Checkpoint functional coverage identity and native open-loop host joins

Include all current shared working-tree changes on main as requested. Join native coverage image admission, open-loop IOptions library and host dispatch, real host configuration-to-output cases and partition-isolation workflows. Local Release attempts failed; current full build, functional coverage, Aspire RF3 and original acceptance gates remain pending. No original plan task is marked complete.

Author: KSemenenko

AGENTS.md

@@ -171,6 +171,8 @@ Rule format:
 - Existing rules MUST remain present and mandatory; change or remove a rule only under explicit rule-specific owner direction, never as framework cleanup.
 
 ## Global Skills
+The owner's 2026-10-06 approval to implement the reviewed native DurableJobs path also authorizes its matching native Journaling API (`ORLEANSEXP005`). Confine that opt-in to the journal provider, native jobs integration and their registration/tests under ADR-110; do not use a global NoWarn or suppress unrelated diagnostics. Journal metadata remains RF3-authoritative and distinct from creator-authorized business effects.
+
 The explicit owner instruction to enable Orleans distributed directory and activation repartitioning is consent to those two native experimental APIs. Confine compiler opt-in ORLEANSEXP003/ORLEANSEXP001 to their two configuration calls, with ADR-034 evidence; it does not authorize global NoWarn, suppression of quality diagnostics or changing analyzer severity.
 
 - On 2026-10-05 the owner explicitly authorized installing the Managed Code `quality` bundle from https://skills.managed-code.com/bundles/quality/ and running KeyLoad complexity, CRAP and related code-quality analysis. Use the catalog's current bundle skill names and native installation command; this scoped permission supersedes the historical skill-installation prohibition and older `mcaf-*` naming requirement for this bundle only. Preserve existing quality thresholds and use the Aspire-owned entry point for coverage-producing tests.

Directory.Packages.props

@@ -23,6 +23,8 @@
     <PackageVersion Include="ModelContextProtocol.AspNetCore" Version="2.2.0" />
     <PackageVersion Include="ModelContextProtocol.Core" Version="2.2.0" />
     <PackageVersion Include="Microsoft.Orleans.Server" Version="10.4.0" />
+    <PackageVersion Include="Microsoft.Orleans.Journaling" Version="10.4.0-alpha.1" />
+    <PackageVersion Include="Microsoft.Orleans.DurableJobs" Version="10.4.0-alpha.1" />
     <PackageVersion Include="Microsoft.Orleans.Sdk" Version="10.4.0" />
     <PackageVersion Include="Microsoft.Orleans.Serialization" Version="10.4.0" />
     <PackageVersion Include="Microsoft.Orleans.CodeGenerator" Version="10.4.0" />

benchmarks/KeyLoad.ComparisonHost/Features/BenchmarkComparisons/Configuration/IsolatedOpenLoopSettings.cs

@@ -0,0 +1,37 @@
+using KeyLoad.Comparisons;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
+
+namespace KeyLoad.ComparisonHost.Features.BenchmarkComparisons;
+
+/// <summary>Admits one centrally validated native open-loop dispatch.</summary>
+[ConfigurationBinding]
+internal sealed record IsolatedOpenLoopSettings(ScaledComparisonProfile Profile, int Rate,
+    bool CancellationProof, IOptions<OpenLoopExecutionOptions> ExecutionOptions)
+{
+    internal const string ProofSetting = "Benchmarks:OpenLoopCancellationProof";
+    internal const string ProofEnvironment = "Benchmarks__OpenLoopCancellationProof";
+    internal const string ProofSelected = "true";
+    private const int ProofNodeCount = 3;
+
+    internal static IsolatedOpenLoopSettings? Read(IConfiguration configuration, ComparisonWorkerSelection selection)
+    {
+        var proofText = configuration[ProofSetting];
+        if (selection.OpenLoopRate is not { } rate)
+        {
+            if (proofText is not null) { throw Invalid(); }
+            return null;
+        }
+        if (proofText is not null && proofText != ProofSelected) { throw Invalid(); }
+        var profile = selection.ScaledProfile ?? throw Invalid();
+        var proof = proofText is not null;
+        if (proof && (selection.Target != IsolatedHostConstants.KeyLoad
+            || selection.NodeCount != ProofNodeCount || selection.Scenario != Scenario.PointRead))
+        {
+            throw Invalid();
+        }
+        return new(profile, rate, proof, OpenLoopExecutionRegistration.Read(configuration));
+    }
+
+    private static InvalidOperationException Invalid() => new(IsolatedHostConstants.Failure);
+}

