fix: release workspace SQLite pools when hosts shut down

Author: Telli

docs/superpowers/plans/2026-10-06-dotnet-intelligence-verification-mcp-distribution.md

@@ -438,4 +438,5 @@ No branches, commits, PRs, issues, or production releases should be created as p
 - Semantic loads now read evaluated test flags and restore paths, retain installed SDK generators, expose excluded custom-generator limitations, and reject unverified rename. Rename compares compiler errors by code and mapped location. Approval waits release the global cache gate while concurrent calls share one approved load; failed loads always dispose their build host, and unrelated inaccessible directories are skipped.
 - Verification now serializes through the configured lock deadline, runs multi-targeted project paths once, classifies prerequisite errors by diagnostic code, preserves cached build diagnostics across test-only/prerequisite failures, and supports a validated configurable automatic timeout (600 seconds by default). Empty valid TRX results are explicitly skipped. Release package smoke accepts and checks the exact prepacked release artifacts.
 - Local follow-up validation: warning-free Release solution/example build; 414 passing tests (280 unit, 114 integration, 20 parity); coverage above the existing 38 percent floor; all four agent scenarios and their gates; DocFX with warnings as errors; all 22 exact prepacked artifacts installed successfully through an isolated clean SDK consumer and CLI tool smoke. Cross-platform PR and merged-head checks remain the remote merge gates.
+- Windows CI follow-up: knowledge and usage stores release their own idle SQLite pools on host disposal, allowing database files to be removed on Windows. A host lifecycle regression checks exclusive database access after shutdown. Cancellation parity now observes startup failures, always cancels/drains its task, and uses the existing longer Windows startup allowance. The 23 focused lifecycle/HTTP/verification tests and all 20 parity cases pass locally before the next cross-platform CI run.
 - Release acceptance still pending externally: win-x64, win-arm64, linux-x64, linux-arm64 and osx-x64 must execute their configured matching CI jobs. No cross-publish is counted as runtime acceptance, and no packages, tag, commit, PR or GitHub release were published by this implementation run.

src/SharpClaw.Code.Memory/Services/SqliteWorkspaceKnowledgeStore.cs

@@ -1,5 +1,6 @@
 using System.Globalization;
 using System.Data.Common;
+using System.Collections.Concurrent;
 using Microsoft.Data.Sqlite;
 using SharpClaw.Code.Infrastructure.Abstractions;
 using SharpClaw.Code.Memory.Abstractions;
@@ -14,8 +15,9 @@ namespace SharpClaw.Code.Memory.Services;
 public sealed class SqliteWorkspaceKnowledgeStore(
     IFileSystem fileSystem,
     IPathService pathService,
-    IRuntimeStoragePathResolver storagePathResolver) : IWorkspaceKnowledgeStore
+    IRuntimeStoragePathResolver storagePathResolver) : IWorkspaceKnowledgeStore, IDisposable
 {
+    private readonly ConcurrentDictionary<string, byte> connectionPools = new(StringComparer.Ordinal);
     private const string WorkspaceKnowledgeDirectoryName = "knowledge";
     private const string WorkspaceKnowledgeFileName = "knowledge.db";
     private const string UserMemoryFileName = "user-memory.db";
@@ -464,15 +466,32 @@ private async Task<SqliteConnection> OpenConnectionAsync(string dbPath, Cancella
             fileSystem.CreateDirectory(directory);
         }
 
-        var connection = new SqliteConnection(new SqliteConnectionStringBuilder
+        var connectionString = new SqliteConnectionStringBuilder
         {
             DataSource = dbPath,
             Mode = SqliteOpenMode.ReadWriteCreate,
             Cache = SqliteCacheMode.Shared,
-        }.ToString());
-        await connection.OpenAsync(cancellationToken).ConfigureAwait(false);
-        await EnsureSchemaAsync(connection, cancellationToken).ConfigureAwait(false);
-        return connection;
+        }.ToString();
+        connectionPools.TryAdd(connectionString, 0);
+        var connection = new SqliteConnection(connectionString);
+        try
+        {
+            await connection.OpenAsync(cancellationToken).ConfigureAwait(false);
+            await EnsureSchemaAsync(connection, cancellationToken).ConfigureAwait(false);
+            return connection;
+        }
+        catch { await connection.DisposeAsync().ConfigureAwait(false); throw; }
+    }
+
+    /// <summary>Releases this store's idle database handles when its host shuts down, including on Windows.</summary>
+    public void Dispose()
+    {
+        foreach (var connectionString in connectionPools.Keys)
+        {
+            using var connection = new SqliteConnection(connectionString);
+            SqliteConnection.ClearPool(connection);
+        }
+        connectionPools.Clear();
     }
 
     private static async Task EnsureSchemaAsync(SqliteConnection connection, CancellationToken cancellationToken)

src/SharpClaw.Code.Runtime/Server/SqliteUsageMeteringStore.cs

@@ -1,4 +1,5 @@
 using System.Globalization;
+using System.Collections.Concurrent;
 using Microsoft.Data.Sqlite;
 using SharpClaw.Code.Infrastructure.Abstractions;
 using SharpClaw.Code.Protocol.Models;
