Widen 2026 cancel silence to every request on a modern-locked connection

The silence fact attached only after classification succeeded, so a
request rejected before classification (envelope-less, malformed envelope)
on a modern-locked connection could still answer after a peer cancel: the
reject runs on a task spawned after the read loop may have already
consumed an adjacent cancel. Unreachable under asyncio's FIFO scheduling -
the reject's answer write always starts before the cancel is consumed,
which is the legitimate already-answering case - but reachable under
trio's randomized scheduling and under any future checkpoint on the reject
path, where the frame written would have been the legacy code-0 answer or
a post-cancel rejection error.

Attach the fact at the top of the modern-locked branch instead, rejections
included: a rejection error is a legitimate answer, only the post-cancel
frame must be silent. On a still-unlocked connection the rule stays
classification-scoped (an unclassifiable request has not proven modern
semantics and keeps the legacy answer), initialize has no window at all
(inline dispatch parks the read loop), and a legacy straggler cancelled
after the lock keeps its legacy answer - scope documented at both
attachment sites and on serve_dual_era_loop.

With the locked branch owning the connection-scoped fact, serve_modern now
attaches its two per-request facts only while the era is unlocked: once
locked, the silence fact is already set and the era-lock observer is a
permanent no-op, so post-lock requests skip the partial allocation and the
per-frame observer invocation.

Author: maxisbey

src/mcp/server/runner.py

