Align query window, result-bytes and guide/graph oracles with the current server

- An offset/limit pair that cannot form a row window is a Validation refusal,
  not BudgetExceeded; projection, ordering and parameter maxima stay budgets.
- Resource-lifetime result retention reports the same result-bytes message as
  the serialization counter.
- Guide lifecycle oracles expect the MCP server-info _meta block.
- Graph path oracles expect canonical key-sorted edge attributes.

Verification: integration and unit test projects build with -warnaserror,
dotnet format verify on changed files, repository governance PASS; locally
GuideLifecycle, GraphPath R43, OneByteWholeEventRefusal and the unit
SqlOffsetWholeFlow cases pass. AcSqlc006 still fails after a cold restart.

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

Author: KSemenenko

src/KeyLoad.Core/ResourceExecution/Lifecycle/ResourceLifetimeWorkResultRetention.cs

@@ -6,7 +6,8 @@ namespace KeyLoad.Core.ResourceExecution;
 internal sealed class ResourceLifetimeWorkResultRetention : IDisposable
 {
     private const int Empty = 0;
-    private const string Capacity = "The retained resource lifetimes exceed the operation result bytes.";
+    // Retained lifetimes are part of the caller's result bytes, so the caller sees the same refusal.
+    private const string Capacity = ResultByteCounterStream.ResultBytesExceeded;
     private const int Unbounded = int.MaxValue;
     private const string Invalid = "The resource lifetime ledger input is invalid.";
     private readonly Lock gate = new();

src/KeyLoad.Core/ResourceExecution/Serialization/ResultByteCounterStream.cs

@@ -2,7 +2,7 @@ namespace KeyLoad.Core.ResourceExecution;
 
 internal sealed class ResultByteCounterStream(long maximumBytes, Action check) : Stream
 {
-    private const string ResultBytesExceeded = "The read result byte budget is exceeded.";
+    internal const string ResultBytesExceeded = "The read result byte budget is exceeded.";
     private long bytes;
 
     internal static long Measure<T>(ReadExecutionBudget budget, T result)

src/KeyLoad.Query/QueryExecution/Validation/QuerySemantics/QueryValidation.cs

@@ -12,7 +12,7 @@ internal static class QueryValidation
     private const int MinimumPositiveCount = 1;
     private const string QueryStructureExceedsItsBudgetDetail = "The query structure exceeds its budget.";
     private const int RootPredicateDepth = 1;
-    private const string QueryWindowIsNotRepresentableDetail = "The query offset and limit exceed the representable row positions.";
+    private const string QueryWindowIsNotRepresentableDetail = "The query offset and limit do not form a valid row window.";
     private const string ModelQuerySourceIsUnsupportedDetail = "The model query source is unsupported.";
     private const string ModelQueryRequiresExplicitFullScanConsentDetail = "A model query requires explicit full-scan consent.";
     private const string ModelQueryContinuationIsNotSupportedDetail = "Model query continuation is not supported.";
@@ -42,13 +42,14 @@ public static AstQueryRequest Normalize(AstQueryRequest request, QueryExecutionO
         ValidateModelSource(request, query);
         if (query.Projection.IsDefault || query.Order.IsDefault
             || query.Projection.Length < MinimumPositiveCount || query.Projection.Length > execution.MaximumProjection
-            || query.Order.Length > execution.MaximumOrdering || query.Limit < MinimumPositiveCount
-            || query.Offset < EmptyElementCount
+            || query.Order.Length > execution.MaximumOrdering
             || request.Parameters?.Count > execution.MaximumParameters)
         {
             throw Errors.Fail(ErrorCode.BudgetExceeded, QueryStructureExceedsItsBudgetDetail);
         }
-        if ((long)query.Offset + query.Limit > int.MaxValue)
+        // A window needs a positive limit and a nonnegative offset that ends within a 32-bit row position.
+        if (query.Limit < MinimumPositiveCount || query.Offset < EmptyElementCount
+            || (long)query.Offset + query.Limit > int.MaxValue)
         {
             throw Errors.Fail(ErrorCode.Validation, QueryWindowIsNotRepresentableDetail);
         }

tests/KeyLoad.IntegrationTests/ClientApi/Assertions/GuideLifecycle/GuideLifecyclePublicExpected.cs

@@ -1,3 +1,5 @@
+using System.Text.Json.Nodes;
+
 namespace KeyLoad.IntegrationTests.ClientApi;
 
 internal static class GuideLifecyclePublicExpected
@@ -9,6 +11,11 @@ internal static class GuideLifecyclePublicExpected
     internal const string Description = "How to discover and safely use KeyLoad operations.";
     internal const int MaximumBytes = 8192;
     internal const string CompleteResult = "complete";
+    private const string ServerInfoKey = "io.modelcontextprotocol/serverInfo";
+    private const string ServerName = "KeyLoad";
+    private const string ServerVersion = "1.0.0";
+    private const string NameKey = "name";
+    private const string VersionKey = "version";
     internal const string Markdown = """
         # KeyLoad agent quickstart
 
@@ -36,4 +43,10 @@ internal static class GuideLifecyclePublicExpected
 
         This guide is static documentation, not a data browser or authorization grant. Confirm current tool schemas and feature support for each task.
         """;
+
+    /// <summary>MCP results carry the server identity in their metadata; each result owns its own node.</summary>
+    internal static JsonObject ServerMeta() => new()
+    {
+        [ServerInfoKey] = new JsonObject { [NameKey] = ServerName, [VersionKey] = ServerVersion }
+    };
 }

tests/KeyLoad.IntegrationTests/ClientApi/Assertions/GuideLifecycle/GuideLifecyclePublicGuidance.cs

@@ -32,7 +32,8 @@ private static async Task ResourcesAsync(McpOfficialClient session, Cancellation
             NextCursor = null,
             TimeToLive = TimeSpan.Zero,
             CacheScope = CacheScope.Private,
-            ResultType = GuideLifecyclePublicExpected.CompleteResult
+            ResultType = GuideLifecyclePublicExpected.CompleteResult,
+            Meta = GuideLifecyclePublicExpected.ServerMeta()
         };
         var actual = await session.Client.ListResourcesAsync(new ListResourcesRequestParams(), token);
         await SqlClusterProtocol.EqualAsync(expected, actual);
@@ -49,7 +50,8 @@ await SqlClusterProtocol.EqualAsync(expected,
             }],
             TimeToLive = TimeSpan.Zero,
             CacheScope = CacheScope.Private,
-            ResultType = GuideLifecyclePublicExpected.CompleteResult
+            ResultType = GuideLifecyclePublicExpected.CompleteResult,
+            Meta = GuideLifecyclePublicExpected.ServerMeta()
         };
         var read = await session.Client.ReadResourceAsync(Resource, cancellationToken: token);
         await SqlClusterProtocol.EqualAsync(expectedRead, read);