benchmarks/KeyLoad.ComparisonHost/Features/BenchmarkComparisons/Configuration/NativeComparisonExecutionRegistration.cs

@@ -1,4 +1,5 @@
 using KeyLoad.Comparisons;
+using KeyLoad.Client;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
@@ -20,4 +21,37 @@ internal static IOptions<NativeComparisonExecutionOptions> Read(IConfiguration c
         var policy = provider.GetRequiredService<IOptions<NativeComparisonExecutionOptions>>().Value.Validate();
         return Options.Create(policy);
     }
+
+    internal static IOptions<ComparisonLifecycleOptions> ReadLifecycle(IConfiguration configuration)
+    {
+        var options = new OptionsManager<ComparisonLifecycleOptions>(new OptionsFactory<ComparisonLifecycleOptions>(
+            [new ConfigureFromConfigurationOptions<ComparisonLifecycleOptions>(
+                configuration.GetSection(ComparisonLifecycleOptions.SectionName))], [],
+            [new ValidateOptions<ComparisonLifecycleOptions>(Options.DefaultName,
+                settings => settings.IsValid(), ComparisonLifecycleOptions.ValidationMessage)]));
+        _ = options.Value;
+        return options;
+    }
+
+    internal static IOptions<KeyLoadClientExecutionOptions> ReadClient(IConfiguration configuration)
+    {
+        var options = new OptionsManager<KeyLoadClientExecutionOptions>(new OptionsFactory<KeyLoadClientExecutionOptions>(
+            [new ConfigureFromConfigurationOptions<KeyLoadClientExecutionOptions>(
+                configuration.GetSection(KeyLoadClientExecutionOptions.SectionName))], [],
+            [new ValidateOptions<KeyLoadClientExecutionOptions>(Options.DefaultName,
+                settings => settings.IsValid(), KeyLoadClientExecutionOptions.ValidationMessage)]));
+        _ = options.Value;
+        return options;
+    }
+
+    internal static IOptions<QueryTranslationOptions> ReadTranslation(IConfiguration configuration)
+    {
+        var options = new OptionsManager<QueryTranslationOptions>(new OptionsFactory<QueryTranslationOptions>(
+            [new ConfigureFromConfigurationOptions<QueryTranslationOptions>(
+                configuration.GetSection(QueryTranslationOptions.SectionName))], [],
+            [new ValidateOptions<QueryTranslationOptions>(Options.DefaultName,
+                settings => settings.IsValid(), QueryTranslationOptions.ValidationMessage)]));
+        _ = options.Value;
+        return options;
+    }
 }

benchmarks/KeyLoad.ComparisonHost/Features/BenchmarkComparisons/Configuration/OpenLoopExecutionRegistration.cs

@@ -0,0 +1,23 @@
+using KeyLoad.Comparisons;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace KeyLoad.ComparisonHost.Features.BenchmarkComparisons;
+
+/// <summary>Binds the canonical open-loop policy before admitting a native target.</summary>
+[ConfigurationBinding]
+internal static class OpenLoopExecutionRegistration
+{
+    internal static IOptions<OpenLoopExecutionOptions> Read(IConfiguration configuration)
+    {
+        ArgumentNullException.ThrowIfNull(configuration);
+        var services = new ServiceCollection();
+        services.AddSingleton<IValidateOptions<OpenLoopExecutionOptions>, OpenLoopExecutionOptionsValidator>();
+        services.AddOptions<OpenLoopExecutionOptions>()
+            .Bind(configuration.GetSection(OpenLoopExecutionOptions.SectionName)).ValidateOnStart();
+        using var provider = services.BuildServiceProvider();
+        var policy = provider.GetRequiredService<IOptions<OpenLoopExecutionOptions>>().Value;
+        return Options.Create(policy);
+    }
+}

