@@ -126,9 +126,8 @@ async def stdio_client(
     """
     command = _get_executable_command(server.command)
 
-    # A child process inherits stderr as an OS file descriptor. Writer objects that
-    # have none (Jupyter's ipykernel stream, io.StringIO) cannot be inherited, so the
-    # server's stderr is piped back and forwarded into errlog by a reader task instead.
+    # A child inherits stderr as a file descriptor; writers without one (ipykernel,
+    # StringIO) need the server's stderr piped back and forwarded by a reader task.
     forward_stderr = _lacks_file_descriptor(errlog)
 
     process = await _create_platform_compatible_process(
@@ -176,11 +175,7 @@ async def stdout_reader() -> None:
                 logger.exception("Reading from the MCP server's stdout failed mid-session")
 
     async def stderr_reader() -> None:
-        """Forwards the server's piped stderr into errlog.
-
-        Only runs when errlog could not be inherited by the child; keeps the
-        server's diagnostics visible where a bare fd hand-off would have lost them.
-        """
+        """Forwards the server's piped stderr into errlog when the child could not inherit it."""
         assert process.stderr, "Piped stderr is missing from the opened process"
 
         stderr = TextReceiveStream(process.stderr, encoding=server.encoding, errors="replace")
@@ -191,12 +186,10 @@ async def stderr_reader() -> None:
         except (anyio.ClosedResourceError, anyio.BrokenResourceError, ConnectionError):
             pass  # the pipe went away with the process; nothing left to forward
         except ValueError:
-            # errlog was closed under us (a notebook cell finishing, a StringIO
-            # released). The server's own traffic must not fail over a lost log sink.
+            # errlog closed under us; the session must not fail over a lost log sink.
             logger.debug("Stopped forwarding the MCP server's stderr: the log stream was closed")
         finally:
-            # Reaching EOF means the server's last diagnostics are in errlog, which
-            # is what shutdown waits on before cancelling this task.
+            # EOF means the last diagnostics have landed; shutdown waits on this.
             stderr_done.set()
 
     async def stdin_writer() -> None:
@@ -227,8 +220,8 @@ async def shutdown() -> None:
         if flush_scope.cancelled_caught:
             await anyio.lowlevel.cancel_shielded_checkpoint()  # resync coverage on 3.11 (gh-106749)
         await _stop_server_process(process)
-        # The server is dead, so its stderr pipe is at EOF with at most a buffer left;
-        # let the forwarder finish it before the task group's cancel takes the task out.
+        # The dead server's stderr is at EOF with at most a buffer left; let the
+        # forwarder drain it before the task group's cancel takes the task out.
         if forward_stderr:
             with anyio.move_on_after(_STDERR_DRAIN_TIMEOUT):
                 await stderr_done.wait()
@@ -361,10 +354,8 @@ def _close_subprocess_transport(process: ServerProcess) -> None:
 def _lacks_file_descriptor(errlog: TextIO) -> bool:
     """Reports whether errlog has no OS file descriptor for a child to inherit.
 
-    Jupyter's ipykernel stream and io.StringIO answer fileno() with an error;
-    real files, pipes and terminals return one. ipykernel does expose a
-    descriptor once fd capture is on, and that path already reaches the
-    notebook, so inheriting it stays correct.
+    ipykernel with fd capture on does expose one, and that path already reaches
+    the notebook, so inheriting it stays correct.
     """
     try:
         errlog.fileno()
 
@@ -196,11 +196,7 @@ async def feed_stderr(self, data: bytes) -> None:
         await self._stderr_send.send(data)
 
     def close_stderr(self) -> None:
-        """End the fake process's stderr, as the kernel does when it dies.
-
-        Closes both ends: unlike stdout, stderr goes unread whenever errlog owns a
-        descriptor, so nothing else would ever release the read end.
-        """
+        """End the fake process's stderr, closing both ends since stderr often goes unread."""
         self._stderr_send.close()
         self.stderr.close()
 
@@ -1021,19 +1017,15 @@ def write(self, s: str, /) -> int:
 async def test_a_closed_errlog_stops_stderr_forwarding_without_failing_the_session(
     monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
 ) -> None:
-    """Losing the log sink mid-session costs the diagnostics, never the session.
-
-    A notebook cell that finishes closes the stream underneath the forwarder; the
-    server's own traffic has to survive that.
-    """
+    """Losing the log sink mid-session costs the diagnostics, never the session."""
     errlog = _UnwritableErrlog()
     process = FakeProcess(on_stdin_close=lambda: process.exit(0))
     install_fake_process(monkeypatch, process)
     ping = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")
 
     with caplog.at_level(logging.DEBUG, logger="mcp.client.stdio"):
         with anyio.fail_after(5):
-            # no branch: coverage mis-traces the exit arcs of a nested `async with` on 3.14.
+            # Coverage mis-traces nested `async with` exit arcs on Python 3.11+.
             async with stdio_client(FAKE_PARAMS, errlog=cast(TextIO, errlog)) as (read_stream, _):  # pragma: no branch
                 await process.feed_stderr(b"server diagnostics no one will read\n")
                 await errlog.attempted.wait()
@@ -1050,11 +1042,7 @@ async def test_a_closed_errlog_stops_stderr_forwarding_without_failing_the_sessi
 async def test_a_stderr_pipe_dying_with_the_server_ends_forwarding_quietly(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    """A stderr pipe torn down with the process is shutdown noise, not an error.
-
-    The proactor loop reports a hard-killed pipe as a reset rather than EOF, which
-    must not propagate out of the transport.
-    """
+    """A stderr pipe torn down with the process is shutdown noise, not an error."""
     errlog = StringIO()
     process = FakeProcess(
         on_stdin_close=lambda: process.exit(0),
 
@@ -138,12 +138,7 @@ async def test_server_stderr_output_reaches_the_errlog_file(
     tmp_path: Path,
     spawned_processes: list[anyio.abc.Process | FallbackProcess],
 ) -> None:
-    """What the server writes to stderr lands in the file passed as `errlog`.
-
-    A real file has a descriptor, so the spawn hands it straight to the child and no
-    forwarding task is involved. The descriptor-less case is covered by
-    test_server_stderr_output_reaches_an_errlog_without_a_file_descriptor.
-    """
+    """Server stderr reaches the file passed as `errlog`."""
     marker = "stdio-lifecycle stderr marker 4242"
 
     async with AsyncExitStack() as stack:
@@ -178,12 +173,7 @@ async def test_server_stderr_output_reaches_the_errlog_file(
 async def test_server_stderr_output_reaches_an_errlog_without_a_file_descriptor(
     spawned_processes: list[anyio.abc.Process | FallbackProcess],
 ) -> None:
-    """Server stderr reaches an `errlog` that a child process cannot inherit.
-
-    Jupyter replaces sys.stderr with an ipykernel stream that has no descriptor to
-    hand over, which used to drop the server's diagnostics entirely (#156). StringIO
-    stands in for it here: same missing fileno, no notebook needed.
-    """
+    """Server stderr reaches an `errlog` with no descriptor for the child to inherit (#156)."""
     marker = "stdio-lifecycle fd-less stderr marker 4243"
     errlog = StringIO()
 
@@ -201,10 +191,9 @@ async def test_server_stderr_output_reaches_an_errlog_without_a_file_descriptor(
         )
         params = StdioServerParameters(command=sys.executable, args=["-c", server])
 
-        # The bound covers one interpreter cold start on a loaded runner; a
-        # healthy run takes well under a second.
+        # Allow one cold interpreter start on loaded CI.
         with anyio.fail_after(10.0):
-            # no branch: coverage mis-traces the exit arcs of a nested `async with` on 3.14.
+            # Coverage mis-traces nested `async with` exit arcs on Python 3.11+.
             async with stdio_client(params, errlog=errlog):  # pragma: no branch
                 stream = await accept_alive(sock)
                 stack.push_async_callback(stream.aclose)