@@ -73,7 +75,8 @@ private static async Task PromptsAsync(McpOfficialClient session, CancellationTo
             NextCursor = null,
             TimeToLive = TimeSpan.Zero,
             CacheScope = CacheScope.Private,
-            ResultType = GuideLifecyclePublicExpected.CompleteResult
+            ResultType = GuideLifecyclePublicExpected.CompleteResult,
+            Meta = GuideLifecyclePublicExpected.ServerMeta()
         };
         var actual = await session.Client.ListPromptsAsync(new ListPromptsRequestParams(), token);
         await SqlClusterProtocol.EqualAsync(expected, actual);
@@ -88,7 +91,8 @@ await SqlClusterProtocol.EqualAsync(expected,
                 Role = Role.User,
                 Content = new TextContentBlock { Text = GuideLifecyclePublicExpected.Markdown }
             }],
-            ResultType = GuideLifecyclePublicExpected.CompleteResult
+            ResultType = GuideLifecyclePublicExpected.CompleteResult,
+            Meta = GuideLifecyclePublicExpected.ServerMeta()
         };
         var get = await session.Client.GetPromptAsync(GuideLifecyclePublicExpected.PromptName, cancellationToken: token);
         await SqlClusterProtocol.EqualAsync(expectedGet, get);

tests/KeyLoad.IntegrationTests/GraphTraversal/Assertions/Paths/GraphPath/GraphPathFieldUseR43Current.cs