benchmarks/KeyLoad.ComparisonHost/Features/BenchmarkComparisons/Hosting/ComparisonApplication.cs

@@ -16,7 +16,10 @@ internal static async Task<int> RunAsync(string[] arguments)
         configuration.AddJsonFile(Path.Combine(AppContext.BaseDirectory, NativeComparisonExecutionRegistration.ConfigurationPath), optional: false);
         configuration.AddEnvironmentVariables();
         configuration.AddCommandLine(arguments);
-        var owner = new ComparisonTargetOwner(NativeComparisonExecutionRegistration.Read(configuration));
+        var owner = new ComparisonTargetOwner(NativeComparisonExecutionRegistration.Read(configuration),
+            NativeComparisonExecutionRegistration.ReadLifecycle(configuration),
+            NativeComparisonExecutionRegistration.ReadClient(configuration),
+            NativeComparisonExecutionRegistration.ReadTranslation(configuration));
         ComparisonCancellationLifetime? cancellationLifetime = null;
         try
         {

benchmarks/KeyLoad.ComparisonHost/Features/BenchmarkComparisons/Hosting/ComparisonTargetOwner.cs

@@ -3,12 +3,14 @@
 using System.Text;
 using Microsoft.Extensions.Options;
 using KeyLoad.Comparisons;
+using KeyLoad.Client;
 using KeyLoad.Comparisons.Targets;
 
 namespace KeyLoad.ComparisonHost.Features.BenchmarkComparisons;
 
 /// <summary>Owns target construction and each client until its target takes ownership.</summary>
-internal sealed class ComparisonTargetOwner(IOptions<NativeComparisonExecutionOptions> executionOptions) : IAsyncDisposable
+internal sealed class ComparisonTargetOwner(IOptions<NativeComparisonExecutionOptions> executionOptions,
+    IOptions<ComparisonLifecycleOptions> lifecycleOptions, IOptions<KeyLoadClientExecutionOptions> clientOptions, IOptions<QueryTranslationOptions> translationOptions) : IAsyncDisposable
 {
     private readonly List<IComparisonTarget> targets = new(ComparisonHostConstants.TargetCount);
     private readonly List<HttpClient> unownedClients = new(ComparisonHostConstants.HttpClientCount);
@@ -27,22 +29,22 @@ internal IComparisonTarget[] CreateTargets(ComparisonHostSettings settings)
         var neo4jClient = CreateClient(settings.Neo4jEndpoint);
         neo4jClient.DefaultRequestHeaders.Authorization = CreateNeo4jAuthorization(settings.Neo4jPassword);
 
-        pendingTarget = new KeyLoadTarget(keyLoadClient, settings.AdminKey, settings.RunId,
+        pendingTarget = new KeyLoadTarget(keyLoadClient, settings.AdminKey, settings.RunId, lifecycleOptions, clientOptions, translationOptions,
             image: settings.ExecutionIdentity?.KeyLoadImage, peers: keyLoadClients);
         PublishPendingTarget(keyLoadClients);
-        pendingTarget = new PostgresTarget(settings.PostgresConnection, settings.RunId, settings.PostgresImage);
+        pendingTarget = new PostgresTarget(settings.PostgresConnection, settings.RunId, settings.PostgresImage, executionOptions, lifecycleOptions);
         PublishPendingTarget();
-        pendingTarget = new QdrantTarget(qdrantClient, settings.RunId, settings.QdrantImage, settings.Options.Topology, null, executionOptions);
+        pendingTarget = new QdrantTarget(qdrantClient, settings.RunId, settings.QdrantImage, executionOptions, lifecycleOptions, settings.Options.Topology, null);
         PublishPendingTarget(qdrantClient);
         var rabbitManagementClient = CreateClient(settings.RabbitManagementEndpoint);
         rabbitManagementClient.DefaultRequestHeaders.Authorization =
             ComparisonEndpointBindings.CreateRabbitAuthorization(settings.RabbitUser, settings.RabbitPassword);
-        pendingTarget = new RabbitTarget(settings.RabbitConnection, settings.RunId, settings.RabbitImage,
+        pendingTarget = new RabbitTarget(settings.RabbitConnection, settings.RunId, settings.RabbitImage, lifecycleOptions,
             management: rabbitManagementClient);
         PublishPendingTarget(rabbitManagementClient);
-        pendingTarget = new RedisTarget(settings.RedisConnection, settings.RunId, settings.RedisImage);
+        pendingTarget = new RedisTarget(settings.RedisConnection, settings.RunId, settings.RedisImage, lifecycleOptions);
         PublishPendingTarget();
-        pendingTarget = new Neo4jTarget(neo4jClient, settings.RunId, settings.Neo4jImage);
+        pendingTarget = new Neo4jTarget(neo4jClient, settings.RunId, settings.Neo4jImage, lifecycleOptions);
         PublishPendingTarget(neo4jClient);
         return [.. targets];
     }

benchmarks/KeyLoad.ComparisonHost/Features/BenchmarkComparisons/Hosting/IsolatedHostApplication.cs

@@ -1,4 +1,5 @@
 using KeyLoad.Comparisons;
+using ManagedCode.Communication.CQRS;
 using Microsoft.Extensions.Configuration;
 
 namespace KeyLoad.ComparisonHost.Features.BenchmarkComparisons;
@@ -30,6 +31,7 @@ private static async Task<int> RunSelectedAsync(IConfiguration configuration, Ca
         {
             cancellationToken.ThrowIfCancellationRequested();
             var settings = IsolatedHostSettings.Read(configuration);
+            var openLoop = IsolatedOpenLoopSettings.Read(configuration, settings.Selection);
             IsolatedHostReportWriter.ValidateDestination(settings.OutputDirectory);
             if (settings.UnsupportedReason is { } reason)
             {
@@ -39,21 +41,37 @@ private static async Task<int> RunSelectedAsync(IConfiguration configuration, Ca
                 return ComparisonHostConstants.SuccessfulExitCode;
             }
             var policy = NativeComparisonExecutionRegistration.Read(configuration);
-            return await RunNativeAsync(settings, policy, cancellationToken);
+            return await RunNativeAsync(settings, policy,
+                NativeComparisonExecutionRegistration.ReadLifecycle(configuration),
+                NativeComparisonExecutionRegistration.ReadClient(configuration),
+                NativeComparisonExecutionRegistration.ReadTranslation(configuration), openLoop, cancellationToken);
         }
         catch (OperationCanceledException)
         {
             throw;
         }
+        catch (Exception failure) when (CqrsRuntimeFailures.FindFatal(failure) is not null)
+        {
+            throw;
+        }
         catch (Exception)
         {
             throw new ComparisonFailureException(IsolatedHostConstants.Failure);
         }
     }
 
-    private static async Task<int> RunNativeAsync(IsolatedHostSettings settings, Microsoft.Extensions.Options.IOptions<NativeComparisonExecutionOptions> policy, CancellationToken cancellationToken)
+    private static async Task<int> RunNativeAsync(IsolatedHostSettings settings,
+        Microsoft.Extensions.Options.IOptions<NativeComparisonExecutionOptions> policy,
+        Microsoft.Extensions.Options.IOptions<ComparisonLifecycleOptions> lifecycleOptions,
+        Microsoft.Extensions.Options.IOptions<KeyLoad.Client.KeyLoadClientExecutionOptions> clientOptions,
+        Microsoft.Extensions.Options.IOptions<KeyLoad.Client.QueryTranslationOptions> translationOptions,
+        IsolatedOpenLoopSettings? openLoop, CancellationToken cancellationToken)
     {
-        await using var owner = new IsolatedHostTargetOwner(policy);
+        await using var owner = new IsolatedHostTargetOwner(policy, lifecycleOptions, clientOptions, translationOptions);
+        if (openLoop is not null)
+        {
+            return await IsolatedOpenLoopHostApplication.RunAsync(owner, settings, openLoop, cancellationToken);
+        }
         if (settings.Selection.VectorProfile is not null)
         {
             return await IsolatedVectorHostApplication.RunAsync(owner, settings, cancellationToken);