@@ -626,8 +626,19 @@ async def serve_dual_era_loop(
     Classified-modern requests are also governed by the 2026 cancellation
     rule for their whole lifetime: after an inbound `notifications/cancelled`
     the server sends nothing further for that request - no result, no error
-    (the transport spec's MUST NOT). Legacy-era requests keep the
-    byte-identical "Request cancelled" answer released 2025 clients expect.
+    (the transport spec's MUST NOT). Once the connection is LOCKED modern the
+    rule widens from classification-scoped to connection-scoped: every
+    request - including one rejected before classification succeeds
+    (envelope-less, malformed envelope) - carries the silence commitment, so
+    a rejection error computed after the peer's cancel never reaches the wire
+    (the rejection itself, absent a cancel, is of course still answered).
+    Legacy-era requests keep the byte-identical "Request cancelled" answer
+    released 2025 clients expect - including a legacy-classified request
+    still in flight when the modern lock commits (the straggler carve-out
+    covers its cancel answer, not just its response) - as does a request that
+    fails classification on a still-unlocked connection: an unclassifiable
+    request has not proven modern semantics, so the legacy answer stands
+    there.
     """
     dispatcher: JSONRPCDispatcher[TransportContext] = JSONRPCDispatcher(
         read_stream,
@@ -672,11 +683,18 @@ async def serve_modern(
         if isinstance(route, InboundLadderRejection):
             raise MCPError(code=route.code, message=route.message, data=route.data)
         # Classification succeeded: 2026 wire semantics govern this request's
-        # lifecycle from here. Both facts attach synchronously - no checkpoint
-        # since the dispatcher entered the handler scope - so a peer cancel
-        # can never interleave and observe the legacy defaults.
-        suppress_cancel_answer(dctx)
-        observe_success_frames(dctx, partial(commit_modern, dctx, route.protocol_version))
+        # lifecycle from here. On a still-unlocked connection this is the
+        # silence rule's exact scope - a request that fails classification
+        # above has not proven modern semantics and keeps the legacy cancel
+        # answer - and the era lock rides the request's first success frame.
+        # Both facts attach synchronously - no checkpoint since the
+        # dispatcher entered the handler scope - so a peer cancel can never
+        # interleave and observe the legacy defaults. Once the connection is
+        # locked, neither attaches here: `on_request` owns the
+        # connection-scoped silence fact, and the lock can never move again.
+        if era == "unlocked":
+            suppress_cancel_answer(dctx)
+            observe_success_frames(dctx, partial(commit_modern, dctx, route.protocol_version))
         connection = Connection.from_envelope(
             route.protocol_version,
             route.client_info,
@@ -718,6 +736,16 @@ async def on_request(
             # METHOD_NOT_FOUND a handshake-only server produced, byte for byte.
             return await loop_runner.on_request(dctx, method, params)
         if era == "modern":
+            # Connection-scoped silence: once locked modern, EVERY request is
+            # governed by the 2026 cancellation rule, rejections included - a
+            # rejection error is a legitimate answer, but nothing may follow
+            # the peer's `notifications/cancelled`. Pre-classification rejects
+            # run on a spawned task, so an adjacent cancel can precede them
+            # under trio's randomized scheduling (asyncio's FIFO always starts
+            # the reject's answer write first - the legitimate
+            # already-answering case; inline `initialize` has no window at
+            # all). See the cancellation paragraph on `serve_dual_era_loop`.
+            suppress_cancel_answer(dctx)
             if method == "initialize":
                 raise MCPError(
                     code=UNSUPPORTED_PROTOCOL_VERSION,

tests/server/test_runner.py

@@ -2101,6 +2101,47 @@ async def list_tools(ctx: Ctx, params: PaginatedRequestParams | None) -> ListToo
         assert answer.error.code == UNSUPPORTED_PROTOCOL_VERSION
 
 
+@pytest.mark.anyio
+async def test_dual_era_loop_modern_locked_envelope_less_reject_with_adjacent_cancel_never_answers_legacy():
+    """On a modern-locked connection the silence commitment is
+    connection-scoped: it attaches to every request, including one rejected
+    before classification (envelope-less). With the cancel adjacent behind
+    the request, asyncio's FIFO scheduling always starts the reject's answer
+    write before the read loop consumes the cancel - the legitimate
+    already-answering case - so exactly one frame appears for the id: the
+    INVALID_PARAMS classification error, never a code-0 legacy cancel answer,
+    and nothing after it. (The silenced arm - the cancel consumed before the
+    reject computes, reachable under trio's randomized scheduling - is pinned
+    at the dispatcher level by
+    test_suppress_cancel_answer_silences_even_an_error_raised_after_the_cancel_landed.)"""
+
+    async def list_tools(ctx: Ctx, params: PaginatedRequestParams | None) -> ListToolsResult:
+        return ListToolsResult(tools=[Tool(name="t", input_schema={"type": "object"})])
+
+    srv: SrvT = Server(name="fast-server", version="0.0.1", on_list_tools=list_tools)
+    async with raw_dual_era_loop(srv) as (c2s, s2c):
+        # Lock modern with a classified request.
+        c2s.send_nowait(_raw_req(1, "tools/list", _modern_params()))
+        locked = (await s2c.receive()).message
+        assert isinstance(locked, JSONRPCResponse)
+        # Envelope-less request with the cancel adjacent behind it.
+        c2s.send_nowait(_raw_req(9, "tools/list", {"plain": True}))
+        c2s.send_nowait(_raw_note("notifications/cancelled", {"requestId": 9}))
+        answer = (await s2c.receive()).message
+        assert isinstance(answer, JSONRPCError)
+        assert answer.id == 9
+        assert answer.error.code == INVALID_PARAMS
+        assert answer.error != ErrorData(code=0, message="Request cancelled")
+        # Nothing further for the cancelled id, and the connection stays healthy.
+        await anyio.wait_all_tasks_blocked()
+        with pytest.raises(anyio.WouldBlock):
+            s2c.receive_nowait()
+        c2s.send_nowait(_raw_req(10, "tools/list", _modern_params()))
+        result = (await s2c.receive()).message
+        assert isinstance(result, JSONRPCResponse)
+        assert result.id == 10
+
+
 @pytest.mark.anyio
 async def test_dual_era_loop_maps_unmapped_handler_exceptions_like_the_modern_http_entry():
     """An unmapped handler exception on a modern request surfaces as the