Fix three cluster oracles that the shortened lanes never reached

With the 45-minute lane deadline, I07 lane 2 and I09 ran classes that had been
cut off before:
- AcSqlView005: the stream record expected event sequence 1, but the sequence
  counts every event in the partition; the oracle now uses the sequence the
  original model row reported.
- LeftFilteredJoin: the unified SQL tool compiles the unsupported predicate
  before dispatch, so that refusal carries no request ID; the two argument
  refusals are dispatched.
- AcSeries012: after the silo restart the test waited for routing on the
  restarted node only, and a read through another node still returned
  OwnershipLost; it now waits until every node reports all silos.

Verification: integration tests build with -warnaserror; dotnet format verify;
governance PASS; locally SqlModelViewClusterParityTests, LeftFilteredJoinCluster
Tests and AcSeries012SiloRestartRetainsLatestAndWindowValuesOnEveryReplica pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: KSemenenko

tests/KeyLoad.IntegrationTests/Authorization/Assertions/ResourcePolicies/ModelRootCluster.cs

@@ -27,8 +27,11 @@ await ModelRootClusterWave.ObserveAsync(root, state, async () => await MessageAs
         {
             var stream = new StreamRef(state.Partition, state.Resource, ModelRootClusterState.Item);
             var request = new ReadStreamRequest(stream);
-            var recordedAt = JsonNode.Parse(state.Original.Json)![ModelRootClusterState.RecordedAtField]!.GetValue<DateTimeOffset>();
-            var expected = new EventRecord(stream, 1L, 1L,
+            var original = JsonNode.Parse(state.Original.Json)!;
+            var recordedAt = original[ModelRootClusterState.RecordedAtField]!.GetValue<DateTimeOffset>();
+            // The event sequence counts every event in the partition, so it is the one the original row reported.
+            var sequence = original[ModelRootClusterState.EventSequenceField]!.GetValue<long>();
+            var expected = new EventRecord(stream, 1L, sequence,
                 new(ModelRootClusterState.Item, ModelRootClusterState.Type, Body(state, read, false), Body(state, read, true)), recordedAt);
             await ModelRootClusterWave.ObserveAsync(root, state, async () => await StreamAsync(
                 await McpCallerAssertions.SdkSuccessAsync(await reader.Sdk.ReadStreamAsync(request, token)), expected), token);

tests/KeyLoad.IntegrationTests/RelationalStorage/Scenarios/Joins/LeftFilteredJoinRefusals.cs

@@ -22,20 +22,22 @@ internal static async Task InvalidAsync(RequestCqrsClusterCallers callers, LeftF
         CancellationToken token)
     {
         var request = LeftFilteredJoinProtocol.Request(state.Partition);
-        foreach (var (input, code) in new[]
+        // The unified SQL tool compiles the text before dispatch, so the unsupported predicate is refused there without a
+        // request ID; the argument refusals need the stored model and are dispatched.
+        foreach (var (input, code, dispatched) in new[]
         {
-            (request with { Parameters = null }, ErrorCode.Validation),
+            (request with { Parameters = null }, ErrorCode.Validation, true),
             (request with { Sql = LeftFilteredJoinProtocol.Prefix + "WHERE r.name = @minimum "
-                + LeftFilteredJoinProtocol.Order }, ErrorCode.UnsupportedCapability),
+                + LeftFilteredJoinProtocol.Order }, ErrorCode.UnsupportedCapability, false),
             (request with { Parameters = new() { [MinimumFieldKey] = System.Text.Json.JsonSerializer.SerializeToElement("wrong") } },
-                ErrorCode.Validation)
+                ErrorCode.Validation, true)
         })
         {
             var failure = await callers.Sdk.ExecuteSqlAsync(input, token);
             await Assert.That(failure.IsSuccess).IsFalse();
             await Assert.That(failure.Problem?.ErrorCode).IsEqualTo(code.ToString());
             await McpCallerAssertions.ErrorAsync(await callers.Mcp.CallAsync(SqlOperationProtocol.ToolName,
-                input, token), code, dispatched: true);
+                input, token), code, dispatched);
         }
     }
 

tests/KeyLoad.IntegrationTests/TimeSeries/Cases/TimeSeriesClusterReplicaRestartTests.cs

@@ -68,11 +68,8 @@ await Assert.That(initial.Sample?.Sample.Value)
 
             await fixture.RestartServerAsync(stoppedNode, deadline.Token);
             restarted = true;
-            await ClusterReplicationTestSupport.EventuallyAsync(async () =>
-            {
-                var status = await clients[selectedIndex].StatusAsync(deadline.Token);
-                return status.IsSuccess && status.Value.RoutingReady;
-            }, deadline.Token);
+            // A write needs every copy, and a read can route through any node, so every node must report all silos.
+            await ClusterMembershipReadiness.WaitForActiveSilosAsync(clients, deadline.Token);
             await Assert.That(Directory.Exists(Path.Combine(fixture.Root, stoppedNode))).IsTrue();
             var committed = ClusterReplicationTestSupport.Success(await clients[survivorIndex].CommitAsync(command, deadline.Token));
             await Assert.That(committed.Durability).IsEqualTo(DurabilityProfile.ProcessDurable);