Preserve tombstones and stream reports; repair real SDK qualification

Preserve empty-versus-missing storage bytes, strict MCP framing and negotiated SDK transport. Stream immutable report arrays without copying samples. Correct real admission/authority/catalog/quota fixtures and retain bounded startup/test evidence.
Full enabled development build and static checks precede this checkpoint; complete exact-SHA GitHub runtime qualification remains pending. Shared main HEAD/index and independent website work are preserved.

Author: KSemenenko

.github/workflows/ci.yml

@@ -27,6 +27,7 @@ jobs:
         with:
           name: analyzer-rule-evidence
           path: |
+            TestResults/**
             tests/KeyLoad.Analyzers.Tests/**/TestResults/**
             artifacts/code-quality/**
           if-no-files-found: error
@@ -87,6 +88,7 @@ jobs:
         with:
           name: docker-rf3-qualification
           path: |
+            TestResults/**
             tests/KeyLoad.IntegrationTests/**/TestResults/**
             artifacts/qualification/**
           if-no-files-found: error
@@ -141,6 +143,15 @@ jobs:
           name: comparison-suite
           path: artifacts/comparisons/**
           if-no-files-found: warn
+      - name: Retain comparison test result reports
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        if: always()
+        with:
+          name: comparison-test-results
+          path: |
+            TestResults/**
+            tests/KeyLoad.ComparisonTests/**/TestResults/**
+          if-no-files-found: warn
       - name: Retain comparison compiler diagnostic reports
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         if: always()

README.md

@@ -233,17 +233,17 @@ 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.
 
-Commit [`3559225a5f918160e46e32c9a812c3f71790e382`](https://github.com/managedcode/KeyLoad/commit/3559225a5f918160e46e32c9a812c3f71790e382) is on `main`. Its full 25-project Release build passed locally before delivery. Exact-SHA GitHub run [36988949282](https://github.com/managedcode/KeyLoad/actions/runs/36988949282) failed: analyzer tests passed 84/88, comparison tests 2/4, and RF3 integration tests 3/23. Governance also failed on all three OSes because its required plan file was ignored, and Windows normalized the preserved `AGENTS.md` prefix; the unit and process-recovery suites did not run because governance stopped those jobs. The first repair set is in progress; no exact-SHA qualification is claimed. Numeric coverage collection and its baseline are still not configured.
+Commit [`3559225a5f918160e46e32c9a812c3f71790e382`](https://github.com/managedcode/KeyLoad/commit/3559225a5f918160e46e32c9a812c3f71790e382) is the shared `main` baseline. Repair checkpoint [`6949fa0c3099443c6f34f91245ab8064ef22c63c`](https://github.com/managedcode/KeyLoad/commit/6949fa0c3099443c6f34f91245ab8064ef22c63c) is on `codex/runtime-qualification-20261002`. Its exact-SHA GitHub run [37005805424](https://github.com/managedcode/KeyLoad/actions/runs/37005805424) passed the full solution build, formatter, governance and 88/88 analyzer regressions on all three OSes. Runtime qualification failed: unit tests passed 719/770 on Ubuntu, 717/770 on macOS and 720/770 on Windows; RF3 passed 6/26 and comparisons 2/4. Recovery and measured comparison profiles did not execute after those failures. Subsequent scoped repairs await another exact-SHA run. The [runtime ledger](docs/implementation/runtime-qualification-20261002.md) retains each failure, job and artifact receipt. Numeric coverage collection and its baseline are still not configured.
 
-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 qualification. The read-only product contract migration preserves JSON/base64 and fingerprints under [ADR-041](docs/ADR/ADR-041-read-only-public-collections.md). The exact-SHA analyzer run executed 88 TUnit cases: 84 passed and four span/cohesion cases failed. Numeric complexity rules are configured, while compatible coverage collection, container export and its baseline remain pending. See the [current source and gate evidence](docs/implementation/code-quality.md) and exact run [36988949282](https://github.com/managedcode/KeyLoad/actions/runs/36988949282).
+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 [37005805424](https://github.com/managedcode/KeyLoad/actions/runs/37005805424) passed all 88 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.
 
-Memory and read-work repairs are in progress across storage, SQL/search, events, time series, graph, messaging, replication and transport. The [located repair inventory](docs/implementation/memory-performance.md) records authored changes and remaining proof separately. Earlier baseline CI [36936319423](https://github.com/managedcode/KeyLoad/actions/runs/36936319423) passed on its earlier SHA; candidate CI [36988949282](https://github.com/managedcode/KeyLoad/actions/runs/36988949282) failed and does not qualify correctness or performance.
+Memory and read-work repairs are in progress across storage, SQL/search, events, time series, graph, messaging, replication and transport. The [located repair inventory](docs/implementation/memory-performance.md) records authored changes and remaining proof separately. Earlier baseline CI [36936319423](https://github.com/managedcode/KeyLoad/actions/runs/36936319423) passed on its earlier SHA; candidate CI [37005805424](https://github.com/managedcode/KeyLoad/actions/runs/37005805424) failed and does not qualify system correctness or performance. Portable vector scoring is present; further SIMD validation, software-fallback checks and matched RF3 resource/latency measurements remain open.
 
 All test qualification and load measurements run in GitHub Actions. The comparison harness uses deterministic JSON, float32 vectors and cyclic graphs, verifies the complete returned payload, and retains every measured attempt, including failures. Reports include useful throughput, p50/p95/p99, separate enqueue/receive/ACK timings and load-generator CPU/allocation/RSS. These resource metrics describe the client process. See the [comparison methodology](docs/implementation/comparative-benchmarks.md).
 
 The [public benchmark lab](https://www.keyload.cloud/) displays verified CI reports with workload, scenario, measure and repetition controls. CI runs a correctness smoke and two measured profiles with 1 KiB/16 KiB documents, eight/four clients and three/five graph hops. GitHub Pages publishes their reports only after the complete CI workflow succeeds; [website operations](docs/implementation/website.md) describes provenance and the custom domain. Current external baselines are single-node and contracts differ; matched-durability, database resource budgets, Marten/Wolverine and scaling qualification remain planned. These development observations do not establish an equal-durability winner or production readiness.
 
-The separate TimeSeries comparison profile is implemented under [ADR-050](docs/ADR/ADR-050-timeseries-timescale-comparison.md). Its CI test starts a digest-pinned, ephemeral TimescaleDB container, sends the same UTC samples through KeyLoad's RF3 .NET SDK and TimescaleDB's hypertable, and checks bucket results against the published `ManagedCode.TimeSeries` in-memory aggregation library. The library is not a persistence provider, and the Timescale container has no cross-run data volume; reports label each guarantee separately. Candidate run 36988949282 reached the comparison suite but failed its Timescale resource-name collision and a container digest assertion that included Aspire-built KeyLoad images. Both source corrections are in progress; a new exact-SHA run is still required.
+The separate TimeSeries comparison profile is authored under [ADR-050](docs/ADR/ADR-050-timeseries-timescale-comparison.md). Its test is designed to start a digest-pinned, ephemeral TimescaleDB container, send identical UTC samples through KeyLoad's RF3 .NET SDK and TimescaleDB's hypertable, and verify bucket results against the published `ManagedCode.TimeSeries` in-memory aggregation library. The library is not a persistence provider, and the Timescale container has no cross-run data volume; reports label each guarantee separately. Candidate run 37005805424 failed the native image assertion before Timescale startup. The source assertion now preserves Aspire's native repository/digest representation; actual database startup, workload, schema isolation and cleanup still need exact-SHA GitHub qualification.
 
 The product website redesign is in progress under [ADR-040](docs/ADR/ADR-040-static-site-threejs-evidence.md): a product introduction, a conceptual Three.js RF3 illustration and the complete evidence workspace. Its independent TUnit site suite runs in GitHub Actions against authentic historical reports. Website source, measured source and raw hashes stay distinct; the preview does not qualify current database changes or publish the pending nine-engine comparison profiles.
 

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

@@ -0,0 +1,55 @@
+using System.Collections.Immutable;
+using System.Text.Json;
+
+namespace KeyLoad.Comparisons;
+
+/// <summary>Exposes an immutable array through a repeatable, allocation-bounded async enumerable.</summary>
+internal static class ImmutableArrayAsyncView
+{
+    internal const string InvalidCollectionMessage = "A required collection must be an initialized JSON array.";
+
+    internal static IAsyncEnumerable<T> Create<T>(ImmutableArray<T> values) => Create(values, static value => value);
+
+    internal static IAsyncEnumerable<TResult> Create<T, TResult>(ImmutableArray<T> values, Func<T, TResult> project)
+    {
+        ArgumentNullException.ThrowIfNull(project);
+        if (values.IsDefault)
+        {
+            throw new JsonException(InvalidCollectionMessage);
+        }
+
+        return new View<T, TResult>(values, project);
+    }
+
+    private sealed class View<TSource, TResult>(ImmutableArray<TSource> values, Func<TSource, TResult> project)
+        : IAsyncEnumerable<TResult>
+    {
+        public IAsyncEnumerator<TResult> GetAsyncEnumerator(CancellationToken cancellationToken = default) =>
+            new Enumerator<TSource, TResult>(values, project, cancellationToken);
+    }
+
+    private sealed class Enumerator<TSource, TResult>(ImmutableArray<TSource> values, Func<TSource, TResult> project,
+        CancellationToken cancellationToken) : IAsyncEnumerator<TResult>
+    {
+        private int _index = -1;
+        private TResult? _current;
+
+        public TResult Current => _current!;
+
+        public ValueTask<bool> MoveNextAsync()
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var next = _index + 1;
+            if (next >= values.Length)
+            {
+                return ValueTask.FromResult(false);
+            }
+
+            _index = next;
+            _current = project(values[next]);
+            return ValueTask.FromResult(true);
+        }
+
+        public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+    }
+}

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

@@ -0,0 +1,20 @@
+using System.Text.Json;
+
+namespace KeyLoad.Comparisons;
+
+/// <summary>Write-only case projection which streams its existing sample array.</summary>
+internal sealed record StreamedComparisonCase(string Target, Scenario Scenario, int Repetition, string Status,
+    string? Detail, Measurement? Measurement, IAsyncEnumerable<OperationSample> Samples)
+{
+    internal static StreamedComparisonCase Create(ComparisonCase comparisonCase)
+    {
+        if (comparisonCase.Samples.IsDefault)
+        {
+            throw new JsonException(ImmutableArrayAsyncView.InvalidCollectionMessage);
+        }
+
+        var samples = ImmutableArrayAsyncView.Create(comparisonCase.Samples);
+        return new StreamedComparisonCase(comparisonCase.Target, comparisonCase.Scenario, comparisonCase.Repetition,
+            comparisonCase.Status, comparisonCase.Detail, comparisonCase.Measurement, samples);
+    }
+}

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

@@ -0,0 +1,35 @@
+using System.Collections.Immutable;
+using System.Text.Json;
+
+namespace KeyLoad.Comparisons;
+
+/// <summary>Write-only report projection which streams its existing case array.</summary>
+internal sealed record StreamedComparisonReport(int SchemaVersion, Guid RunId, DateTimeOffset StartedAt,
+    ComparisonOptions Options, string DatasetSha256, string LoadModel, string HostOs, string Architecture,
+    int LogicalProcessors, string Runtime, string Storage, string? SourceRevision,
+    ImmutableArray<TargetProfile> Targets, IAsyncEnumerable<StreamedComparisonCase> Cases)
+{
+    /// <summary>Gets GitHub Actions provenance for the report, when available.</summary>
+    public GitHubProvenance? Provenance { get; init; }
+
+    /// <summary>Gets the load-generator image reference, when available.</summary>
+    public string? LoadGeneratorImage { get; init; }
+
+    internal static StreamedComparisonReport Create(ComparisonReport report)
+    {
+        ArgumentNullException.ThrowIfNull(report);
+        if (report.Cases.IsDefault)
+        {
+            throw new JsonException(ImmutableArrayAsyncView.InvalidCollectionMessage);
+        }
+
+        var cases = ImmutableArrayAsyncView.Create(report.Cases, StreamedComparisonCase.Create);
+        return new StreamedComparisonReport(report.SchemaVersion, report.RunId, report.StartedAt, report.Options,
+            report.DatasetSha256, report.LoadModel, report.HostOs, report.Architecture, report.LogicalProcessors,
+            report.Runtime, report.Storage, report.SourceRevision, report.Targets, cases)
+        {
+            Provenance = report.Provenance,
+            LoadGeneratorImage = report.LoadGeneratorImage
+        };
+    }
+}

benchmarks/KeyLoad.Comparisons/ReportWriter.cs

@@ -33,7 +33,7 @@ public static async Task WriteAsync(ComparisonReport report, string directory, C
             Options = FileOptions.Asynchronous | FileOptions.SequentialScan
         }))
         {
-            await JsonSerializer.SerializeAsync(stream, report, JsonOptions, cancellationToken).ConfigureAwait(false);
+            await JsonSerializer.SerializeAsync(stream, StreamedComparisonReport.Create(report), JsonOptions, cancellationToken).ConfigureAwait(false);
         }
         cancellationToken.ThrowIfCancellationRequested();
         await File.WriteAllTextAsync(Path.Combine(directory, MarkdownFileName), Markdown(report), cancellationToken).ConfigureAwait(false);