@@ -4073,22 +4073,11 @@ def __post_init__(self) -> None:
             "(NoBackChannelError, INVALID_REQUEST) before any request reaches the client; a handler "
             "can catch it and fall back, and the originating call still completes."
         ),
-        divergence=Divergence(
-            note=(
-                "The prohibition is enforced by each transport's missing back-channel, not by an "
-                "era gate on the send path, and the enforcement splits per transport and per leg. "
-                "Standalone sends (no related_request_id) raise NoBackChannelError locally on both "
-                "2026 transports because the per-request Connection has no outbound channel. "
-                "Request-scoped sends (related_request_id=...) ride the per-request dispatch "
-                "context, whose can_send_request the modern HTTP entry hard-codes to False but the "
-                "in-memory direct-dispatcher pair leaves at its True default -- so in-memory the "
-                "forbidden elicitation/create frame IS transmitted, and the failure comes back from "
-                "the client's 2026 version gate (METHOD_NOT_FOUND) instead of arising locally. An "
-                "era-aware gate on the send path would loud-fail both legs on every transport; when "
-                "it lands, re-pin the request-scoped in-memory test to the local NoBackChannelError "
-                "and delete this divergence."
-            ),
-            issue="L107",
+        note=(
+            "Era-routed by construction: every modern dispatch path hands handlers a request-scoped "
+            "channel that refuses server-initiated requests and a connection with no standalone "
+            "back-channel, so the refusal is local on both legs of every 2026 transport, while legacy "
+            "connections keep their live back-channel."
         ),
         added_in="2026-07-28",
     ),
