Re-ground deferral premises and stale notes against the current main

The merge window landed the listen server runtime, the client response
cache, requestState integrity, stream-pair 2026 serving, and the client
extension API — invalidating the premises of ~45 deferral texts and notes
written against the older base. Each text now states what is true at this
pin: entries whose blocking surface landed flip to 'Not yet covered here'
naming what a test will drive; entries still blocked name the precise
missing surface. Also fixes the README era-lock line (stateless is locked
too), documents the default-on client cache in the transport-matrix
section, and renames one resource test whose name predated its retarget.

Author: maxisbey

tests/interaction/README.md

@@ -61,6 +61,12 @@ stateless configurations), and over the legacy SSE transport the same way. A tes
 `async with connect(server, ...) as client:` and asserts the same output on every leg, because the
 transport is not supposed to change observable behaviour. Requirements that need a server-to-client
 back-channel or persisted session state are carved out of the stateless arm via `arm_exclusions`.
+
+The 2026 cells run the client's response cache in its default-on configuration. Servers stamp
+`ttlMs: 0` by default, so nothing is served from cache unless a test opts in server-side by
+authoring a positive `ttl_ms` — a test that does so and then repeats a call must expect the
+repeat to be served from cache instead of reaching the handler.
+
 Tests that are tied to one transport do not use the fixture: the wire-recording tests
 (their seam is the in-memory stream pair), the bare-`ClientSession` lifecycle tests, the
 real-clock timeout tests (the timeout machinery is transport-independent and must not race
@@ -163,10 +169,11 @@ What admits or excludes a cell:
   closes, grep for the reason string to find every cell to re-admit.
 - **`known_failures`** keep a cell in the grid but mark it as a strict xfail — the test runs and
   must fail; an unexpected pass fails the suite.
-- **`TRANSPORT_SPEC_VERSIONS`** era-locks a transport to a subset of spec versions (currently only
-  `sse` is locked to `2025-11-25`). A `(transport, version)` cell is dropped if the version is not
-  in the transport's entry; transports absent from the map serve every spec version. This is the
-  mechanism for cutting an entire transport off from a new revision (or admitting it).
+- **`TRANSPORT_SPEC_VERSIONS`** era-locks a transport to a subset of spec versions (currently
+  `sse` and `streamable-http-stateless` are locked to `2025-11-25`). A `(transport, version)`
+  cell is dropped if the version is not in the transport's entry; transports absent from the
+  map serve every spec version. This is the mechanism for cutting an entire transport off from
+  a new revision (or admitting it).
 - **`transports`** is descriptive metadata for the non-`connect` transport-specific suites under
   `transports/` and does **not** drive cell generation. Only `arm_exclusions`, `added_in`,
   `removed_in`, and `TRANSPORT_SPEC_VERSIONS` filter the grid.

tests/interaction/_connect.py

@@ -388,7 +388,9 @@ def httpx_client_factory(
     transport = sse_client(f"{BASE_URL}/sse", httpx_client_factory=httpx_client_factory)
     async with Client(
         transport,
-        # SSE is a legacy-only transport; the modern path has no SSE story.
+        # A policy lock, not a capability one: the dual-era server loop behind build_sse_app
+        # would negotiate 2026 if probed, but SSE is the deprecated legacy transport and its
+        # clients run the handshake era by design.
         mode="legacy",
         read_timeout_seconds=read_timeout_seconds,
         sampling_callback=sampling_callback,

tests/interaction/_requirements.py

@@ -1,7 +1,8 @@
 """SEP-2549 caching hints: producer-side stamping and client-facing TTL/scope semantics.
 
 One test pins 2026 wire frames (typed models hide absent-vs-default keys); one scripts a
-non-conformant server (the typed Server cannot author the malformed value); response caching is deferred.
+non-conformant server (the typed Server cannot author the malformed value). The client response
+cache is live but its serve/evict behaviours are not yet pinned here (see the caching:* deferrals).
 """
 
 import anyio
@@ -160,8 +161,9 @@ async def list_tools(ctx: ServerRequestContext, params: types.PaginatedRequestPa
 async def test_ttl_zero_results_are_refetched_on_every_access(connect: Connect) -> None:
     """Two consecutive list_tools calls against a ttlMs-0 server both reach the handler.
 
-    Passes by construction (the client has no response cache); the pin is the regression bar for
-    a future cache that wrongly serves a ttlMs-0 entry.
+    Load-bearing against the live response cache: a ttlMs-0 result is never stored, so every
+    access re-fetches, while the same seam with a positive ttl_ms serves the second access from
+    cache (one fetch).
     """
     fetches: list[int] = []
 

tests/interaction/lowlevel/test_caching.py

@@ -394,8 +394,10 @@ async def test_discover_carries_server_instructions_and_omits_them_when_undeclar
 async def test_discover_capabilities_reflect_registered_handlers() -> None:
     """The discover result advertises a capability per registered handler area and omits the rest.
 
-    Only era-clean areas are registered: the derivation is era-agnostic, so a subscribe or logging
-    handler would advertise an era-removed method -- a quirk deliberately left unpinned here.
+    Only era-clean areas are registered. The subscription-delivered bits are era-honest (at 2026
+    they derive from whether subscriptions/listen is served, so a legacy subscribe handler
+    advertises nothing), but logging derivation is still era-agnostic: a setLevel handler would
+    advertise the era-deprecated logging capability -- a quirk deliberately left unpinned here.
     """
 
     # The handlers exist only so their capability is advertised; none is ever called.

tests/interaction/lowlevel/test_client_connect.py

@@ -177,11 +177,12 @@ async def read_resource(ctx: ServerRequestContext, params: types.ReadResourceReq
 
 
 @requirement("protocol:error:handler-error-passthrough")
-async def test_read_resource_unknown_uri_is_protocol_error(connect: Connect) -> None:
-    """A handler that rejects an unrecognised URI with MCPError produces a JSON-RPC error.
+async def test_handler_raised_mcperror_code_and_message_reach_the_client_verbatim(connect: Connect) -> None:
+    """A handler-raised MCPError's code and message reach the client verbatim.
 
-    The spec reserves -32002 for resource-not-found; the code is the handler's choice and reaches
-    the client verbatim.
+    The -32002 here is only this handler's choice (the pre-2026 resource-not-found code; the 2026
+    spec reserves -32602 for an unknown URI). The real unknown-URI posture lives in the resource
+    registry and is pinned in mcpserver/test_resources.py; this test asserts the generic passthrough.
     """
 
     async def read_resource(ctx: ServerRequestContext, params: types.ReadResourceRequestParams) -> ReadResourceResult:

tests/interaction/lowlevel/test_resources.py

@@ -546,6 +546,7 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara
     server = Server("weather", on_list_tools=list_tools, on_call_tool=call_tool)
 
     async with connect(server) as client:
+        # The {} args matter: on http-2026 a non-empty call adds the server's internal Mcp-Param validation listing.
         first = await client.call_tool("forecast", {})
         assert list_calls == ["called"]
         second = await client.call_tool("forecast", {})

tests/interaction/lowlevel/test_tools.py

@@ -548,7 +548,9 @@ async def test_modern_client_stops_mirroring_after_a_re_list_drops_the_tool() ->
 
     The tool is first listed with a valid annotation (so a call mirrors `Mcp-Param-Region`), then re-listed
     with an invalid annotation -- the modern client drops it and evicts the cached map, so a later `tools/call`
-    by name carries no `Mcp-Param-*` header. Asserted at the wire, where the eviction is observable.
+    by name carries no `Mcp-Param-*` header. The server serves that header-less call only because the same
+    invalid schema disables its own validation (the shared validator skips schemas it rejects); a valid
+    annotated schema would reject the missing header. Asserted at the wire, where the eviction is observable.
     """
     schema = {"type": "object", "properties": {"a": {"type": "string", "x-mcp-header": "Region"}}}
     bad_schema = {"type": "object", "properties": {"a": {"type": "string", "x-mcp-header": "bad name"}}}
@@ -737,9 +739,10 @@ async def on_request(request: httpx.Request) -> None:
 async def test_null_and_absent_annotated_arguments_emit_no_param_headers_and_the_server_accepts() -> None:
     """Null and absent annotated arguments emit no ``Mcp-Param-*`` headers and the server accepts the call.
 
-    Spec-mandated by the behaviour matrix's null and absent rows. Acceptance currently holds
-    because the server validates no param headers at all; when that validation lands, null and
-    absent must not start being rejected.
+    Spec-mandated by the behaviour matrix's null and absent rows. The fixture advertises the
+    annotated schema, so this acceptance is a validated accept: the server checks each annotated
+    argument against its `Mcp-Param-*` header and would reject an orphan header for the null or
+    absent argument (a header matching no annotation is ignored).
     """
     requests: list[httpx.Request] = []