Checkpoint cache control and intensive comparison implementation

Commit all current eligible source, tests, documentation and CI configuration on main as requested. Include signed cache metadata primitives, image HTTP ownership, native comparison repairs and KeyLoad/Timescale intensive adapters.

This is a work-in-progress checkpoint. The enabled R101 full development build failed 53 diagnostics; Node and Mongo corrections, final formatter and new-SHA native qualification remain open. Existing native results and source-only review are recorded separately, with no performance or readiness claim.

Author: KSemenenko

.github/workflows/ci.yml

@@ -193,6 +193,10 @@ jobs:
       - name: Qualify exact native topology composition models
         run: |
           dotnet test --project tests/KeyLoad.ComparisonTests --no-build --no-restore --configuration Release --treenode-filter '/*/*/Isolated*Resource*/*'
+          dotnet test --project tests/KeyLoad.ComparisonTests --no-build --no-restore --configuration Release --treenode-filter '/*/*/MongoReadinessResourceTests/*'
+          dotnet test --project tests/KeyLoad.ComparisonTests --no-build --no-restore --configuration Release --treenode-filter '/*/*/MongoReadinessIdentityTests/*'
+          dotnet test --project tests/KeyLoad.ComparisonTests --no-build --no-restore --configuration Release --treenode-filter '/*/*/MongoReadinessTaskFailureTests/*'
+          dotnet test --project tests/KeyLoad.ComparisonTests --no-build --no-restore --configuration Release --treenode-filter '/*/*/IsolatedKurrentVolumeRegressionFailureTests/*'
           dotnet test --project tests/KeyLoad.ComparisonTests --no-build --no-restore --configuration Release --treenode-filter '/*/*/IsolatedKeyLoadAdmissionTests/*'
           dotnet test --project tests/KeyLoad.ComparisonTests --no-build --no-restore --configuration Release --treenode-filter '/*/*/ComparisonResourceLogBufferTests/*'
       - name: Qualify isolated replay admission and native diagnostics

README.md

@@ -249,7 +249,7 @@ Tests use TUnit and Microsoft.Testing.Platform and execute in GitHub Actions. De
 
 The root `.editorconfig` is copied directly from Prostir. Every project enables SDK/static/style analysis with warnings as errors. Edit custom rules under `src/KeyLoad.Analyzers/Features/CodeQuality/` and add real-compilation cases under `tests/KeyLoad.Analyzers.Tests/Features/CodeQuality/`. They attach centrally to consumer projects and report in the IDE and build. Compiler SARIF 2.1 reports live under `artifacts/code-quality/<project>/<configuration>/<framework>/diagnostics.sarif`; CI retains them even when the build fails. See [CodeQuality](docs/Features/CodeQuality.md) for the rule catalog, authoring and applicability, and [current evidence](docs/implementation/code-quality.md) for actual gates.
 
