Checkpoint all current runtime journal and quality changes

Commit the complete current working-tree scope on main at the owner's request.

Validation: the last canonical Release solution snapshot failed with 59 CS0103
errors in Abstractions and no source drift during that build. The owned
Diagnostics build/format passed, and 5/5 frozen coverage-threshold controls passed.
Full product test and coverage gates remain open; this checkpoint is not
acceptance or production qualification.

Author: KSemenenko

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Benchmarks/EmbeddedBenchmarks.cs

@@ -45,7 +45,7 @@ public void Setup()
             throw new InvalidOperationException(ActiveSetupMessage);
         }
 
-        var candidate = new EmbeddedBenchmarkResources();
+        var candidate = new EmbeddedBenchmarkResources(EmbeddedBenchmarkRuntimeRegistration.Read());
         var initialized = false;
         try
         {
@@ -108,7 +108,7 @@ protected virtual void Dispose(bool disposing)
     private EmbeddedBenchmarkResources RequireResources()
         => resources ?? throw new InvalidOperationException(EmbeddedBenchmarkResources.InactiveFixtureMessage);
 
-    private sealed class EmbeddedBenchmarkResources : IDisposable
+    private sealed class EmbeddedBenchmarkResources(EmbeddedBenchmarkRuntimeOptions options) : IDisposable
     {
         internal const string InactiveFixtureMessage = "The benchmark fixture is not initialized.";
         private const string GuidFormat = "N";
@@ -123,8 +123,9 @@ internal DatabaseEngine Database
 
         internal void Initialize(PartitionRef partition)
         {
-            store = new(new(directory));
-            database = new(store, new AuthorizationPolicy());
+            store = new(new(directory), options.Storage, options.PointCache);
+            database = new(store, new AuthorizationPolicy(), options.Database, options.DueWork, options.EventSource,
+                options.Messaging);
             database.Bootstrap(new(PrincipalId, PrincipalScope,
                 [new(Wildcard, Wildcard, Capability.All)], [Wildcard])
             { ClusterAdministrator = true },

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Benchmarks/ScaledStorageReadBenchmarks.cs

@@ -66,7 +66,7 @@ public void Setup()
             throw new ArgumentOutOfRangeException(nameof(RecordCount), InvalidCountMessage);
         }
 
-        _fixture = new ScaledRawStorageFixture(RecordCount, PayloadBytes);
+        _fixture = new ScaledRawStorageFixture(RecordCount, PayloadBytes, ScaledStorageExecutionRegistration.Read());
     }
 
     /// <summary>Consumes one million checked sequential actual record identities.</summary>

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Configuration/BenchmarkScenarioOptionsRegistration.cs

@@ -0,0 +1,19 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
+
+namespace KeyLoad.BenchmarkScenarios.Features.BenchmarkComparisons;
+
+/// <summary>Binds standalone native fixtures before they acquire storage ownership.</summary>
+[ConfigurationBinding]
+internal static class BenchmarkScenarioOptionsRegistration
+{
+    internal static IOptions<T> Read<T>(IConfiguration configuration, string section,
+        Func<T, bool> validate, string message) where T : class, new()
+    {
+        var options = new OptionsManager<T>(new OptionsFactory<T>(
+            [new ConfigureFromConfigurationOptions<T>(configuration.GetSection(section))], [],
+            [new ValidateOptions<T>(Options.DefaultName, validate, message)]));
+        _ = options.Value;
+        return options;
+    }
+}

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Configuration/EmbeddedBenchmarkRuntimeOptions.cs

@@ -0,0 +1,36 @@
+using KeyLoad.Core;
+using KeyLoad.Storage.ZoneTree;
+using KeyLoad.Storage.ZoneTree.Features.ResourceExecution;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
+
+namespace KeyLoad.BenchmarkScenarios.Features.BenchmarkComparisons;
+
+/// <summary>Holds the validated native snapshots borrowed by an embedded benchmark owner.</summary>
+internal sealed record EmbeddedBenchmarkRuntimeOptions(IOptions<DatabaseLimits> Database,
+    IOptions<DueWorkExecutionOptions> DueWork, IOptions<EventSourceExecutionOptions> EventSource,
+    IOptions<MessagingExecutionOptions> Messaging, IOptions<ZoneTreeStorageExecutionOptions> Storage,
+    IOptions<ZoneTreePointCacheExecutionOptions> PointCache);
+
+/// <summary>Binds the actual generated runner's environment to native fixture policies.</summary>
+[ConfigurationBinding]
+internal static class EmbeddedBenchmarkRuntimeRegistration
+{
+    internal static EmbeddedBenchmarkRuntimeOptions Read()
+    {
+        using var configuration = new ConfigurationBuilder().AddEnvironmentVariables().Build();
+        return new(
+            BenchmarkScenarioOptionsRegistration.Read<DatabaseLimits>(configuration, DatabaseLimits.SectionName,
+                settings => settings.IsValid(), DatabaseLimits.ValidationMessage),
+            BenchmarkScenarioOptionsRegistration.Read<DueWorkExecutionOptions>(configuration, DueWorkExecutionOptions.SectionName,
+                settings => settings.IsValid(), DueWorkExecutionOptions.ValidationMessage),
+            BenchmarkScenarioOptionsRegistration.Read<EventSourceExecutionOptions>(configuration, EventSourceExecutionOptions.SectionName,
+                settings => settings.IsValid(), EventSourceExecutionOptions.ValidationMessage),
+            BenchmarkScenarioOptionsRegistration.Read<MessagingExecutionOptions>(configuration, MessagingExecutionOptions.SectionName,
+                settings => settings.IsValid(), MessagingExecutionOptions.ValidationMessage),
+            BenchmarkScenarioOptionsRegistration.Read<ZoneTreeStorageExecutionOptions>(configuration, ZoneTreeStorageExecutionOptions.SectionName,
+                settings => settings.IsValid(), ZoneTreeStorageExecutionOptions.ValidationMessage),
+            BenchmarkScenarioOptionsRegistration.Read<ZoneTreePointCacheExecutionOptions>(configuration, ZoneTreePointCacheExecutionOptions.SectionName,
+                settings => settings.IsValid(), ZoneTreePointCacheExecutionOptions.ValidationMessage));
+    }
+}

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Configuration/ScaledStorageExecutionOptions.cs

@@ -0,0 +1,46 @@
+using Microsoft.Extensions.Options;
+
+namespace KeyLoad.BenchmarkScenarios.Features.BenchmarkComparisons;
+
+/// <summary>Bounds standalone scaled-fixture preparation and retained process memory.</summary>
+[ConfigurationOptions]
+public sealed class ScaledStorageExecutionOptions
+{
+    /// <summary>The native benchmark execution section.</summary>
+    public const string SectionName = "ScaledStorageExecution";
+    /// <summary>Safe rejection before scaled-fixture admission.</summary>
+    public const string ValidationMessage = "Scaled storage preparation, memory and mutable-segment budgets must be positive and consistent.";
+    private const int DefaultPreparationMinutes = 20;
+    private const long DefaultMaximumProcessBytes = 12_884_901_888;
+    private const long DefaultRequiredHeadroomBytes = 2_147_483_648;
+    private const long DefaultQualificationCapacityBytes = 15_032_385_536;
+    private const int DefaultMutableSegmentRecords = 1000;
+    private const int MaximumPreparationHours = 24;
+
+    /// <summary>The full preparation deadline including capacity admission and verification.</summary>
+    public TimeSpan PreparationTimeout { get; set; } = TimeSpan.FromMinutes(DefaultPreparationMinutes);
+    /// <summary>The observed process memory ceiling for native scaled fixtures.</summary>
+    public long MaximumProcessBytes { get; set; } = DefaultMaximumProcessBytes;
+    /// <summary>The available process memory reserved beyond measured retention.</summary>
+    public long RequiredHeadroomBytes { get; set; } = DefaultRequiredHeadroomBytes;
+    /// <summary>The available memory required for qualification-sized fixture admission.</summary>
+    public long MinimumQualificationCapacityBytes { get; set; } = DefaultQualificationCapacityBytes;
+    /// <summary>The minimum native mutable-segment capacity before corpus-based sizing.</summary>
+    public int MinimumMutableSegmentRecords { get; set; } = DefaultMutableSegmentRecords;
+
+    /// <summary>Checks consistent, positive memory admission and a native timer-safe deadline.</summary>
+    /// <returns>Whether native fixture ownership can begin.</returns>
+    public bool IsValid() => PreparationTimeout > TimeSpan.Zero
+        && PreparationTimeout <= TimeSpan.FromHours(MaximumPreparationHours)
+        && MaximumProcessBytes > 0 && RequiredHeadroomBytes > 0
+        && MaximumProcessBytes <= long.MaxValue - RequiredHeadroomBytes
+        && MinimumQualificationCapacityBytes >= MaximumProcessBytes + RequiredHeadroomBytes
+        && MinimumMutableSegmentRecords > 0;
+
+    /// <summary>Rejects invalid standalone composition before storage allocation.</summary>
+    public void Validate()
+    {
+        if (!IsValid())
+        { throw new OptionsValidationException(SectionName, typeof(ScaledStorageExecutionOptions), [ValidationMessage]); }
+    }
+}

benchmarks/KeyLoad.BenchmarkScenarios/Features/BenchmarkComparisons/Configuration/ScaledStorageExecutionRegistration.cs

@@ -0,0 +1,17 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
+
+namespace KeyLoad.BenchmarkScenarios.Features.BenchmarkComparisons;
+
+/// <summary>Binds scaled-fixture policy from the actual native generated runner's environment.</summary>
+[ConfigurationBinding]
+internal static class ScaledStorageExecutionRegistration
+{
+    internal static IOptions<ScaledStorageExecutionOptions> Read()
+    {
+        using var configuration = new ConfigurationBuilder().AddEnvironmentVariables().Build();
+        return BenchmarkScenarioOptionsRegistration.Read<ScaledStorageExecutionOptions>(configuration,
+            ScaledStorageExecutionOptions.SectionName, settings => settings.IsValid(),
+            ScaledStorageExecutionOptions.ValidationMessage);
+    }
+}

benchmarks/KeyLoad.BenchmarkScenarios/KeyLoad.BenchmarkScenarios.csproj

@@ -8,6 +8,8 @@
     <ProjectReference Include="../../src/KeyLoad.Security/KeyLoad.Security.csproj" />
     <ProjectReference Include="../../src/KeyLoad.Storage.ZoneTree/KeyLoad.Storage.ZoneTree.csproj" />
     <PackageReference Include="BenchmarkDotNet" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" />
     <InternalsVisibleTo Include="KeyLoad.UnitTests" />
   </ItemGroup>
 </Project>

docs/implementation/code-quality-repair-2026-10-06.json

@@ -160,7 +160,14 @@
       "trx": "TestResults/quality-repair-frozen-threshold-20261006/KeyLoad.Analyzers.Tests_net10.0_arm64.trx",
       "fixtureDrift": 0,
       "limitation": "Frozen copied36-source contract with native synthetic coverage fixtures; no whole-current-catalog, functional coverage, complete source-cohort suite or current CRAP acceptance."
-    }
+    },
+    "governance": {
+      "status": "passed",
+      "artifact": "governance-final2.log",
+      "projects": 27,
+      "modules": 4
+    },
+    "orderedReviewSourceDriftCheck": "Diagnostics eight authored hashes from the native review still match at final evidence join; frozen threshold fixture inputs remain identical to their captured copy."
   },
   "remainingFindings": [
     {
@@ -175,7 +182,7 @@
       "severity": "high",
       "status": "open; independently owned analyzer implementation in progress",
       "source": "scripts/Features/CodeQuality/site-analyzer-coverage.contract.json",
-      "consequence": "Ten new analyzer files are not bound by the current catalog; Prepare correctly fails closed. Full threshold runtime verification remains blocked.",
+      "consequence": "Ten new analyzer files are not bound by the current catalog; Prepare correctly fails closed. Five native frozen-fixture threshold controls pass, but complete current-catalog qualification remains blocked.",
       "artifact": "catalog-blocker.json"
     },
     {

src/KeyLoad.Core/Features/ClusterRouting/Execution/DatabaseEngine.RuntimeJournal.cs

@@ -1,4 +1,3 @@
-using KeyLoad.Core.Features.ClusterRouting;
 using Microsoft.Extensions.Options;
 using KeyLoad.Storage;
 

src/KeyLoad.Orleans/Features/ClusterRouting/Lifecycle/RuntimeJournalAdmission.cs

@@ -1,7 +1,7 @@
 namespace KeyLoad.Orleans;
 
 /// <summary>Opens native journal work only after replicated identity and catalog verification.</summary>
-internal sealed class RuntimeJournalAdmission : IDisposable
+public sealed class RuntimeJournalAdmission : IDisposable
 {
     private readonly Lock lifecycle = new();
     private readonly TaskCompletionSource ready = new(TaskCreationOptions.RunContinuationsAsynchronously);