@@ -6,8 +6,6 @@ namespace KeyLoad.IntegrationTests.GraphTraversal;
 
 internal static class GraphPathFieldUseR43Current
 {
-    private const string CanonicalFullAttributes = "{\"public\":\"visible\",\"secret\":\"graph-path-private-marker\"}";
-
     internal static async Task ObserveAsync(RequestCqrsClusterCallers admin, GraphPathFieldUseR43State state,
         CancellationToken token)
     {
@@ -20,7 +18,7 @@ await SqlClusterProtocol.EqualAsync(expected, (await PublicReadAssertions.Docume
         }
         var request = new TraverseRequest(state.Seed.Partition, GraphPathClusterScenario.Graph, state.Source, 2, 3, 2);
         var expectedGraph = state.Seed.StoredTraversal(new([state.Middle, state.Source, state.Target],
-            [.. state.Edges.Select(edge => edge with { AttributesJson = CanonicalFullAttributes })]));
+            [.. state.Edges.Select(edge => edge with { AttributesJson = GraphPathClusterScenario.CanonicalAttributes })]));
         await SqlClusterProtocol.EqualAsync(expectedGraph, await McpCallerAssertions.SdkSuccessAsync(
             await admin.Sdk.TraverseAsync(request, token)));
         await SqlClusterProtocol.EqualAsync(expectedGraph, (await McpCallerAssertions.SuccessAsync<global::KeyLoad.GraphTraversal>(

tests/KeyLoad.IntegrationTests/GraphTraversal/Assertions/Paths/GraphPath/GraphPathRawReadR43Current.cs

@@ -17,7 +17,8 @@ await SqlClusterProtocol.EqualAsync(expected, (await PublicReadAssertions.Docume
                 await admin.Mcp.CallAsync(McpCallerTools.DocumentsGet, new GetDocumentRequest(vertex), token))).Value);
         }
         var request = new TraverseRequest(state.Seed.Partition, GraphPathClusterScenario.Graph, state.Source, 2, 3, 2);
-        var expectedGraph = state.Seed.StoredTraversal(new([state.Middle, state.Source, state.Target], [.. state.Edges]));
+        var expectedGraph = state.Seed.StoredTraversal(new([state.Middle, state.Source, state.Target],
+            [.. state.Edges.Select(edge => edge with { AttributesJson = GraphPathClusterScenario.CanonicalAttributes })]));
         await SqlClusterProtocol.EqualAsync(expectedGraph, await McpCallerAssertions.SdkSuccessAsync(
             await admin.Sdk.TraverseAsync(request, token)));
         await SqlClusterProtocol.EqualAsync(expectedGraph, (await McpCallerAssertions.SuccessAsync<global::KeyLoad.GraphTraversal>(

tests/KeyLoad.IntegrationTests/GraphTraversal/Models/GraphPathRawReadR43State.cs

@@ -26,7 +26,9 @@ internal bool Allowed
         new("r43-raw-0", Source, Middle, GraphPathClusterScenario.Label, "{\"public\":\"visible\"}", 1L),
         new("r43-raw-1", Middle, Target, GraphPathClusterScenario.Label, "{\"public\":\"visible\"}", 1L)
     ];
-    internal EdgeRecord[] ProjectedEdges => Allowed ? Edges : RedactedEdges;
+    internal EdgeRecord[] ProjectedEdges => Allowed
+        ? [.. Edges.Select(edge => edge with { AttributesJson = GraphPathClusterScenario.CanonicalAttributes })]
+        : RedactedEdges;
     internal EdgeRecord[] StoredProjectedEdges => [.. ProjectedEdges.Select(Seed.StoredEdge)];
     internal CommandRequest Command { get; set; } = null!;
     internal CommitReceipt Receipt { get; set; } = null!;

tests/KeyLoad.IntegrationTests/GraphTraversal/Scenarios/Paths/GraphPathClusterScenario.cs

@@ -29,6 +29,8 @@ internal static class GraphPathClusterScenario
     internal const string IsolatedId = "isolated";
     internal const string SecretOwner = "different-row-owner";
     internal const string PublicAttributes = "{\"secret\":\"graph-path-private-marker\",\"public\":\"visible\"}";
+    /// <summary>Stored edge attributes are canonical JSON, so a full read returns them with sorted keys.</summary>
+    internal const string CanonicalAttributes = "{\"public\":\"visible\",\"secret\":\"graph-path-private-marker\"}";
     internal const string EmptyAttributes = "{}";
 
     internal static async Task<GraphPathClusterSeed> CreateAsync(ClusterFixture fixture,

tests/KeyLoad.IntegrationTests/QueryExecution/Assertions/Pagination/SqlOffsetClusterRefusals.cs

@@ -43,11 +43,12 @@ await McpCallerAssertions.ErrorAsync(await callers.Mcp.CallAsync(McpCallerTools.
                     Offset = offset
                 }
             };
+            // A negative offset or an offset whose window passes the 32-bit row position is invalid input, as in SQL.
             var failure = await callers.Sdk.QueryAstAsync(bad, token);
             await Assert.That(failure.IsSuccess).IsFalse();
-            await Assert.That(failure.Problem?.ErrorCode).IsEqualTo(ErrorCode.BudgetExceeded.ToString());
+            await Assert.That(failure.Problem?.ErrorCode).IsEqualTo(ErrorCode.Validation.ToString());
             await McpCallerAssertions.ErrorAsync(await callers.Mcp.CallAsync(McpCallerTools.QueryAst, bad, token),
-                ErrorCode.BudgetExceeded, dispatched: true);
+                ErrorCode.Validation, dispatched: true);
         }
     }
     internal static async Task DeniedAsync(RequestCqrsClusterCallers callers, SqlOffsetClusterState state, CancellationToken token)