-The [runtime ledger](docs/implementation/runtime-qualification-20261002.md) preserves exact GitHub source SHAs, native suite counts, failures and artifact hashes; [AdminDashboard](docs/Features/AdminDashboard.md) records its separately verified RF3 and browser evidence. The latest joined 06a9 run has unit and image-preparation failures; RF3 and measured comparison stages did not run. Historical successful cases do not qualify newer source. Environmental failure branches, coverage, activation movement, server-resource/performance, endurance and power-loss qualification remain open.
+The [runtime ledger](docs/implementation/runtime-qualification-20261002.md) preserves exact GitHub source SHAs, native suite counts, failures and artifact hashes; [AdminDashboard](docs/Features/AdminDashboard.md) records its separately verified RF3 and browser evidence. The earlier joined [397a run](docs/implementation/runtime-qualification-37097831105.json) fails17 unit cases; RF3, recovery and analyzer tests pass, while scalar and measured comparisons are skipped. Historical successful cases do not qualify newer source. Environmental failure branches, coverage, activation movement, server-resource/performance, endurance and power-loss qualification remain open.
 
 The comparison library/sole CLI host split under [ADR-043](docs/ADR/ADR-043-comparison-library-host.md), immutable harness under [ADR-044](docs/ADR/ADR-044-benchmark-immutable-contracts.md), owned PostgreSQL schema repair under [ADR-045](docs/ADR/ADR-045-postgres-schema-ownership.md), private storage owners under [ADR-046](docs/ADR/ADR-046-storage-private-owners.md) and genuine BenchmarkDotNet library under [ADR-047](docs/ADR/ADR-047-embedded-benchmark-host.md) are source joins awaiting full runtime qualification. The read-only product contract migration preserves JSON/base64 and fingerprints under [ADR-041](docs/ADR/ADR-041-read-only-public-collections.md). Exact-SHA run [37015193756](https://github.com/managedcode/KeyLoad/actions/runs/37015193756) passed all88 analyzer cases and the enabled solution builds; subsequent repairs require renewed verification. Compatible coverage collection, container export and its numeric baseline remain pending. Historical source stages are retained in the [code-quality record](docs/implementation/code-quality.md); the [runtime ledger](docs/implementation/runtime-qualification-20261002.md) records the latest completed candidate run.
 
@@ -300,9 +300,12 @@ No new intensive performance or live publication result is claimed.
 
 The earlier isolated Linux baseline ([run37087909605](https://github.com/managedcode/KeyLoad/actions/runs/37087909605), source `b47409e`) passes source, unit, recovery and RF3 gates. Ten of27 native1/2/3 preflights fail, so the complete270-cell cohort and new performance publication remain blocked. Read/control admission, native diagnostics, document oracle and pinned gossip identity repairs are awaiting exact-source GitHub qualification; the separate intensive TimeSeries corpus/oracle source does not yet implement its native runner/adapters.
 
-The bounded RAM pool, explicit embedded point cache, local coordinated binding, actual-owner observation and test-fixture repairs passed the development build, formatter and static governance checks recorded in the [R83 source receipt](docs/implementation/cache-memory-source-r83.json). The preceding [exact-source native run](docs/implementation/runtime-qualification-37093992229.json) failed:1522/1539 normal unit cases and62/63 RF3 cases passed; scalar was skipped, while164 recovery and118 analyzer cases passed. The17 unit failures are test-side null-key projection and byte/int assertion defects; RF3 failed an election-window queue receive without its required same-ID retry. Their source repairs require a new delivered SHA and complete native gates. The [signed metadata contract](docs/Features/ResourceExecution/CacheControlV1.md) is accepted for unused primitives only; Orleans RF3 controls, coverage and measured benefit remain pending, and server RF3 caches are disabled.
+The bounded RAM pool, embedded point cache and local binding passed the development checks in the [R83 source receipt](docs/implementation/cache-memory-source-r83.json). The newer [d45 native source gates](docs/implementation/cache-native-source-r93.json) pass1583/1583 normal and scalar unit cases with identical IDs and no skips,164/164 recovery plus1000 seeded process-cut rows,118 analyzer cases and63/63 SDK/MCP RF3 cases. All17 earlier identity failures and the byte77 oracle now pass. The comparison workflow concluded with24/27 successful preflight jobs and3 failures; the270-cell matrix did not execute. These source gates provide no performance result. The [R100 wire source receipt](docs/implementation/cache-wire-source-r100.json) binds the complete independent review of34 unused internal signed-metadata files and26 corrected test files. Fresh integrated source gates and delivered-SHA native qualification remain pending. Orleans RF3 controls, product coverage, measured benefit, endurance and power-loss gates remain open; server RF3 caches are disabled.
 
 
 The delivered `2f374fc34` [Linux run37093197474](https://github.com/managedcode/KeyLoad/actions/runs/37093197474) now passes the complete source gates,118 analyzer cases,1483 normal and1483 scalar unit cases,164 process-recovery cases and63 Docker RF3 cases without skips. The [original-source receipt](docs/implementation/isolated-source-qualification-37093197474.json) retains exact report/artifact hashes. Comparative image and diagnostic gates pass;27 native preflights finish16 job successes and11 failures, including two explicit unavailable Neo4j topologies among the successes. Complete270 performance and site publication remain unqualified. The separate TimeSeries pure30 cases pass in both modes, while its bounded runner has36 new declared TUnit cases prepared in source and native adapters/all30 cells remain pending.
 
 The later `2ecbeee4d` [run37093992229](https://github.com/managedcode/KeyLoad/actions/runs/37093992229) fails17 normal unit cases and one RF3 queue-receive case; scalar and native comparison jobs are skipped. The [original-failure receipt](docs/implementation/isolated-current-main-baseline-37093992229.json) preserves the exact reports and artifact hashes. Current repairs and a prepared intensive TimeSeries runner remain unqualified until their delivered-source GitHub gates pass.
+
+
+The fixture-only `d45d7f253` [Linux source qualification](docs/implementation/isolated-source-qualification-37098964980.json) passes normal1583/scalar1583, recovery164, analyzer118 and RF363 without skips; all17 prior fixture failures pass in both modes. The [terminal comparison receipt](docs/implementation/isolated-comparison-terminal-37098964980.json) records24successful native preflight jobs and3failures (Mongo2 image import, Mongo3 priority takeover, Kurrent2 cleanup). Two successful jobs explicitly report unavailable Neo4j Community topologies. Full270 was not allocated; aggregation and refreshed site metrics remain unqualified. New ACK ownership, SDK TimeSeries adapter, SQL and transactional lifecycle source require their own delivered-SHA qualification; TimeSeries6/30 remains incomplete.

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/KurrentClusterVerifier.cs

@@ -35,9 +35,10 @@ public static async Task<KurrentClusterProof> VerifyAsync(string connectionStrin
     }
 
     public static Task<ClusterEvidence> VerifyCopyAsync(KurrentDBClient writer, KurrentDBClient[] nodeClients,
-        HttpClient[] httpClients, ComparisonTopology topology, string stream, KurrentEventData eventData, TimeSpan timeout,
+        HttpClient[] httpClients, ComparisonTopology topology, string stream, KurrentEventData eventData,
+        KurrentStreamOwnership ownership, TimeSpan timeout,
         CancellationToken cancellationToken)
-        => KurrentReplicaProbe.VerifyCopyAsync(writer, nodeClients, httpClients, topology, stream, eventData,
+        => KurrentReplicaProbe.VerifyCopyAsync(writer, nodeClients, httpClients, topology, stream, eventData, ownership,
             timeout, cancellationToken);
 
     internal static async Task<KurrentGossipView[]> ReadReadyViewsAsync(HttpClient[] clients,

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/KurrentConstants.cs

@@ -94,11 +94,17 @@ internal static class KurrentConstants
     public const int ReadLimit = 2;
     public const ulong NativeFirstRevision = 0;
     public const int CanonicalFirstRevision = 1;
-    public const int CleanupTimeoutSeconds = 20;
-    public const int CleanupHostTimeoutSeconds = 30;
+    public const int CleanupTimeoutSeconds = 120;
+    public const int CleanupHostTimeoutSeconds = 180;
     public const int CleanupConcurrency = 16;
     public const string CleanupIncomplete = "KurrentOwnedStreamCleanupIncomplete";
     public const string CleanupDrainFailed = "KurrentOwnedStreamCleanupDrainFailed";
     public const string CleanupInvalidDiagnostic = "KurrentOwnedStreamCleanupInvalidDiagnostic";
+    public const int OwnershipProbeCount = 2;
+    public const string OwnershipInvalidDescriptor = "KurrentStreamOwnershipInvalidDescriptor";
+    public const string OwnershipReservationRejected = "KurrentStreamOwnershipReservationRejected";
+    public const string OwnershipTransitionRejected = "KurrentStreamOwnershipTransitionRejected";
+    public const string OwnershipAlreadyInitialized = "KurrentStreamOwnershipAlreadyInitialized";
+    public const string AppendAcknowledgementMissing = "KurrentStreamAppendAcknowledgementMissing";
     public const int ProbeWaitMilliseconds = 100;
 }

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/KurrentOwnedStreamAppend.cs

@@ -0,0 +1,39 @@
+using KurrentDB.Client;
+using KurrentEventData = KurrentDB.Client.EventData;
+
+namespace KeyLoad.Comparisons.Targets;
+
+internal static class KurrentOwnedStreamAppend
+{
+    internal static async Task<IWriteResult> AppendAsync(KurrentDBClient writer, KurrentStreamOwnership ownership,
+        string stream, KurrentEventData eventData, CancellationToken token)
+    {
+        ArgumentNullException.ThrowIfNull(writer);
+        ArgumentNullException.ThrowIfNull(ownership);
+        ArgumentNullException.ThrowIfNull(eventData);
+        var nativeEventId = eventData.EventId.ToGuid();
+        ownership.Reserve(stream, nativeEventId);
+        IWriteResult result;
+        try
+        {
+            result = await writer.AppendToStreamAsync(stream, StreamState.NoStream, [eventData], cancellationToken: token);
+            if (result is not SuccessResult)
+            {
+                throw new ComparisonFailureException(KurrentConstants.AppendAcknowledgementMissing);
+            }
+        }
+        catch (WrongExpectedVersionException)
+        {
+            ownership.Reject(stream, nativeEventId);
+            throw;
+        }
+        catch (Exception)
+        {
+            ownership.MarkUnknown(stream, nativeEventId);
+            throw;
+        }
+        // No conversion, copy validation or success result can precede this actual ACK transition.
+        ownership.Acknowledge(stream, nativeEventId);
+        return result;
+    }
+}

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/KurrentReplicaProbe.cs

@@ -8,10 +8,11 @@ namespace KeyLoad.Comparisons.Targets;
 internal static class KurrentReplicaProbe
 {
     public static async Task<ClusterEvidence> VerifyCopyAsync(KurrentDBClient writer, KurrentDBClient[] nodeClients,
-        HttpClient[] httpClients, ComparisonTopology topology, string stream, KurrentEventData eventData, TimeSpan timeout,
+        HttpClient[] httpClients, ComparisonTopology topology, string stream, KurrentEventData eventData,
+        KurrentStreamOwnership ownership, TimeSpan timeout,
         CancellationToken cancellationToken)
     {
-        var cut = await AppendAndCaptureCutAsync(writer, stream, eventData, cancellationToken);
+        var cut = await AppendAndCaptureCutAsync(writer, ownership, stream, eventData, cancellationToken);
         using var limit = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
         limit.CancelAfter(timeout);
         try
@@ -59,11 +60,10 @@ public static async Task RequireOriginalEventAsync(KurrentDBClient client, strin
         }
     }
 
-    private static async Task<KurrentAppendCut> AppendAndCaptureCutAsync(KurrentDBClient writer, string stream,
-        KurrentEventData eventData, CancellationToken cancellationToken)
+    private static async Task<KurrentAppendCut> AppendAndCaptureCutAsync(KurrentDBClient writer,
+        KurrentStreamOwnership ownership, string stream, KurrentEventData eventData, CancellationToken cancellationToken)
     {
-        var result = await writer.AppendToStreamAsync(stream, StreamState.NoStream, [eventData],
-            cancellationToken: cancellationToken);
+        var result = await KurrentOwnedStreamAppend.AppendAsync(writer, ownership, stream, eventData, cancellationToken);
         var commit = checked((long)result.LogPosition.CommitPosition);
         var prepare = checked((long)result.LogPosition.PreparePosition);
         if (commit < prepare)

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/KurrentSession.cs

@@ -42,9 +42,8 @@ public async Task<OperationResult> ExecuteAsync(Scenario scenario, BenchmarkDocu
         {
             case Scenario.StreamAppend:
                 var appendStream = target.StreamName(document);
-                target.TrackStream(appendStream);
-                await client.AppendToStreamAsync(appendStream, StreamState.NoStream,
-                    [KurrentTarget.CreateEvent(document)], cancellationToken: cancellationToken);
+                await KurrentOwnedStreamAppend.AppendAsync(client, target.Ownership, appendStream,
+                    KurrentTarget.CreateEvent(document), cancellationToken);
                 return new();
             case Scenario.StreamRead:
                 return new(Event: await ReadEventAsync(document, cancellationToken));

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/KurrentStreamOwnership.cs

@@ -0,0 +1,74 @@
+namespace KeyLoad.Comparisons.Targets;
+
+internal sealed class KurrentStreamOwnership
+{
+    private readonly object gate = new();
+    private readonly Dictionary<string, KurrentStreamOwnershipEntry> entries = new(StringComparer.Ordinal);
+
+    internal KurrentStreamOwnership(ComparisonOptions options)
+    {
+        ArgumentNullException.ThrowIfNull(options);
+        options.Validate();
+        Capacity = checked(options.Documents + options.Repetitions * checked(options.Warmup + options.Operations)
+            + KurrentConstants.OwnershipProbeCount);
+    }
+
+    internal int Capacity { get; }
+    internal int Count
+    {
+        get
+        {
+            lock (gate)
+            {
+                return entries.Count;
+            }
+        }
+    }
+
+    internal void Reserve(string stream, Guid nativeEventId)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(stream);
+        if (nativeEventId == Guid.Empty)
+        {
+            throw new ArgumentException(KurrentConstants.OwnershipInvalidDescriptor, nameof(nativeEventId));
+        }
+        lock (gate)
+        {
+            if (entries.Count >= Capacity || !entries.TryAdd(stream, new(nativeEventId, KurrentStreamOwnershipState.Reserved)))
+            {
+                throw new ComparisonFailureException(KurrentConstants.OwnershipReservationRejected);
+            }
+        }
+    }
+
+    internal void Acknowledge(string stream, Guid nativeEventId)
+        => Complete(stream, nativeEventId, KurrentStreamOwnershipState.Acknowledged);
+
+    internal void Reject(string stream, Guid nativeEventId)
+        => Complete(stream, nativeEventId, KurrentStreamOwnershipState.Rejected);
+
+    internal void MarkUnknown(string stream, Guid nativeEventId)
+        => Complete(stream, nativeEventId, KurrentStreamOwnershipState.Unknown);
+
+    internal string[] SnapshotAcknowledged()
+    {
+        lock (gate)
+        {
+            return entries.Where(pair => pair.Value.State == KurrentStreamOwnershipState.Acknowledged)
+                .Select(pair => pair.Key).ToArray();
+        }
+    }
+
+    private void Complete(string stream, Guid nativeEventId, KurrentStreamOwnershipState state)
+    {
+        lock (gate)
+        {
+            if (!entries.TryGetValue(stream, out var entry) || entry.NativeEventId != nativeEventId ||
+                entry.State != KurrentStreamOwnershipState.Reserved)
+            {
+                throw new ComparisonFailureException(KurrentConstants.OwnershipTransitionRejected);
+            }
+            entries[stream] = entry with { State = state };
+        }
+    }
+}

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/KurrentStreamOwnershipEntry.cs

@@ -0,0 +1,3 @@
+namespace KeyLoad.Comparisons.Targets;
+
+internal readonly record struct KurrentStreamOwnershipEntry(Guid NativeEventId, KurrentStreamOwnershipState State);

benchmarks/KeyLoad.Comparisons/Features/BenchmarkComparisons/KurrentStreamOwnershipState.cs

@@ -0,0 +1,9 @@
+namespace KeyLoad.Comparisons.Targets;
+
+internal enum KurrentStreamOwnershipState
+{
+    Reserved,
+    Acknowledged,
+    Rejected,
+    Unknown,
+}