Complete Roslynk quality review and canonical formatting

Roslynk loaded all 27 projects without load diagnostics and reported zero
compiler/analyzer errors or warnings. Canonical solution formatting passed;
the full Release build passed with isolated single-process MSBuild after an
MSB4166 parallel-worker failure.

Retain advisory style findings and the owner-scoped exclusion of further
test execution.

Author: KSemenenko

docs/Features/CodeQuality.md

@@ -50,14 +50,18 @@ flowchart LR
     Repair --> Gates[Canonical format and build]
 ```
 
-Local Roslynk inspection on2026-10-09 loaded all27/27 projects to Ready and
+Local Roslynk inspection on 2026-10-09 loaded all 27/27 projects to Ready and
 rechecked the solution with compiler errors, warnings and analyzers included.
-The initial27 errors were repaired; the recheck reported zero errors and zero
-warnings. Informational/hidden suggestions remain advisory, including existing
+The initial 27 errors were repaired; the final native MCP recheck reported zero
+errors and zero warnings, with zero workspace load diagnostics. The canonical
+whole-solution formatter passed. The full Release build passed with zero warnings
+and errors using `--disable-build-servers -m:1` after a parallel MSBuild attempt
+failed with `MSB4166`. Informational/hidden suggestions remain advisory, including existing
 namespace/folder differences and intentionally unused fluent assertion results;
 this result does not claim every style suggestion has been eliminated. The
-owner-scoped follow-up performs formatting and compilation only, without test
-execution or additional runtime qualification. Original diagnostic reports are
+owner-scoped follow-up performed formatting and compilation only; no tests were
+executed after the owner's scope clarification. Runtime qualification remains
+outside this inspection. Original diagnostic and build reports are
 kept outside the checkout.
 
 TASK-CQ-UNIT64-010 implements the owner's 2026-10-06 rule-specific correction:

src/KeyLoad.AppHost/Features/ClusterRouting/Validation/TwoRf3Profile.cs

@@ -1,7 +1,7 @@
 using System.Globalization;
 using KeyLoad.AppHost.Features.TestInfrastructure;
-using Microsoft.Extensions.Configuration;
 using KeyLoad.Storage.ZoneTree;
+using Microsoft.Extensions.Configuration;
 
 namespace KeyLoad.AppHost.Features.ClusterRouting;
 

src/KeyLoad.Core/Features/BackupRestore/Validation/AtomicPartitionRosterOriginValidation.cs

@@ -12,7 +12,8 @@ internal static long ReadBound(IKeyValueView view, AtomicPartitionCatalogEntryV1
     {
         var origin = view.GetRecord<AtomicPartitionRosterRestoreOrigin>(
             AtomicPartitionRosterRestoreOriginSerialization.OriginKey(entry.Partition));
-        if (origin is null) { return NoHistoricalBound; }
+        if (origin is null)
+        { return NoHistoricalBound; }
         var identity = view.GetRecord<AtomicPartitionRosterRestoreIdentity>(
             AtomicPartitionRosterRestoreOriginSerialization.IdentityKey());
         if (identity is null || !AtomicPartitionRosterRestoreOriginSerialization.MatchesIdentity(identity, currentIncarnation))

src/KeyLoad.Orleans/Features/ClusterRouting/Grains/CommandPartitionGrain.cs

@@ -1,8 +1,8 @@
 using KeyLoad.Core;
-using Orleans.Runtime.Placement;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Orleans.Runtime.Placement;
 
 namespace KeyLoad.Orleans;
 

src/KeyLoad.Server/Features/ClusterRouting/Execution/RequestCqrsProbeCleanupInventory.cs

@@ -16,14 +16,17 @@ internal void Read(string path, string name, List<RequestCqrsProbeLoadedArm> loa
         if (name.StartsWith(RequestCqrsProbeProtocol.ArmFilePrefix, StringComparison.Ordinal))
         {
             var known = arms.SingleOrDefault(pair => RequestCqrsProbeFiles.ArmName(pair.Value.Record) == name);
-            if (known.Key == Guid.Empty) { return; }
+            if (known.Key == Guid.Empty)
+            { return; }
             RequireBytes(path, known.Value.Bytes);
             loaded.Add(new(known.Value.Record, known.Value.Bytes));
             return;
         }
         if (name == RequestCqrsProbeProtocol.OwnerFile
-            || name.StartsWith(RequestCqrsProbeProtocol.TemporaryFilePrefix, StringComparison.Ordinal)) { return; }
-        if (!controls.TryGetValue(name, out var bytes)) { throw Invalid(); }
+            || name.StartsWith(RequestCqrsProbeProtocol.TemporaryFilePrefix, StringComparison.Ordinal))
+        { return; }
+        if (!controls.TryGetValue(name, out var bytes))
+        { throw Invalid(); }
         RequireBytes(path, bytes);
         present.Add(name);
         if (name.StartsWith(RequestCqrsProbeProtocol.MarkerFilePrefix, StringComparison.Ordinal))
@@ -46,13 +49,15 @@ internal void RequireArmQuota(IEnumerable<string> names)
             .Concat(arms.Values.Select(arm => RequestCqrsProbeFiles.ArmName(arm.Record)))
             .Concat(retired.Select(id => RequestCqrsProbeProtocol.ArmFilePrefix + id.ToString(RequestCqrsProbeProtocol.SessionIdFormat)
                 + RequestCqrsProbeProtocol.JsonFileSuffix)).Distinct(StringComparer.Ordinal).Count();
-        if (count > options.Value.MaximumArms) { throw Invalid(); }
+        if (count > options.Value.MaximumArms)
+        { throw Invalid(); }
     }
 
     private void RequireBytes(string path, byte[] expected)
     {
         var actual = RequestCqrsProbeFiles.ReadRecord(path, options);
-        if (!CryptographicOperations.FixedTimeEquals(expected, actual)) { throw Invalid(); }
+        if (!CryptographicOperations.FixedTimeEquals(expected, actual))
+        { throw Invalid(); }
     }
 
     private static InvalidOperationException Invalid() => new(RequestCqrsProbeProtocol.InvalidFiles);

src/KeyLoad.Server/Features/ClusterRouting/Execution/RequestCqrsReceiverIssueAdjunct.cs

@@ -25,7 +25,8 @@ internal async Task<bool> TryObserveAsync(RequestCqrsProbeClaim primary, GrainRe
                 || arm.Record.SourceRequestId == primary.Identity.RequestId
                 || arm.Record.PrincipalId == primary.Identity.PrincipalId
                     && arm.Record.CommandId == primary.Identity.CommandId)).Take(PairMatchCeiling).ToArray();
-        if (linked.Length == NoAdjunct) { return false; }
+        if (linked.Length == NoAdjunct)
+        { return false; }
         if (linked.Length != ExactlyOneAdjunct || primary.ReceiverIssueAdjunct is not null)
         { throw Invalid(); }
         var arm = linked[FirstAdjunct];
@@ -49,7 +50,8 @@ await hold(claim, RequestCqrsProbePhase.ParentReceiverIssueObserved, context,
 
     internal void ProducerDisposed(RequestCqrsProbeClaim primary)
     {
-        if (primary.ReceiverIssueAdjunct is not { } adjunct) { return; }
+        if (primary.ReceiverIssueAdjunct is not { } adjunct)
+        { return; }
         files.WriteClaimedProducerDisposed(createMarker(adjunct, RequestCqrsProbePhase.ProducerDisposed,
             RequestCqrsProbeOutcome.Observed), adjunct.Arm);
     }

src/KeyLoad.Server/Features/ClusterRouting/Serialization/RequestCqrsProbeClaimedCleanup.cs

@@ -33,9 +33,11 @@ private RequestCqrsProbeSnapshot Read(RequestCqrsProbeCleanupInventory inventory
     {
         RequestCqrsProbePaths.RequireDirectory(root);
         var owner = RequestCqrsProbeFiles.ReadRecord(Path.Combine(root, RequestCqrsProbeProtocol.OwnerFile), options);
-        if (!CryptographicOperations.FixedTimeEquals(ownerBytes, owner)) { throw Invalid(); }
+        if (!CryptographicOperations.FixedTimeEquals(ownerBytes, owner))
+        { throw Invalid(); }
         var entries = Directory.EnumerateFileSystemEntries(root).Take(options.Value.MaximumFiles + OverflowEntry).ToArray();
-        if (entries.Length > options.Value.MaximumFiles) { throw Invalid(); }
+        if (entries.Length > options.Value.MaximumFiles)
+        { throw Invalid(); }
         var arms = new List<RequestCqrsProbeLoadedArm>();
         var releases = new List<RequestCqrsProbeReleaseRecord>();
         var markers = new List<RequestCqrsProbeMarkerRecord>();
@@ -46,7 +48,8 @@ private RequestCqrsProbeSnapshot Read(RequestCqrsProbeCleanupInventory inventory
         {
             var name = Path.GetFileName(path);
             total = checked(total + validateEntry(path, name));
-            if (total > options.Value.MaximumAggregateBytes) { throw Invalid(); }
+            if (total > options.Value.MaximumAggregateBytes)
+            { throw Invalid(); }
             inventory.Read(path, name, arms, releases, markers, present);
         }
         inventory.RequireKnownArmPresence(arms);
@@ -58,8 +61,10 @@ private RequestCqrsProbeSnapshot Read(RequestCqrsProbeCleanupInventory inventory
     private void RequireClaim(RequestCqrsProbeLoadedArm claim, RequestCqrsProbeSnapshot snapshot)
     {
         var current = snapshot.Arms.SingleOrDefault(arm => arm.Record.ArmId == claim.Record.ArmId);
-        if (current is not null && CryptographicOperations.FixedTimeEquals(current.ExactBytes, claim.ExactBytes)) { return; }
-        if (current is null && records.IsRetiredArm(claim.Record.ArmId, claim.ExactBytes)) { return; }
+        if (current is not null && CryptographicOperations.FixedTimeEquals(current.ExactBytes, claim.ExactBytes))
+        { return; }
+        if (current is null && records.IsRetiredArm(claim.Record.ArmId, claim.ExactBytes))
+        { return; }
         throw Invalid();
     }
 

src/KeyLoad.Storage.ZoneTree/Features/BackupRestore/Recovery/ZoneTreeBackupRestoreRestore.cs

@@ -33,7 +33,8 @@ internal static StoreIdentity Restore(string backup, string destination,
         {
             try
             {
-                if (Directory.Exists(staging)) { Directory.Delete(staging, recursive: true); }
+                if (Directory.Exists(staging))
+                { Directory.Delete(staging, recursive: true); }
             }
             catch (Exception cleanup)
             { throw new AggregateException(primary, cleanup); }
@@ -115,10 +116,12 @@ private static StoreIdentity ApplyRestoreAuthorityState(string destination,
 
     private static void DisposeRestoredStore(ZoneTreeStore restored, Exception? primary)
     {
-        try { restored.Dispose(); }
+        try
+        { restored.Dispose(); }
         catch (Exception cleanup)
         {
-            if (primary is null) { throw; }
+            if (primary is null)
+            { throw; }
             throw new AggregateException(primary, cleanup);
         }
     }

tests/KeyLoad.CrashHost/Features/ClusterRouting/Helpers/NativeInstallFrameInspection.cs

@@ -18,7 +18,8 @@ internal static async Task<bool> TryRunAsync(string[] args)
         try
         {
             evidence.SetPhase(C1OutcomeInspectionFailurePhase.ValidateRequest);
-            if (args.Length != SingleArgument) { throw new InvalidDataException(C1OutcomeInspectionProtocol.InvalidRequest); }
+            if (args.Length != SingleArgument)
+            { throw new InvalidDataException(C1OutcomeInspectionProtocol.InvalidRequest); }
             evidence.SetPhase(C1OutcomeInspectionFailurePhase.ReadInput);
             var bytes = await C1OutcomeInspection.ReadRequestBytesAsync().ConfigureAwait(false);
             evidence.SetPhase(C1OutcomeInspectionFailurePhase.ValidateRequest);
@@ -33,7 +34,8 @@ internal static async Task<bool> TryRunAsync(string[] args)
             evidence.Capture(failure);
             var failures = new List<Exception> { failure };
             await ServerFailureObserver.ObserveAsync(() => C1OutcomeInspection.WriteBytesAsync(evidence.Bytes(), true), failures).ConfigureAwait(false);
-            if (failures.Any(C1OutcomeInspectionFailures.ContainsFatal)) { ServerFailureObserver.ThrowIfAny(failures); }
+            if (failures.Any(C1OutcomeInspectionFailures.ContainsFatal))
+            { ServerFailureObserver.ThrowIfAny(failures); }
             Environment.ExitCode = C1OutcomeInspectionProtocol.FailureExitCode;
             GC.KeepAlive(failures);
         }

tests/KeyLoad.CrashHost/Features/ClusterRouting/Helpers/NativeInstallFrameInspectionOperation.cs

@@ -32,7 +32,8 @@ internal static NativeInstallFrameInspectionReceipt Run(NativeInstallFrameInspec
                     KeySpace.PartitionOutcome(request.Partition, request.PrincipalId, request.CommandId), TimeProvider.System, CancellationToken.None);
                 receipt = RequireOutcome(frame, request);
             }, failures);
-            if (failures.Count > NoFailures) { evidence.Capture(failures[FirstFailure]); }
+            if (failures.Count > NoFailures)
+            { evidence.Capture(failures[FirstFailure]); }
             evidence.SetPhase(C1OutcomeInspectionFailurePhase.DisposeStore);
         }, failures);
         ServerFailureObserver.ThrowIfAny(failures);