@@ -12,8 +13,9 @@ namespace SharpClaw.Code.Runtime.Server;
 public sealed class SqliteUsageMeteringStore(
     IFileSystem fileSystem,
     IPathService pathService,
-    IRuntimeStoragePathResolver storagePathResolver) : IUsageMeteringStore
+    IRuntimeStoragePathResolver storagePathResolver) : IUsageMeteringStore, IDisposable
 {
+    private readonly ConcurrentDictionary<string, byte> connectionPools = new(StringComparer.Ordinal);
     /// <inheritdoc />
     public async Task AppendAsync(string workspaceRoot, UsageMeteringRecord record, CancellationToken cancellationToken)
     {
@@ -138,10 +140,27 @@ private async Task<SqliteConnection> OpenConnectionAsync(string workspaceRoot, C
             ?? storagePathResolver.GetTelemetryRoot(normalizedWorkspace);
         fileSystem.CreateDirectory(telemetryRoot);
 
-        var connection = new SqliteConnection($"Data Source={dbPath}");
-        await connection.OpenAsync(cancellationToken).ConfigureAwait(false);
-        await EnsureSchemaAsync(connection, cancellationToken).ConfigureAwait(false);
-        return connection;
+        var connectionString = new SqliteConnectionStringBuilder { DataSource = dbPath }.ToString();
+        connectionPools.TryAdd(connectionString, 0);
+        var connection = new SqliteConnection(connectionString);
+        try
+        {
+            await connection.OpenAsync(cancellationToken).ConfigureAwait(false);
+            await EnsureSchemaAsync(connection, cancellationToken).ConfigureAwait(false);
+            return connection;
+        }
+        catch { await connection.DisposeAsync().ConfigureAwait(false); throw; }
+    }
+
+    /// <summary>Releases this host's idle metering database handles without clearing unrelated workspace pools.</summary>
+    public void Dispose()
+    {
+        foreach (var connectionString in connectionPools.Keys)
+        {
+            using var connection = new SqliteConnection(connectionString);
+            SqliteConnection.ClearPool(connection);
+        }
+        connectionPools.Clear();
     }
 
     private static async Task EnsureSchemaAsync(SqliteConnection connection, CancellationToken cancellationToken)

tests/SharpClaw.Code.IntegrationTests/Runtime/WorkspaceDatabaseLifecycleTests.cs

@@ -0,0 +1,38 @@
+using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
+using SharpClaw.Code.Memory.Abstractions;
+using SharpClaw.Code.Runtime;
+using SharpClaw.Code.Telemetry.Abstractions;
+
+namespace SharpClaw.Code.IntegrationTests.Runtime;
+
+/// <summary>Verifies database handles follow the host lifecycle, including Windows file sharing rules.</summary>
+public sealed class WorkspaceDatabaseLifecycleTests
+{
+    /// <summary>A disposed host releases its knowledge and metering databases for exclusive access and workspace removal.</summary>
+    [Fact]
+    public async Task Host_disposal_releases_knowledge_and_usage_database_handles()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "sharpclaw-db-lifecycle-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(root);
+        try
+        {
+            await File.WriteAllTextAsync(Path.Combine(root, "Source.cs"), "public class Source { }");
+            using (var provider = new ServiceCollection().AddSharpClawRuntime().BuildServiceProvider())
+            {
+                await provider.GetRequiredService<IWorkspaceIndexService>().RefreshAsync(root, CancellationToken.None);
+                await provider.GetRequiredService<IUsageMeteringStore>().GetSummaryAsync(root, new(), CancellationToken.None);
+            }
+            var databases = Directory.GetFiles(root, "*.db", SearchOption.AllDirectories);
+            databases.Should().HaveCount(2);
+            foreach (var database in databases)
+            {
+                using var exclusive = new FileStream(database, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
+                exclusive.Length.Should().BeGreaterThan(0);
+            }
+            Directory.Delete(root, recursive: true);
+            Directory.Exists(root).Should().BeFalse();
+        }
+        finally { if (Directory.Exists(root)) Directory.Delete(root, recursive: true); }
+    }
+}

tests/SharpClaw.Code.ParityHarness/ParityScenarioTests.cs

@@ -327,16 +327,31 @@ private async Task RunPromptWithCancelAfterTurnStartAsync(
     {
         using var cts = new CancellationTokenSource();
         var runTask = runtime.RunPromptAsync(request, cts.Token);
-        await WaitForActiveTurnAsync(store, CancellationToken.None);
-        cts.CancelAfter(cancelAfter);
-        await runTask.ConfigureAwait(false);
+        try
+        {
+            await WaitForActiveTurnAsync(store, runTask, CancellationToken.None);
+            cts.CancelAfter(cancelAfter);
+            await runTask.ConfigureAwait(false);
+        }
+        finally
+        {
+            cts.Cancel();
+            try { await runTask.ConfigureAwait(false); }
+            catch (OperationCanceledException) { }
+        }
     }
 
-    private async Task WaitForActiveTurnAsync(ISessionStore store, CancellationToken cancellationToken)
+    private async Task WaitForActiveTurnAsync(ISessionStore store, Task runTask, CancellationToken cancellationToken)
     {
         // Startup is separate from the cancellation deadline and can be slow on loaded Windows runners.
-        for (var attempt = 0; attempt < 600; attempt++)
+        var maxAttempts = OperatingSystem.IsWindows() ? 1800 : 600;
+        for (var attempt = 0; attempt < maxAttempts; attempt++)
         {
+            if (runTask.IsCompleted)
+            {
+                await runTask.ConfigureAwait(false);
+                throw new InvalidOperationException("The parity runtime completed before an active turn could be observed.");
+            }
             var session = await store.GetLatestAsync(_workspace, cancellationToken).ConfigureAwait(false);
             if (!string.IsNullOrWhiteSpace(session?.ActiveTurnId))
             {