@@ -7647,15 +7636,18 @@ def __post_init__(self) -> None:
         transports=("stdio",),
         deferred=(
             "Not yet covered here: stream-pair 2026 serving landed -- serve_dual_era_loop "
-            "(src/mcp/server/runner.py) locks each stream-pair connection's era on its first "
-            "era-distinctive frame (a request that classifies as modern locks modern before it is "
-            "served; a successful initialize locks legacy; a rejected classification never locks), "
-            "routing server/discover and envelope-bearing requests to a per-request "
-            "Connection.from_envelope, and Server.run drives it for stdio, so the suite's "
-            "subprocess server (tests/interaction/transports/_stdio_server.py) already serves both "
-            "eras unchanged. The test connects a mode='auto' client that negotiates 2026-07-28 via "
-            "server/discover alongside the existing legacy-mode connection against the same "
-            "factory, over a real child-process pipe."
+            "(src/mcp/server/runner.py) locks each stream-pair connection's era on the first "
+            "era-distinctive frame to succeed (a request that classifies as modern locks modern "
+            "only after it is served to a client-visible success; a successful initialize locks "
+            "legacy; no failure of any kind locks -- rejected classification, malformed envelope "
+            "content, unknown method, handler error -- and a success the peer cancelled away from "
+            "does not lock either; the lock settles once, so a straggling other-era success "
+            "cannot move it), routing server/discover and envelope-bearing requests to a "
+            "per-request Connection.from_envelope, and Server.run drives it for stdio, so the "
+            "suite's subprocess server (tests/interaction/transports/_stdio_server.py) already "
+            "serves both eras unchanged. The test connects a mode='auto' client that negotiates "
+            "2026-07-28 via server/discover alongside the existing legacy-mode connection against "
+            "the same factory, over a real child-process pipe."
         ),
         note=(
             "stdio-only by definition: the dual-era HTTP analogue is the session manager's "
 
@@ -16,7 +16,6 @@
     CLIENT_INFO_META_KEY,
     INVALID_PARAMS,
     INVALID_REQUEST,
-    METHOD_NOT_FOUND,
     PROTOCOL_VERSION_META_KEY,
     CallToolResult,
     ClientCapabilities,
@@ -481,8 +480,10 @@ async def call_tool(
 async def test_push_elicit_on_2026_raises_typed_local_error_and_call_still_completes(connect: Connect) -> None:
     """A push API call on a 2026 connection raises a typed local error and the call still completes.
 
-    Spec-mandated outcome, incidental enforcement: the gate is "no back-channel", not "wrong era".
-    One push API stands for all four: they share ServerSession.send_request's channel selection.
+    Spec-mandated outcome, era-routed enforcement: every modern dispatch path installs a
+    channel-less context by construction, so the gate is "no back-channel", never a send-time
+    era check. One push API stands for all four: they share ServerSession.send_request's
+    channel selection.
     """
     caught: list[NoBackChannelError] = []
 
@@ -524,14 +525,16 @@ async def never_deliverable(context: ClientRequestContext, params: types.ElicitR
 
 
 @requirement("mrtr:push-api:loud-fail-2026")
-async def test_request_scoped_push_elicit_on_in_memory_2026_transmits_the_forbidden_frame() -> None:
-    """PINS A KNOWN GAP: a request-scoped push elicit on in-memory 2026 transmits the forbidden frame.
-
-    The no-back-channel gate is per-transport and the in-memory request-scoped channel still has one,
-    so the failure comes back from the client's 2026 version gate instead of arising locally. When an
-    era-aware send gate lands: re-pin to the local NoBackChannelError and delete the Divergence.
+async def test_request_scoped_push_elicit_on_in_memory_2026_loud_fails_locally_and_the_call_still_completes() -> None:
+    """A request-scoped push elicit on in-memory 2026 loud-fails locally and the call still completes.
+
+    The related id routes the send onto the per-request dispatch channel -- the one leg whose
+    channel is otherwise live in-memory -- so this pin proves local provenance: the typed
+    NoBackChannelError (never a peer answer) and a callback that never fires. A delivered frame
+    would raise NotImplementedError in the callback, surface as a non-NoBackChannelError error,
+    escape the narrowed except, and fail the test loudly.
     """
-    caught: list[MCPError] = []
+    caught: list[NoBackChannelError] = []
 
     async def list_tools(
         ctx: ServerRequestContext, params: types.PaginatedRequestParams | None
@@ -544,26 +547,32 @@ async def call_tool(ctx: ServerRequestContext, params: types.CallToolRequestPara
         try:
             # The related id routes the send onto the per-request dispatch channel.
             await ctx.session.elicit_form("Need a name", _NAME_SCHEMA, related_request_id=ctx.request_id)
-        except MCPError as exc:
-            # MCPError, not NoBackChannelError: nothing is raised locally -- the failure is the peer's answer.
+        except NoBackChannelError as exc:
+            # Narrow on purpose: a peer-answered MCPError would propagate and fail the test.
             caught.append(exc)
         return CallToolResult(content=[TextContent(text="fallback")])
 
     server = Server("scoped-push", on_list_tools=list_tools, on_call_tool=call_tool)
 
-    # Declares the elicitation capability; the body is itself the never-delivered assertion.
+    # Registering the callback declares the elicitation capability; it must never fire.
     async def never_deliverable(context: ClientRequestContext, params: types.ElicitRequestParams) -> ElicitResult:
         raise NotImplementedError
 
     async with Client(server, mode=LATEST_MODERN_VERSION, elicitation_callback=never_deliverable) as client:
         result = await client.call_tool("ask", {})
 
-    # The connection survives the rejected frame.
+    # The failed push did not poison the request: the call completes with the handler's fallback.
     assert result == snapshot(CallToolResult(content=[TextContent(text="fallback")]))
     assert len(caught) == 1
-    # Only the pre-dispatch client version gate answers data=<method>: transmission proven, callback never reached.
+    assert caught[0].method == "elicitation/create"
     assert caught[0].error == snapshot(
-        ErrorData(code=METHOD_NOT_FOUND, message="Method not found", data="elicitation/create")
+        ErrorData(
+            code=INVALID_REQUEST,
+            message=(
+                "Cannot send 'elicitation/create': this transport context has no back-channel "
+                "for server-initiated requests."
+            ),
+        )
     )
 
 
 
@@ -1377,9 +1377,9 @@ async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) ->
 async def test_modern_request_scoped_push_elicit_loud_fails_locally_and_the_call_still_completes() -> None:
     """A request-scoped push elicit over the modern HTTP entry loud-fails locally and the call still completes.
 
-    Spec-mandated outcome; the enforcement here is incidental (no back-channel, not an era gate).
-    The in-memory twin of this leg still transmits the frame -- the divergence pinned in
-    lowlevel/test_mrtr.py -- so the modern entry's gate gets its own regression pin.
+    Spec-mandated outcome: the modern HTTP entry builds its per-request channel with no
+    back-channel, so the refusal is local by construction. The in-memory twin of this leg is
+    pinned in lowlevel/test_mrtr.py; this pin keeps the HTTP entry's own gate regression-covered.
     """
     caught: list[NoBackChannelError] = []