@animalabs/agent-framework 0.22.2 → 0.23.0

package/dist/src/mcpl/server-connection.js

@@ -9,11 +9,12 @@
  * stdio and WebSocket behave identically above the transport seam.
  */
 import { EventEmitter } from 'node:events';
-import { openTransport } from './transport.js';
+import { openTransport, STDERR_END_WAIT_MS } from './transport.js';
 import { maskNegotiatedCapabilities } from './capability-mask.js';
 import { CapabilityGrant, expandAdvertisementShorthand } from './capability-grant.js';
-import { CAPABILITY_DISABLED } from './errors.js';
-import { logDetail, logValue } from './log-value.js';
+import { CAPABILITY_DISABLED, boundedForLog, describeCause } from './errors.js';
+import { logDetail, logValue, logValueRedacted } from './log-value.js';
+import { LEGACY_MCP_PROTOCOL_VERSION, MODERN_MCP_PROTOCOL_VERSION, checkServerConfig, redactServerText, } from './protocol-family.js';
 import { McplMethod } from './types.js';
 /** Timeout for the initialize handshake in milliseconds.
  *  Spring Boot + JDA servers can take 5-10s to boot, so 30s is safe. */
@@ -25,14 +26,30 @@ export function stderrTailOf(error) {
     return typeof tail === 'string' && tail !== '' ? tail : undefined;
 }
 /** For the host's own log line about a failed connect: the server's stderr
- *  that the error keeps as `stderrTail`, one marked line per line of it,
- *  each through log-value, since it's the server's text. '' when there's
+ *  that the error keeps as `stderrTail`, with the server's credentials
+ *  taken out by `redact` (its redactServerText), one marked line per line of
+ *  it, each through log-value, since it's the server's text. '' when there's
  *  none. */
-export function withStderr(error) {
+export function withStderr(error, redact) {
     const tail = stderrTailOf(error);
     if (tail === undefined)
         return '';
-    return '. The last of its stderr:' + tail.split('\n').map((line) => `\n  stderr: ${logDetail(line)}`).join('');
+    return '. The last of its stderr:' + redact(tail).split('\n').map((line) => `\n  stderr: ${logDetail(line)}`).join('');
+}
+/** A transport close's reason, as the host's log and the handshake's error
+ *  give it: the transport's own words. A WebSocket peer's close reason is the
+ *  server's text (`reasonFromPeer`), so they give the words the transport uses
+ *  for a close without one, as `mcpl:server-closed` leaves that text out. A
+ *  WebSocket close's code, a number, says what the server meant (4001: a
+ *  refused credential), with or without a reason, so each gives it too: the
+ *  log line for a close with requests pending has `code=`, and the
+ *  handshake's error adds it for any WebSocket close, since a close before the
+ *  handshake completes reaches no 'close' event. A stdio child's exit reads
+ *  as before. */
+function closeReasonText(info) {
+    if (info.reasonFromPeer)
+        return 'websocket closed';
+    return info.reason ?? 'unknown';
 }
 /** Default per-request timeout in milliseconds (see McplServerConfig.requestTimeoutMs).
  *  A live-but-wedged server (accepts requests, never answers, never closes its
@@ -40,8 +57,143 @@ export function withStderr(error) {
  *  endTurn, no further wakes, zero errors anywhere. 60s is generous for real
  *  tool work while still bounding the hang. */
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
-/** MCP protocol version used in the initialize handshake. */
-const MCP_PROTOCOL_VERSION = '2024-11-05';
+/** MCP protocol version used in the initialize handshake: the only revision
+ *  this legacy engine offers or accepts. */
+const MCP_PROTOCOL_VERSION = LEGACY_MCP_PROTOCOL_VERSION;
+/** JSON-RPC code for an unsupported protocol version (MCP 2026-07-28 §basic,
+ *  the code a modern-only server answers our `initialize` with). */
+const UNSUPPORTED_PROTOCOL_VERSION_CODE = -32022;
+/** Upper bound on `tools/list` pages, against a server whose cursors never
+ *  end. Generous: real inventories fit in a handful of pages. */
+const MAX_TOOL_LIST_PAGES = 100;
+/**
+ * The server and this engine have no protocol revision in common, so the
+ * connection was never established. This is a protocol-negotiation fact, not
+ * a request outcome. Retrying cannot change it: each engine offers one
+ * revision, and only configuration can fix the mismatch. A connection that
+ * gets this error does not schedule reconnects. The legacy engine and the
+ * modern one (ModernMcpConnection, whose pinned revision the server refused)
+ * both throw it, so its readers treat them alike.
+ *
+ * - `rejected`: the server refused the offered revision: the legacy engine's
+ *   `initialize` answered with error -32022, or a modern server's discovery
+ *   or error naming no common revision. `supported` is the server's own list,
+ *   when it gave one.
+ * - `mismatch`: the server answered the legacy engine's `initialize` with a
+ *   revision other than 2024-11-05, or with none.
+ */
+export class McplProtocolVersionError extends Error {
+    kind;
+    returned;
+    supported;
+    code;
+    data;
+    offered;
+    constructor(message, kind, 
+    /** Revision the server answered with (`mismatch`; null when it gave none). */
+    returned, 
+    /** Revisions the server says it supports (`rejected`, when stated). */
+    supported, 
+    /** The JSON-RPC error's code and data, verbatim (`rejected`). */
+    code, data, 
+    /** The revision this client offered: the legacy engine's, unless a
+     *  modern connection's. */
+    offered = MCP_PROTOCOL_VERSION) {
+        super(message);
+        this.kind = kind;
+        this.returned = returned;
+        this.supported = supported;
+        this.code = code;
+        this.data = data;
+        this.offered = offered;
+        this.name = 'McplProtocolVersionError';
+    }
+}
+function protocolVersionRejection(id, error) {
+    const data = error.data;
+    const supported = Array.isArray(data?.supported) && data.supported.every((v) => typeof v === 'string')
+        ? data.supported
+        : null;
+    const modernHint = supported?.includes(MODERN_MCP_PROTOCOL_VERSION)
+        ? ` It speaks modern MCP: configure it with protocol: 'modern' (stdio) or reach it over http(s).`
+        : '';
+    return new McplProtocolVersionError(`MCPL server "${id}" does not support MCP ${MCP_PROTOCOL_VERSION}` +
+        // The server's message can be any JSON value, so it's read without
+        // throwing (describeCause) and bounded, as the initialize error is.
+        (supported ? ` (it supports: ${supported.join(', ') || 'none listed'}).` : ` (${boundedForLog(describeCause(error.message))}).`) +
+        modernHint, 'rejected', null, supported, error.code, error.data);
+}
+const errorOf = (value) => (value instanceof Error ? value : new Error(String(value)));
+/**
+ * A handshake that failed, and whose cleanup couldn't confirm that the child
+ * exited. The transport goes to whoever owns the launch.
+ */
+class HandshakeCleanupError extends Error {
+    failure;
+    cleanup;
+    transport;
+    constructor(failure, cleanup, transport) {
+        super(`${failure.message}; its cleanup also failed: ${cleanup.message}`, { cause: failure });
+        this.failure = failure;
+        this.cleanup = cleanup;
+        this.transport = transport;
+        this.name = 'HandshakeCleanupError';
+    }
+}
+/**
+ * A connect that failed, and whose cleanup couldn't confirm that the child
+ * exited: it may still be running. `connection` owns that launch, closed and
+ * not reconnecting. Its close() retries the reap and resolves once the exit
+ * is confirmed, so the caller can still clean up, and should start nothing
+ * else for this server until then. connect() and connectWithReconnect()
+ * throw this, and the modern engine's ModernMcpConnection.connect() too.
+ * `cause` is the connect's own failure.
+ */
+export class McplUnreapedLaunchError extends Error {
+    connection;
+    cleanup;
+    constructor(connection, failure, 
+    /** The cleanup's own failure: the child it couldn't confirm exited. */
+    cleanup) {
+        super(`${failure.message}; its cleanup also failed: ${cleanup.message}`, { cause: failure });
+        this.connection = connection;
+        this.cleanup = cleanup;
+        this.name = 'McplUnreapedLaunchError';
+    }
+}
+/**
+ * Why a request to an MCPL server produced no result, as far as the host can
+ * know it. Messages are unchanged from plain errors; the `outcome` makes the
+ * difference between "never left the host" and "left, and no answer came
+ * back" a fact a caller can act on instead of a string to match:
+ * - `not-sent`: the request was refused before anything was written (the
+ *   connection was already closed);
+ * - `error-response`: the server answered with a JSON-RPC error (it may have
+ *   acted before failing; the error alone does not say);
+ * - `no-response`: the request was handed to the transport and no answer
+ *   came back (timeout, or the connection closed while awaiting). It does
+ *   not prove the request reached the server — the transport can decline or
+ *   drop a write — only that the host can no longer say it didn't.
+ */
+export class McplRequestError extends Error {
+    outcome;
+    data;
+    constructor(message, outcome, 
+    /** The JSON-RPC error's `data`, verbatim, when the server supplied one
+     *  (e.g. which parts of a multi-part send were posted). */
+    data) {
+        super(message);
+        this.outcome = outcome;
+        this.data = data;
+        this.name = 'McplRequestError';
+    }
+}
+/** A request's method for a log line, whatever the server sent there. */
+function describeMethod(method) {
+    return typeof method === 'string'
+        ? `method ${logValue(method)}`
+        : `a method of type ${method === null ? 'null' : typeof method}`;
+}
 /**
  * McplServerConnection manages a single JSON-RPC 2.0 connection to an
  * MCPL server over stdio. Use the static `connect()` factory to create
@@ -63,7 +215,12 @@ const MCP_PROTOCOL_VERSION = '2024-11-05';
  *   server's stderr when its handshake failed by its transport closing, a
  *   transport error or its timeout and it had written any; `error` never
  *   carries it.
- * - `'reconnect'`          — Background reconnect succeeded
+ * - `'reconnect'`          — Background reconnect succeeded. The new transport
+ *                            starts with an empty grant and both planes
+ *                            closed, as at initial connect: whoever owns the
+ *                            connection runs the §5.3 policy exchange again,
+ *                            then opens the planes (the framework's listener
+ *                            does).
  */
 export class McplServerConnection extends EventEmitter {
     /** Unique server identifier from config. */
@@ -79,6 +236,9 @@ export class McplServerConnection extends EventEmitter {
     /** OUTER standard MCP capabilities.tools was present at handshake (§5.1 —
      *  the sole source of the `tools` capability path). */
     mcpToolsAdvertised = false;
+    /** The MCP revision established by the last successful handshake (always
+     *  2024-11-05 for this engine), or null before the first one. */
+    protocolVersion = null;
     /** Host-owned per-server authority for host/command (config
      *  allowHostCommands, default false). No capability path exists and the
      *  grant cannot confer it — server params never decide admin authority. */
@@ -133,6 +293,22 @@ export class McplServerConnection extends EventEmitter {
         this.grant = CapabilityGrant.empty();
         this.policyEstablished = false;
         this.transportEpoch++;
+        // What the server sent that is still held came on the transport that is
+        // now gone. What it said about its own process is dropped: its requests
+        // wait on answers that can no longer reach whoever asked (an inference
+        // request, a host/command), and its announcements describe a process
+        // that is gone (a tools/observe filter, a channel registration), so the
+        // next one announces its own. What it reported about the world is kept: a
+        // channel's incoming messages and its pushes, which the next process
+        // doesn't send again when its bridge records them as forwarded first, as
+        // discord-mcpl does with its watermark. They are admitted at the flush
+        // against the next transport's grant, like anything held, and an answer
+        // to one is never written to the next transport (sameTransport); a
+        // connection closed for good, with no next transport, drops them. The
+        // host's own reports about the transport stay too: its lifecycle
+        // (connect-failed, reconnect-failed), the server's stderr, and
+        // orphaned-response audits.
+        this.replaceHeld(this.keepAcrossBoundary(this.bufferedEvents));
         // RFC-007 §6.5: a filter is per connection epoch — after a reconnect the
         // server sends it again, and until then receives metadata only.
         this.toolObserveFilter = null;
@@ -142,6 +318,59 @@ export class McplServerConnection extends EventEmitter {
         // (Sol, PR #84 review — they previously survived into the new epoch).
         this.manifestState = { lastValidatedRevision: null, lastFetchedAt: null, lastNegotiatedAt: null };
     }
+    /** What of these held items a transport boundary keeps (see
+     *  resetPolicyForTransportBoundary), in order, each marked `kept`; the
+     *  rest is logged and dropped. A connection closed for good has no next
+     *  transport whose grant could admit what the server reported about the
+     *  world, so that is dropped too. */
+    keepAcrossBoundary(held) {
+        const forGood = this.closedForGood;
+        const drops = (item) => McplServerConnection.PROCESS_EVENTS.has(item.event)
+            || (forGood && McplServerConnection.WORLD_EVENTS.has(item.event));
+        const kept = held.filter((item) => !drops(item));
+        if (kept.length < held.length) {
+            // Named by event, with a count, so a dropped request a server was
+            // waiting on, which no answer will now reach, can be told apart.
+            const counts = new Map();
+            for (const item of held)
+                if (drops(item))
+                    counts.set(item.event, (counts.get(item.event) ?? 0) + 1);
+            const what = [...counts].map(([event, count]) => `${count} ${logValue(event)}`).join(', ');
+            console.error(`[mcpl] ${this.id}: dropped ${held.length - kept.length} held message(s) from a transport that closed` +
+                `${forGood ? ', with no transport to come' : ''}: ${what}`);
+        }
+        return kept.map((item) => ({ ...item, kept: true }));
+    }
+    /** Hold these items in place of what is held, with heldRequests and
+     *  keptRequests counting the requests among them: a boundary keeps some of
+     *  what was held, a flush that crosses one holds the rest of its snapshot
+     *  again, and a flush starts from nothing held. Notifications need no cap
+     *  here: hold caps them kept or not, and what this is given never has more
+     *  than was held. */
+    replaceHeld(items) {
+        // The kept bound holds here too: boundaries that come with no flush
+        // between them each keep what the next transport held, so it's checked
+        // where they're joined. The earliest kept are kept, as at hold.
+        let kept = 0;
+        let past = 0;
+        this.bufferedEvents = items.filter((item) => {
+            if (item.kept !== true || !McplServerConnection.hasResponder(item))
+                return true;
+            if (kept < McplServerConnection.MAX_HELD_REQUESTS) {
+                kept++;
+                return true;
+            }
+            past++;
+            return false;
+        });
+        this.heldRequests = this.bufferedEvents.filter((item) => !item.kept && McplServerConnection.hasResponder(item)).length;
+        this.keptRequests = kept;
+        if (past > 0) {
+            this.droppedKeptRequests += past;
+            console.error(`[mcpl] ${this.id}: kept-request bound (${McplServerConnection.MAX_HELD_REQUESTS}) — ` +
+                `dropped ${past} request(s) a closed transport left`);
+        }
+    }
     /** The active transport (stdio child or WebSocket). Null for a disconnected
      *  stub awaiting its first background reconnect. */
     transport;
@@ -159,11 +388,21 @@ export class McplServerConnection extends EventEmitter {
     /** Set by `reconnectAfterFailure()` before it closes a live transport, so
      *  the transport close handler reports that teardown as `byHost: true`. */
     hostCloseRequested = false;
+    /** Set by `close()`: this host has stopped the connection, as a removal and
+     *  a restart both do, so a request after it can't say whether the server
+     *  comes back. */
+    closedByThisHost = false;
+    /** The host's close attempt: in flight, or done. A failed one is cleared,
+     *  so the next close() tries again. */
     closePromise = null;
+    /** The host closed this connection while it was live, and its teardown
+     *  hasn't completed yet: 'close' is emitted once it has. */
     closeIncomplete = false;
-    reconnectPromise = null;
     /** Per-request timeout in ms (0 disables). See McplServerConfig.requestTimeoutMs. */
     requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS;
+    /** The deadline a channels/publish or channels/open request keeps when
+     *  requestTimeoutMs is 0 (see sendChannelsPublish). */
+    publishDeadlineMs = DEFAULT_REQUEST_TIMEOUT_MS;
     // Event buffering: control-plane traffic can be released independently from
     // inference-bearing data-plane traffic. This lets a server finish its own
     // registration (and answer host tools/call requests) while startup/reconnect
@@ -171,15 +410,37 @@ export class McplServerConnection extends EventEmitter {
     controlPlaneReady = false;
     dataPlaneReady = false;
     bufferedEvents = [];
-    /** Cap on buffered responder-less events during a plane pause (issue #122).
-     *  Held server→host requests are never dropped and may exceed this. */
-    static MAX_BUFFERED_EVENTS = 1000;
+    /** How many of bufferedEvents are server→host requests, each holding a
+     *  responder its server waits on. Every change to bufferedEvents keeps it. */
+    heldRequests = 0;
+    /** How many of bufferedEvents are requests a transport boundary kept:
+     *  incoming messages and pushes whose transport has closed. No server waits
+     *  on them, since their answers can't reach it (sameTransport), so they
+     *  stay out of the held-request budget, which bounds what a live server
+     *  waits on: a dead process's backlog must not refuse the next process's
+     *  registration. They have their own bound at the same size, past which a
+     *  kept request is dropped and logged, there being no one to refuse. */
+    keptRequests = 0;
+    /** Kept requests dropped at their bound since the planes last opened
+     *  (ready()), so the first of each run of drops is logged. */
+    droppedKeptRequests = 0;
+    /** Cap on held notifications (responder-less events) during a plane pause
+     *  (issue #122), counted apart from requests: past it, the oldest held
+     *  notification is dropped. */
+    static MAX_HELD_NOTIFICATIONS = 1000;
+    /** Budget of held requests during a plane pause (#387), counted apart from
+     *  notifications: past it, a request is refused at once, never dropped. It
+     *  bounds a server that pipelines requests without waiting for answers. A
+     *  server that doesn't send a refused request again loses it (discord-mcpl
+     *  doesn't), so the budget sits far above the notifications' cap, to leave
+     *  a busy server's long pause room. Requests a transport boundary kept are
+     *  counted apart from it (keptRequests), with a bound of the same size past
+     *  which they're dropped, since no server waits on them. */
+    static MAX_HELD_REQUESTS = 10_000;
     droppedBufferedEvents = 0;
-    /** True while ready()/readyControlPlane() re-emit a buffer snapshot. Items
-     *  re-buffering mid-flush were already admitted once — applying the cap to
-     *  them again would evict events that were legally held (the cap targets
-     *  NEW arrivals during a pause, not churn from control-plane flushes). */
-    flushDepth = 0;
+    /** Requests refused at the budget since the planes last opened (ready()),
+     *  so each pause's first refusal is logged. */
+    refusedHeldRequests = 0;
     // Reconnect state (adapted from Anarchid/agent-framework@mcpl-module-proto)
     config = null;
     hostCapabilities = null;
@@ -190,11 +451,33 @@ export class McplServerConnection extends EventEmitter {
     /** Consecutive failed connect attempts since the last successful handshake.
      *  Drives the exponential backoff and is reported on reconnect events. */
     reconnectAttempts = 0;
+    /** The reconnect attempt in flight, so close() can abort it and wait for
+     *  its cleanup. */
+    reconnecting = null;
+    /**
+     * Launches whose cleanup couldn't confirm that the child exited. While any
+     * is held, reconnecting is halted, since another launch could run beside
+     * one that's still alive. close() retries their reap.
+     */
+    unreaped = [];
     /** Whether a background reconnect loop will revive this connection after a
-     *  drop. False once close() has been called (explicit close stops retrying). */
+     *  drop. False once close() has been called (explicit close stops retrying),
+     *  after a protocol-version verdict, and while a launch is unreaped. */
     get willReconnect() {
         return this.reconnectEnabled;
     }
+    /** Whether a child this connection launched couldn't be confirmed exited.
+     *  While it's true the connection owns that child, so whatever registered
+     *  it keeps its id held; close() retries the reap. */
+    get holdsUnreapedChild() {
+        return this.unreaped.length > 0;
+    }
+    /** Closed with no reconnect to come: after close(), whether or not its
+     *  transport close succeeded, or a drop with reconnect off. A connection
+     *  between retries keeps reconnectEnabled, so it isn't closed for good. */
+    get closedForGood() {
+        return this.closed && !this.reconnectEnabled;
+    }
     /**
      * Private constructor. Use `McplServerConnection.connect()` instead.
      */
@@ -215,58 +498,206 @@ export class McplServerConnection extends EventEmitter {
      * Mark the connection as ready — flushes any events that arrived between
      * construction (when setupMessageRouting starts emitting) and now (when
      * the caller has attached listeners via wireMcplEvents).
+     *
+     * Once the connection is closed for good it readies nothing. Its policy was
+     * reset when it closed, so what the server sent that needs a grant would be
+     * refused, and a closed connection sends no response, so nothing it held
+     * could be answered. It delivers only its own reports of how it ended (see
+     * {@link deliverOwnReports}). A connection between retries isn't closed for
+     * good: what it held, such as a reconnect stub's connect-failed, reaches
+     * its listeners as it does any connection's, except the incoming messages
+     * and pushes a transport boundary kept, which wait for the next
+     * transport's grant (see {@link flushHeld}).
      */
     ready() {
+        if (this.closedForGood) {
+            this.deliverOwnReports();
+            return;
+        }
         this.controlPlaneReady = true;
         this.dataPlaneReady = true;
         const pending = this.bufferedEvents;
-        this.bufferedEvents = [];
+        this.replaceHeld([]);
+        // The cap's drops are counted per pause: this flush ends one, so its line
+        // reports that pause's drops, and the next pause counts (and logs) its own.
+        const dropped = this.droppedBufferedEvents;
+        this.droppedBufferedEvents = 0;
+        this.refusedHeldRequests = 0;
+        this.droppedKeptRequests = 0;
         if (pending.length > 200) {
             console.error(`[mcpl] ${this.id}: flushing ${pending.length} buffered event(s) synchronously ` +
-                `(long pause backlog${this.droppedBufferedEvents > 0 ? `; ${this.droppedBufferedEvents} dropped at cap` : ''})`);
+                `(long pause backlog${dropped > 0 ? `; ${dropped} dropped at cap` : ''})`);
         }
-        this.flushDepth++;
-        try {
-            for (const { event, args } of pending) {
-                // Re-enter the gate for every buffered item. A control handler (notably
-                // tools/list_changed) may install a newer data-plane barrier while this
-                // snapshot is being flushed; later data items must observe that pause.
-                this.emit(event, ...args);
+        // Re-enter the gate for every buffered item. A control handler (notably
+        // tools/list_changed) may install a newer data-plane barrier while this
+        // snapshot is being flushed; later data items must observe that pause.
+        this.flushHeld(pending);
+    }
+    /**
+     * Re-emit a held snapshot through the admission gate (this.emit), inside
+     * the containment boundary every inbound event shares
+     * (dispatchInboundEvent), in admission order (admissionOrder). A transport
+     * boundary crossed during the flush (a listener that closes the connection,
+     * say) leaves the rest of the snapshot to the boundary rule, as if it had
+     * still been held: what the server said about its own process is dropped,
+     * and the rest is held again, after whatever this flush held.
+     *
+     * Between transports, the incoming messages and pushes a boundary kept
+     * stay held for the next transport's grant: admitted now, they would meet
+     * the empty grant the boundary left, with no transport to answer on. The
+     * host's own reports about the transport (a stub's connect-failed, say)
+     * need no grant and go on.
+     */
+    flushHeld(snapshot) {
+        const waits = (item) => item.kept === true && McplServerConnection.WORLD_EVENTS.has(item.event);
+        let pending = snapshot;
+        if (!this.isConnected && snapshot.some(waits)) {
+            this.replaceHeld([...this.bufferedEvents, ...snapshot.filter(waits)]);
+            pending = snapshot.filter((item) => !waits(item));
+        }
+        const ordered = McplServerConnection.admissionOrder(pending);
+        const epoch = this.transportEpoch;
+        for (let index = 0; index < ordered.length; index++) {
+            if (this.transportEpoch !== epoch) {
+                this.replaceHeld([...this.bufferedEvents, ...this.keepAcrossBoundary(ordered.slice(index))]);
+                return;
             }
+            const { event, args, kept } = ordered[index];
+            // What it can't admit yet is held again, as the admission gate would
+            // hold it, with what a boundary kept still marked as kept.
+            if (kept && !this.planeReadyFor(event))
+                this.hold(event, args, kept);
+            else
+                this.dispatchInboundEvent(event, ...args);
         }
-        finally {
-            this.flushDepth--;
+    }
+    /** Whether the plane an event belongs to is open (lifecycle events always
+     *  pass), as the admission gate (emit) decides it. */
+    planeReadyFor(event) {
+        return McplServerConnection.isLifecycleEvent(event)
+            || (McplServerConnection.isControlPlaneEvent(event) ? this.controlPlaneReady : this.dataPlaneReady);
+    }
+    /**
+     * The order a flush admits a held snapshot in: as it was held, except that
+     * when it holds items a transport boundary kept, the current transport's
+     * channel registrations (`channels-register`, `channels-changed`) go
+     * first, each unless it names a channel that something the transport sent
+     * before it, and that stays where it was held, also names (below). The
+     * registry refuses a message for a channel it doesn't know
+     * (§14.5). It keeps a server's channels across a reconnect, but a
+     * registration the old process sent that was still held at the boundary
+     * was dropped with it (keepAcrossBoundary), so the next process registers
+     * that channel anew, behind what was kept: a kept message for it admitted
+     * first would be refused, and lost, since a bridge that recorded it as
+     * forwarded doesn't send it again.
+     * Nothing else moves, so a snapshot with nothing kept is flushed as it was
+     * held. A registration also passes whatever its own transport sent before
+     * it, which a server that announces its channels first, as a bridge does,
+     * never has. A removal stays where it was held, with whatever else it adds
+     * or updates, as everything does that isn't a registration. A registration
+     * that names a channel which an earlier removal, or an earlier registration
+     * that stays, names stays where it was held too, so the writes to one
+     * channel keep their order: a channel's removal and its re-registration,
+     * and two registrations or updates of it. In a flush that opens both
+     * planes, what the transport sent before a removal is admitted before it,
+     * its messages for that channel included. A flush that opens only the control
+     * plane, as during a quiesce, admits the control traffic, a removal
+     * included, and holds the data plane's again until that plane opens, as
+     * live traffic is during a quiesce: a message held for a channel a removal
+     * took is then refused as the data plane opens.
+     */
+    static admissionOrder(pending) {
+        if (!pending.some((item) => item.kept))
+            return pending;
+        const registrations = new Set();
+        // The channels named so far by a removal or registration that stays
+        // where it was held.
+        const staying = new Set();
+        for (const item of pending) {
+            if (item.kept)
+                continue;
+            if (item.event !== 'channels-register' && item.event !== 'channels-changed')
+                continue;
+            const removes = McplServerConnection.removedChannelIds(item);
+            const registers = McplServerConnection.registeredChannelIds(item);
+            if (removes.length === 0 && !registers.some((id) => staying.has(id))) {
+                registrations.add(item);
+                continue;
+            }
+            for (const id of [...removes, ...registers])
+                staying.add(id);
         }
+        if (registrations.size === 0)
+            return pending;
+        return [...registrations, ...pending.filter((item) => !registrations.has(item))];
+    }
+    /** The channels a held `channels-changed` removes. The registry takes any
+     *  entry of `removed` as a channel id, by its string form, so a number
+     *  removes the channel of its digits; an object is left out here, since
+     *  its string form can throw. */
+    static removedChannelIds(item) {
+        if (item.event !== 'channels-changed')
+            return [];
+        const params = item.args[0];
+        return Array.isArray(params?.removed)
+            ? params.removed.filter((id) => typeof id !== 'object' || id === null).map((id) => String(id))
+            : [];
+    }
+    /** The channels a held `channels-register` registers, or a held
+     *  `channels-changed` adds or updates. */
+    static registeredChannelIds(item) {
+        const params = item.args[0];
+        const lists = item.event === 'channels-register' ? [params?.channels] : [params?.added, params?.updated];
+        return lists.flatMap((list) => (Array.isArray(list) ? list : []))
+            .map((channel) => channel?.id)
+            .filter((id) => typeof id === 'string');
     }
     /**
      * Release only server-establishment and lifecycle/control traffic. Responses
      * to host requests are never event-buffered, so tools/list and tools/call
      * responses remain live as well. Inference-bearing requests stay queued in
-     * their original relative order until {@link ready} is called.
+     * their original relative order until {@link ready} is called. Like
+     * {@link ready}, once the connection is closed for good it delivers only
+     * its own reports of how it ended.
      */
     readyControlPlane() {
+        if (this.closedForGood) {
+            this.deliverOwnReports();
+            return;
+        }
         this.controlPlaneReady = true;
         const pending = this.bufferedEvents;
-        this.bufferedEvents = [];
-        this.flushDepth++;
-        try {
-            for (const item of pending) {
-                // Re-enter the ADMISSION gate (this.emit), never super.emit: control
-                // events include channels-register/changed, which are grant-gated —
-                // the old direct flush bypassed positive-grant enforcement entirely
-                // (PR #79 review blocker 3). Data-plane items re-buffer in order via
-                // the same call, since dataPlaneReady is still false.
-                this.emit(item.event, ...item.args);
-            }
-        }
-        finally {
-            this.flushDepth--;
-        }
+        this.replaceHeld([]);
+        // Re-enter the ADMISSION gate (this.emit), never super.emit: control
+        // events include channels-register/changed, which are grant-gated —
+        // the old direct flush bypassed positive-grant enforcement entirely
+        // (PR #79 review blocker 3). Data-plane items re-buffer in order via
+        // the same call, since dataPlaneReady is still false.
+        this.flushHeld(pending);
+    }
+    /**
+     * A connection closed for good still says how it ended. Its own buffered
+     * connect-failed and reconnect-failed, such as the permanent failure of a
+     * launch held as unreaped before the first gate released it, are the
+     * framework's records of it: they need no grant, and its listeners act on
+     * them (a trace, and for a permanent failure an alert and its tools leaving
+     * the list). What the server sent stays held.
+     */
+    deliverOwnReports() {
+        const own = (item) => item.event === 'connect-failed' || item.event === 'reconnect-failed';
+        const reports = this.bufferedEvents.filter(own);
+        if (reports.length === 0)
+            return;
+        // The host's own reports have no responder, so the request counts stand.
+        this.bufferedEvents = this.bufferedEvents.filter((item) => !own(item));
+        for (const { event, args } of reports)
+            super.emit(event, ...args);
     }
     /**
      * Close the data plane synchronously while leaving an already-released
-     * control plane live. Used before reconnect adoption and list-change
-     * reconciliation so no new inference event can beat barrier installation.
+     * control plane live. Used before list-change reconciliation so no new
+     * inference event can beat barrier installation. A reconnect closes both
+     * planes instead.
      */
     pauseDataPlane() {
         this.dataPlaneReady = false;
@@ -278,10 +709,7 @@ export class McplServerConnection extends EventEmitter {
      */
     emit(event, ...args) {
         const name = typeof event === 'string' ? event : '';
-        if (McplServerConnection.isLifecycleEvent(name)
-            || (McplServerConnection.isControlPlaneEvent(name)
-                ? this.controlPlaneReady
-                : this.dataPlaneReady)) {
+        if (this.planeReadyFor(name)) {
             // Positive-grant admission (§5.4/§14.1), at the single choke-point
             // every path shares: live routing AND buffer flushes re-enter here, so
             // an event buffered while the connection was staged is authorized
@@ -317,37 +745,104 @@ export class McplServerConnection extends EventEmitter {
                 }
                 return true;
             }
+            // §6.6: a request that will never be answered MUST get an error. A
+            // request whose event nothing on this host listens for would never be.
+            const request = args[1];
+            if (typeof request?.respondError === 'function' && this.listenerCount(event) === 0) {
+                request.respondError(-32601, 'Method not found');
+                console.error(`[mcpl] ${this.id}: answered -32601 to ${logValue(name)}, which nothing on this host handles`);
+                return true;
+            }
+            // mcpl/manifestChanged (§17.3) and tools/list_changed are notifications.
+            // Sent as a request, either is answered with an empty result as it's
+            // admitted, and passed on as the notification is, with no responder:
+            // the host acts on it the same way, so the answer doesn't depend on what
+            // the refresh does, and it's written before any request the refresh
+            // sends. This is where live routing and buffer flushes meet, so a request
+            // held while its plane is closed is answered only when it's let through,
+            // never by a startup that fails first.
+            if ((name === 'manifest-changed' || name === 'tools-list-changed') && typeof request?.respond === 'function') {
+                request.respond({});
+                return super.emit(event, args[0]);
+            }
             return super.emit(event, ...args);
         }
-        // Buffer cap (issue #122): a long data-plane pause (quiesce window) on a
-        // busy server would otherwise grow this array without bound. Only
-        // responder-LESS events are ever dropped — a buffered server→host REQUEST
-        // holds a live responder the server is blocking on, and dropping it would
-        // strand that call forever (the server timing out and reconnecting is the
-        // accepted bound there, and reconnect re-runs the barrier funnel).
-        if (this.flushDepth === 0 && this.bufferedEvents.length >= McplServerConnection.MAX_BUFFERED_EVENTS) {
-            const hasResponder = (item) => {
-                const responder = item.args[1];
-                return typeof responder?.respond === 'function';
-            };
-            if (!hasResponder({ args })) {
-                this.droppedBufferedEvents++;
-                if (this.droppedBufferedEvents % 100 === 1) {
-                    console.error(`[mcpl] ${this.id}: buffered-event cap (${McplServerConnection.MAX_BUFFERED_EVENTS}) — ` +
-                        `dropped ${this.droppedBufferedEvents} responder-less event(s) while the plane is paused`);
-                }
-                const dropIndex = this.bufferedEvents.findIndex((item) => !hasResponder(item));
-                if (dropIndex >= 0) {
-                    this.bufferedEvents.splice(dropIndex, 1); // drop-oldest non-request
-                    this.bufferedEvents.push({ event: name, args });
+        return this.hold(name, args);
+    }
+    /**
+     * Hold an event until its plane opens, `kept` when a transport boundary
+     * keeps it for the next transport's grant (afterBoundary).
+     */
+    hold(name, args, kept) {
+        // Held until the plane opens. A long pause (a quiesce, say) on a busy or a
+        // runaway server would otherwise grow this array without bound, so
+        // requests and notifications each have a bound, counted apart. A request
+        // holds a responder its server waits on, and dropping it would strand that
+        // call, so past MAX_HELD_REQUESTS (#387) it's refused at once with -32000,
+        // the code of the host's other transient refusals, and its server can send
+        // it again. A notification has no one to tell, so past
+        // MAX_HELD_NOTIFICATIONS (issue #122) the oldest held notification is
+        // dropped to make room. A request a closed transport left (`kept`) has
+        // no server waiting on it, so it's counted apart, as keptRequests, and
+        // dropped past its own bound. A flush takes the whole buffer and zeroes
+        // its counts, so what it holds again was admitted within these bounds
+        // and stays within them.
+        const responder = args[1];
+        const isRequest = McplServerConnection.hasResponder({ args });
+        if (isRequest && kept) {
+            // A request a closed transport left (keptRequests): no server waits on
+            // it, so past its own bound it's dropped, with nobody to refuse.
+            if (this.keptRequests >= McplServerConnection.MAX_HELD_REQUESTS) {
+                this.droppedKeptRequests++;
+                if (this.droppedKeptRequests % 100 === 1) {
+                    console.error(`[mcpl] ${this.id}: kept-request bound (${McplServerConnection.MAX_HELD_REQUESTS}) — ` +
+                        `dropped ${this.droppedKeptRequests} request(s) a closed transport left`);
                 }
-                // else: buffer is all held requests — drop the incoming event instead.
                 return true;
             }
+            this.bufferedEvents.push({ event: name, args, kept });
+            this.keptRequests++;
+            return true;
         }
-        this.bufferedEvents.push({ event: name, args });
+        if (isRequest && this.heldRequests >= McplServerConnection.MAX_HELD_REQUESTS) {
+            this.refusedHeldRequests++;
+            if (this.refusedHeldRequests % 100 === 1) {
+                console.error(`[mcpl] ${this.id}: held-request budget (${McplServerConnection.MAX_HELD_REQUESTS}) — ` +
+                    `refused ${this.refusedHeldRequests} request(s) with -32000 while the plane is paused`);
+            }
+            responder?.respondError?.(-32000, `the host is busy: ${McplServerConnection.MAX_HELD_REQUESTS} of this server's requests are already waiting; send this one again later`);
+            return true;
+        }
+        if (!isRequest && this.bufferedEvents.length - this.heldRequests - this.keptRequests >= McplServerConnection.MAX_HELD_NOTIFICATIONS) {
+            this.droppedBufferedEvents++;
+            if (this.droppedBufferedEvents % 100 === 1) {
+                console.error(`[mcpl] ${this.id}: buffered-event cap (${McplServerConnection.MAX_HELD_NOTIFICATIONS}) — ` +
+                    `dropped ${this.droppedBufferedEvents} responder-less event(s) while the plane is paused`);
+            }
+            const oldest = this.bufferedEvents.findIndex((item) => !McplServerConnection.hasResponder(item));
+            if (oldest >= 0)
+                this.bufferedEvents.splice(oldest, 1);
+        }
+        this.bufferedEvents.push(kept ? { event: name, args, kept } : { event: name, args });
+        if (isRequest)
+            this.heldRequests++;
         return true;
     }
+    /** A buffered server→host request: it carries a responder its server waits on. */
+    static hasResponder(item) {
+        const responder = item.args[1];
+        return typeof responder?.respond === 'function';
+    }
+    /** Events routed from a server's transport that report the world, which
+     *  the next process doesn't send again when its bridge records them as
+     *  forwarded first: kept at a transport boundary while held. */
+    static WORLD_EVENTS = new Set(['channels-incoming', 'push-event']);
+    /** Events routed from a server's transport that speak for its process, not
+     *  the world: dropped at a transport boundary while held. */
+    static get PROCESS_EVENTS() {
+        return new Set(Object.values(McplServerConnection.METHOD_TO_EVENT)
+            .filter((event) => !McplServerConnection.WORLD_EVENTS.has(event)));
+    }
     /** Event-name form of METHOD_TO_REQUIRED_CAPABILITY, for admission-time
      *  enforcement in emit(). */
     static EVENT_TO_REQUIRED_CAPABILITY = {
@@ -395,19 +890,46 @@ export class McplServerConnection extends EventEmitter {
      * capability negotiation, and return a ready-to-use connection.
      *
      * Works over stdio (spawned child) or WebSocket, selected by `config` (see
-     * {@link openTransport}). Throws if the transport can't be opened, the server
-     * closes/errors before the handshake, or the handshake times out.
+     * {@link openTransport}). Throws if the configuration can't be used (before
+     * anything is spawned or dialed), the transport can't be opened, the server
+     * closes/errors before the handshake, or the handshake times out. If the
+     * failed launch's cleanup can't confirm its child exited, it throws
+     * {@link McplUnreapedLaunchError}, whose connection owns that launch.
      */
-    static async connect(config, hostCapabilities) {
-        const { transport, capabilities, droppedCapabilities, mcpToolsAdvertised } = await McplServerConnection.handshake(config, hostCapabilities);
+    static async connect(config, hostCapabilities, signal) {
+        McplServerConnection.checkConfig(config);
+        return McplServerConnection.connectChecked(config, hostCapabilities, signal);
+    }
+    /** {@link connect}, for a configuration its caller has already checked
+     *  (and warned about) once. `signal` ends the connect at once, its launch
+     *  reaped as for any failed handshake: its caller's stop() or a
+     *  disconnect of its id. */
+    static async connectChecked(config, hostCapabilities, signal) {
+        let established;
+        try {
+            established = await McplServerConnection.handshake(config, hostCapabilities, signal);
+        }
+        catch (error) {
+            if (!(error instanceof HandshakeCleanupError))
+                throw error;
+            // The launch may still be running. A connection owns it, closed and
+            // halted, so the caller can retry the reap by closing it.
+            const owner = McplServerConnection.createDisconnectedStub(config, hostCapabilities);
+            owner.holdUnreaped(error.transport, error.cleanup);
+            throw new McplUnreapedLaunchError(owner, error.failure, error.cleanup);
+        }
+        const { transport, capabilities, droppedCapabilities, mcpToolsAdvertised, protocolVersion } = established;
         const connection = new McplServerConnection(config.id, capabilities, transport);
         connection.droppedCapabilities = droppedCapabilities;
         connection.mcpToolsAdvertised = mcpToolsAdvertised;
+        connection.protocolVersion = protocolVersion;
         connection.allowHostCommands = config.allowHostCommands === true;
         connection.requestTimeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-        // Store config for reconnection
-        if (config.reconnect) {
-            connection.config = config;
+        // Its configuration, which a reconnect reads and every log line of the
+        // server's text redacts with. Only `true` turns reconnect on, as at
+        // every other reader of it.
+        connection.config = config;
+        if (config.reconnect === true) {
             connection.hostCapabilities = hostCapabilities;
             connection.reconnectEnabled = true;
             connection.reconnectIntervalMs = config.reconnectIntervalMs ?? 5000;
@@ -415,15 +937,45 @@ export class McplServerConnection extends EventEmitter {
         }
         return connection;
     }
+    /**
+     * This engine's configuration check, made before anything is spawned or
+     * dialed: every problem {@link checkServerConfig} finds, the same check the
+     * framework applies, and the modern family, which belongs to
+     * ModernMcpConnection (an http(s) url is never dialed as a WebSocket).
+     * Every configuration that worked before still passes but the one
+     * serverConfigProblems names.
+     */
+    static checkConfig(config) {
+        const { family } = checkServerConfig(config);
+        if (family === 'modern') {
+            throw new Error(`MCP server "${config.id}" is configured for modern MCP (${MODERN_MCP_PROTOCOL_VERSION}); ` +
+                `McplServerConnection speaks the legacy family (${MCP_PROTOCOL_VERSION} + MCPL) only`);
+        }
+    }
     /**
      * Open a fresh transport and run the MCP/MCPL initialize handshake over it,
      * returning the connected transport plus the negotiated capabilities. Shared
      * by {@link connect} and {@link attemptReconnect} so both transports handshake
      * identically. On any failure the transport is closed so a spawned child /
-     * open socket never leaks.
+     * open socket never leaks. If that close can't confirm the child exited,
+     * the failure is a {@link HandshakeCleanupError} carrying the transport, so
+     * the caller keeps owning it. `signal` ends a handshake whose connection is
+     * closed meanwhile: it cuts a WebSocket dial short, is checked once the
+     * transport is open, and races the initialize answer.
      */
-    static async handshake(config, hostCapabilities) {
-        const transport = await openTransport(config);
+    static async handshake(config, hostCapabilities, signal) {
+        const closedWhileConnecting = () => new Error(`MCPL server "${config.id}" was closed while connecting`);
+        if (signal?.aborted)
+            throw closedWhileConnecting();
+        let transport;
+        try {
+            transport = await openTransport(config, signal);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw closedWhileConnecting();
+            throw error;
+        }
         // Once the handshake stops listening for 'error', this logs what the
         // transport reports, until the handshake hands the transport on, or for
         // good if the handshake fails. EventEmitter throws an 'error' that has no
@@ -431,9 +983,11 @@ export class McplServerConnection extends EventEmitter {
         // WebSocket frame that arrives with the initialize response, or while a
         // failed handshake's close() runs, is such an error.
         const logAfterSettled = (err) => {
-            console.error(`[mcpl] ${config.id}: transport error after the handshake settled: ${err.message}`);
+            console.error(`[mcpl] ${config.id}: transport error after the handshake settled: ${redactServerText(err.message, config)}`);
         };
         try {
+            if (signal?.aborted)
+                throw closedWhileConnecting();
             const initId = 0; // use id=0 for the handshake
             const initRequest = {
                 jsonrpc: '2.0',
@@ -445,9 +999,9 @@ export class McplServerConnection extends EventEmitter {
                     clientInfo: { name: 'agent-framework', version: '1.0.0' },
                 },
             };
-            // Await the initialize response, racing an early transport close/error and
-            // a timeout. All three paths clean up their listeners.
-            const { mcpl: rawCapabilities, mcpToolsAdvertised } = await new Promise((resolve, reject) => {
+            // Await the initialize response, racing an early transport close/error,
+            // a timeout and the owner's close. Every path cleans up its listeners.
+            const { mcpl: rawCapabilities, mcpToolsAdvertised, protocolVersion } = await new Promise((resolve, reject) => {
                 // When the transport fails, the end of the server's stderr often says
                 // why, such as a missing token or a crash at startup. It goes on the
                 // error as `stderrTail`, never into the message: an error's message
@@ -461,9 +1015,14 @@ export class McplServerConnection extends EventEmitter {
                     transport.off('line', onLine);
                     transport.off('close', onClose);
                     transport.off('error', onError);
+                    signal?.removeEventListener('abort', onAbort);
                     transport.on('error', logAfterSettled);
                     clearTimeout(timer);
                 };
+                const onAbort = () => {
+                    cleanup();
+                    reject(closedWhileConnecting());
+                };
                 const onLine = (line) => {
                     let msg;
                     try {
@@ -472,14 +1031,46 @@ export class McplServerConnection extends EventEmitter {
                     catch {
                         return; // Ignore non-JSON lines (e.g. logback output from Java servers)
                     }
+                    if (msg === null || typeof msg !== 'object' || Array.isArray(msg))
+                        return;
+                    // A request or a notification from the server is never the
+                    // initialize response, whatever its id: a server's own ids can start
+                    // at 0, this handshake's. MCP lets a server ping before
+                    // initialization completes, and the ping gets its empty result, as
+                    // on a connected transport. Anything else it sends now is ignored.
+                    if ('method' in msg) {
+                        const request = msg;
+                        if (request.method === 'ping' && request.id != null) {
+                            transport.writeLine(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: {} }));
+                        }
+                        return;
+                    }
                     if (msg.id !== initId)
                         return;
                     cleanup();
                     if (msg.error) {
-                        reject(new Error(`MCPL server "${config.id}" initialize error: ${msg.error.message}`));
+                        // describeCause rather than the template's own conversion: the
+                        // server's `message` can be any JSON value, and one that has no
+                        // primitive form, such as {"toString":1}, would throw out of this
+                        // listener after cleanup() has cleared the timeout: an uncaught
+                        // exception, which ends a host that doesn't catch them, and a
+                        // handshake left to wait forever. It's the server's text in an
+                        // error's message, so it's bounded as errors.ts says.
+                        reject(msg.error.code === UNSUPPORTED_PROTOCOL_VERSION_CODE
+                            ? protocolVersionRejection(config.id, msg.error)
+                            : new Error(`MCPL server "${config.id}" initialize error: ${boundedForLog(describeCause(msg.error.message))}`));
                         return;
                     }
                     const result = msg.result;
+                    // The server's answer is the established revision. This engine
+                    // implements exactly one, so any other answer (or none) means the
+                    // two sides never agreed on what they're speaking.
+                    const returned = typeof result?.protocolVersion === 'string' ? result.protocolVersion : null;
+                    if (returned !== MCP_PROTOCOL_VERSION) {
+                        reject(new McplProtocolVersionError(`MCPL server "${config.id}" answered initialize with protocolVersion ` +
+                            `${returned === null ? '(none)' : JSON.stringify(returned)}; this client's legacy engine speaks only ${MCP_PROTOCOL_VERSION}`, 'mismatch', returned, null));
+                        return;
+                    }
                     const caps = result?.capabilities;
                     const experimental = caps?.experimental;
                     // §5.1: `tools` capability is the OUTER standard MCP member — the
@@ -488,11 +1079,19 @@ export class McplServerConnection extends EventEmitter {
                     resolve({
                         mcpl: experimental?.mcpl ?? null,
                         mcpToolsAdvertised: caps?.tools !== undefined,
+                        protocolVersion: returned,
                     });
                 };
                 const onClose = (info) => {
                     cleanup();
-                    reject(failed(`MCPL server "${config.id}" transport closed before handshake completed (${info.reason ?? 'unknown'})`));
+                    const code = transport.kind === 'websocket' && typeof info.code === 'number' ? `, code ${info.code}` : '';
+                    const failure = `MCPL server "${config.id}" transport closed before handshake completed (${closeReasonText(info)}${code})`;
+                    // The close comes at a stdio child's exit, which Node can emit before
+                    // it has read the last of the child's stderr, or when the host closes
+                    // the transport, which then ends the child. The tail is taken once
+                    // stderr has ended, waiting at most STDERR_END_WAIT_MS. A WebSocket
+                    // transport has no stderr to wait for.
+                    void transport.stderrEnded(STDERR_END_WAIT_MS).then(() => reject(failed(failure)));
                 };
                 const onError = (err) => {
                     cleanup();
@@ -502,6 +1101,7 @@ export class McplServerConnection extends EventEmitter {
                     cleanup();
                     reject(failed(`MCPL server "${config.id}" initialize handshake timed out`));
                 }, INITIALIZE_TIMEOUT_MS);
+                signal?.addEventListener('abort', onAbort, { once: true });
                 transport.on('line', onLine);
                 transport.on('close', onClose);
                 transport.on('error', onError);
@@ -525,11 +1125,18 @@ export class McplServerConnection extends EventEmitter {
             // listener of its own, in the continuation of this return, before any
             // I/O callback can emit.
             transport.off('error', logAfterSettled);
-            return { transport, capabilities: scoped, droppedCapabilities: new Set(dropped), mcpToolsAdvertised };
+            return { transport, capabilities: scoped, droppedCapabilities: new Set(dropped), mcpToolsAdvertised, protocolVersion };
         }
         catch (err) {
-            // Never leak the child / socket if the handshake fails.
-            await transport.close().catch(() => { });
+            // Never leak the child / socket if the handshake fails. A cleanup that
+            // can't confirm the child exited is part of the failure, never
+            // swallowed: the launch may still be running, so the caller keeps it.
+            try {
+                await transport.close();
+            }
+            catch (cleanup) {
+                throw new HandshakeCleanupError(errorOf(err), errorOf(cleanup), transport);
+            }
             throw err;
         }
     }
@@ -537,30 +1144,43 @@ export class McplServerConnection extends EventEmitter {
      * Connect with reconnect support.
      * When `config.reconnect` is true and the initial connection fails,
      * resolves immediately with null capabilities and retries in the background.
+     * A configuration this engine can't use, or a protocol-version verdict,
+     * still throws: retrying can't change either. So does a failed launch that
+     * can't be reaped, as in {@link connect}: no retry starts beside a child
+     * that may still be running, and the {@link McplUnreapedLaunchError}
+     * carries the connection that owns it, whose close() retries the reap.
      * Adapted from Anarchid/agent-framework@mcpl-module-proto.
      */
-    static async connectWithReconnect(config, hostCapabilities) {
+    static async connectWithReconnect(config, hostCapabilities, signal) {
+        // Outside the retry path below: a configuration error is never retried.
+        McplServerConnection.checkConfig(config);
         try {
-            return await McplServerConnection.connect(config, hostCapabilities);
+            return await McplServerConnection.connectChecked(config, hostCapabilities, signal);
         }
         catch (error) {
-            if (!config.reconnect) {
+            // No common protocol revision is a configuration fact, not an outage:
+            // a retry stub would restart the server forever for nothing. A connect
+            // its caller ended (stop(), or a disconnect of its id) isn't retried
+            // either, nor is a launch that couldn't be reaped.
+            if (config.reconnect !== true || error instanceof McplProtocolVersionError || error instanceof McplUnreapedLaunchError || signal?.aborted) {
                 throw error;
             }
-            // Non-blocking start: create a disconnected stub that will reconnect in background
-            console.error(`MCPL server "${config.id}" initial connect failed, will retry: ${error.message}${withStderr(error)}`);
-            const stub = McplServerConnection.createDisconnectedStub(config, hostCapabilities);
             // Surface the initial failure. The event is buffered by the emit()
             // override until the host wires listeners and calls ready(), so it is
             // not lost in the window before wireMcplEvents runs.
+            // Non-blocking start: create a disconnected stub that will reconnect in background
+            console.error(`MCPL server "${config.id}" initial connect failed, will retry: ${redactServerText(error.message, config)}${withStderr(error, (text) => redactServerText(text, config))}`);
+            const stub = McplServerConnection.createDisconnectedStub(config, hostCapabilities);
             const stderrTail = stderrTailOf(error);
             stub.emit('connect-failed', { error: error.message, ...(stderrTail ? { stderrTail } : {}), attempt: 0 });
+            stub.scheduleReconnect();
             return stub;
         }
     }
     /**
-     * Create a disconnected stub connection that will reconnect in the background.
-     * Used when initial connect fails and reconnect is enabled.
+     * Create a disconnected stub connection, for a failed initial connect: one
+     * that will reconnect in the background (its caller schedules that), or one
+     * that owns a launch that couldn't be reaped.
      * @internal
      */
     static createDisconnectedStub(config, hostCapabilities) {
@@ -570,14 +1190,31 @@ export class McplServerConnection extends EventEmitter {
         stub.requestTimeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
         stub.config = config;
         stub.hostCapabilities = hostCapabilities;
-        stub.reconnectEnabled = true;
+        stub.reconnectEnabled = config.reconnect === true;
         stub.reconnectIntervalMs = config.reconnectIntervalMs ?? 5000;
         stub.reconnectMaxIntervalMs = config.reconnectMaxIntervalMs ?? 300_000;
         stub.reconnectAttempts = 1; // the initial connect already failed
-        // Schedule background reconnect
-        stub.scheduleReconnect();
         return stub;
     }
+    /**
+     * Keep a launch whose cleanup couldn't confirm its child exited, and halt
+     * reconnecting: another launch could run beside one that's still alive.
+     * close() retries the reap.
+     */
+    holdUnreaped(transport, failure) {
+        this.reconnectEnabled = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (!this.unreaped.some((held) => held.transport === transport))
+            this.unreaped.push({ transport, failure });
+    }
+    /** The halt, as a reconnect event's failure text. */
+    unreapedFailure() {
+        const held = this.unreaped[0];
+        return `the previous launch could not be reaped (${held?.failure.message ?? 'unknown'}); reconnecting is halted`;
+    }
     // ==========================================================================
     // Outbound requests (return Promises)
     // ==========================================================================
@@ -606,8 +1243,12 @@ export class McplServerConnection extends EventEmitter {
     sendFeatureSetsUpdateRequest(params, timeoutMs = 15_000) {
         return this.sendRequest(McplMethod.FeatureSetsUpdate, params, { timeoutMs });
     }
-    /** Send `inference/chunk` notification. */
-    sendInferenceChunk(params) {
+    /** Send `inference/chunk` notification, on the transport `epoch` names: a
+     *  chunk of a request from a transport that has closed goes nowhere, as
+     *  that request's answer does. */
+    sendInferenceChunk(params, epoch = this.transportEpoch) {
+        if (epoch !== this.transportEpoch)
+            return;
         this.sendNotification(McplMethod.InferenceChunk, params);
     }
     /** Send `inference/lifecycle` notification (§10.5). Best-effort. */
@@ -633,9 +1274,13 @@ export class McplServerConnection extends EventEmitter {
     sendStateRollback(params) {
         return this.sendRequest(McplMethod.StateRollback, params);
     }
-    /** Send `channels/open` request and await result. */
+    /** Send `channels/open` request and await result. It keeps a deadline as
+     *  channels/publish does: a delivery opens a closed channel before it
+     *  publishes, so an open that is never answered would hold the delivery,
+     *  and the turn that waits for it, for good. */
     sendChannelsOpen(params) {
-        return this.sendRequest(McplMethod.ChannelsOpen, params);
+        const timeoutMs = this.requestTimeoutMs > 0 ? this.requestTimeoutMs : this.publishDeadlineMs;
+        return this.sendRequest(McplMethod.ChannelsOpen, params, { timeoutMs });
     }
     /** Send `channels/close` request and await result. */
     sendChannelsClose(params) {
@@ -653,13 +1298,20 @@ export class McplServerConnection extends EventEmitter {
      * Send `channels/publish`.
      * May be sent as a request (if an ACK is desired) or notification.
      * When `params.stream` is true, sends as a notification (no ACK).
+     *
+     * A request always has a deadline: the server's requestTimeoutMs, or
+     * publishDeadlineMs when that is 0 (disabled). A publish is a side effect
+     * whose outcome the resident is told and a held draft's attempt records,
+     * so one that is never answered would hold both open for good. Its expiry
+     * is a no-response, which the caller reads as unknown.
      */
     sendChannelsPublish(params) {
         if (params.stream) {
             this.sendNotification(McplMethod.ChannelsPublish, params);
             return Promise.resolve();
         }
-        return this.sendRequest(McplMethod.ChannelsPublish, params);
+        const timeoutMs = this.requestTimeoutMs > 0 ? this.requestTimeoutMs : this.publishDeadlineMs;
+        return this.sendRequest(McplMethod.ChannelsPublish, params, { timeoutMs });
     }
     /** Send `channels/outgoing/chunk` notification. */
     sendChannelsOutgoingChunk(params) {
@@ -685,9 +1337,45 @@ export class McplServerConnection extends EventEmitter {
     // ==========================================================================
     // Standard MCP methods
     // ==========================================================================
-    /** Send `tools/list` and return the server's tool definitions. */
-    sendToolsList() {
-        return this.sendRequest('tools/list', {});
+    /**
+     * Send `tools/list` and return the server's complete tool inventory,
+     * following `nextCursor` across pages (2024-11-05 pagination). Cursors are
+     * opaque strings, `''` included: only an absent or null `nextCursor` ends
+     * the inventory (a null one is how some servers say "no more", and main
+     * read it as a complete page). A page that isn't well formed (no `tools` array, a cursor
+     * that isn't a string), or cursors that don't terminate (a repeat, or more
+     * than {@link MAX_TOOL_LIST_PAGES} pages), are errors, never a partial or
+     * empty inventory published as complete.
+     */
+    async sendToolsList() {
+        const tools = [];
+        const seen = new Set();
+        let cursor;
+        let first;
+        for (let page = 0; page < MAX_TOOL_LIST_PAGES; page++) {
+            const result = await this.sendRequest('tools/list', cursor === undefined ? {} : { cursor });
+            const malformed = (why) => new Error(`MCPL server "${this.id}" sent a malformed tools/list page ${page + 1}: ${why}`);
+            if (!result || typeof result !== 'object' || !Array.isArray(result.tools)) {
+                throw malformed('no tools array');
+            }
+            first ??= result;
+            tools.push(...result.tools);
+            if (result.nextCursor === undefined || result.nextCursor === null) {
+                // The first page's other fields are kept as they came, so a
+                // single-page answer is returned exactly as before.
+                const { nextCursor: _done, ...rest } = first;
+                return { ...rest, tools };
+            }
+            if (typeof result.nextCursor !== 'string') {
+                throw malformed(`nextCursor must be a string, got ${JSON.stringify(result.nextCursor)}`);
+            }
+            if (seen.has(result.nextCursor)) {
+                throw new Error(`MCPL server "${this.id}" repeated tools/list cursor ${JSON.stringify(result.nextCursor)}`);
+            }
+            seen.add(result.nextCursor);
+            cursor = result.nextCursor;
+        }
+        throw new Error(`MCPL server "${this.id}" tools/list did not finish within ${MAX_TOOL_LIST_PAGES} pages`);
     }
     /** Send `tools/call` and return the result. Optionally includes state/checkpoint for stateful tools. */
     sendToolsCall(name, args, stateParams) {
@@ -716,43 +1404,61 @@ export class McplServerConnection extends EventEmitter {
     // ==========================================================================
     // Lifecycle
     // ==========================================================================
-    /** Close the connection: disable reconnect, kill the child process, and clean up resources. */
-    async close() {
+    /** The requests still waiting for an answer, for the operator's log line
+     *  when the connection goes: their methods and ids. */
+    unansweredRequests() {
+        const list = [...this.pendingRequests].map(([id, pending]) => `${pending.method} (id=${id})`).join(', ');
+        return `${this.pendingRequests.size} request(s) unanswered: ${list}`;
+    }
+    /**
+     * Close the connection for good: disable reconnect, kill the child
+     * process, and clean up resources. At once, as before, reconnecting stops
+     * and pending requests fail; a reconnect handshake in flight is aborted.
+     *
+     * Calls share one attempt: while it is pending, and once it has
+     * succeeded, close() returns it. The attempt waits for the aborted
+     * reconnect's own cleanup, closes the transport (its close is the reaping
+     * verdict) and retries each launch an earlier cleanup couldn't reap. It
+     * rejects while any child can't be confirmed exited, with that failure
+     * itself, or an AggregateError when there are several. A failed attempt is
+     * cleared, so the next close() retries what it couldn't reap. 'close' is
+     * emitted once, when the teardown of a connection the host closed while
+     * live completes.
+     */
+    close() {
         // Disable reconnect before closing — explicit close means stop retrying
         this.reconnectEnabled = false;
+        this.closedByThisHost = true;
         if (this.reconnectTimer) {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = null;
         }
+        this.reconnecting?.abort.abort();
         if (this.closePromise)
             return this.closePromise;
-        if (this.closed && !this.closeIncomplete && !this.reconnectPromise)
-            return;
-        this.closed = true;
-        this.closeIncomplete = true;
-        this.resetPolicyForTransportBoundary();
-        // Reject all pending requests
-        for (const [id, pending] of this.pendingRequests) {
-            if (pending.timer)
-                clearTimeout(pending.timer);
-            pending.reject(new Error(`Connection to MCPL server "${this.id}" closed while awaiting response for ${pending.method} (id=${id})`));
+        if (!this.closed) {
+            this.closed = true;
+            this.closeIncomplete = true;
+            this.resetPolicyForTransportBoundary();
+            // Reject all pending requests. Each message is the whole of what an
+            // agent reads for a tools/call, and what follows a channel tool's own
+            // words ("Failed to publish to channel: …") for the requests a channel
+            // tool makes, so it names no method; the log line does. It doesn't say
+            // whether this host reconnects: a restart closes the connection and then
+            // connects again.
+            if (this.pendingRequests.size > 0) {
+                console.error(`MCPL server "${this.id}": this host closed its connection with ${this.unansweredRequests()}`);
+            }
+            for (const pending of this.pendingRequests.values()) {
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                pending.reject(new McplRequestError(`The "${this.id}" server didn't answer before this host closed its connection, so whether the request took effect is unknown. ` +
+                    'Check its effect before trying again.', 'no-response'));
+            }
+            this.pendingRequests.clear();
+            this.orphanedRequests.clear();
         }
-        this.pendingRequests.clear();
-        this.orphanedRequests.clear();
-        // Tear down the transport (kills the child / closes the socket). The
-        // transport's own 'close' event is short-circuited by `this.closed` in
-        // setupLifecycle, so this is the single source of the connection 'close'.
-        const attempt = Promise.resolve().then(async () => {
-            // An already opened handshake owns a transport too. It hands that
-            // transport back without admission once reconnect has been disabled.
-            // The registry bounds this wait; retry reuses this real close attempt.
-            if (this.reconnectPromise)
-                await this.reconnectPromise;
-            if (this.transport)
-                await this.transport.close();
-            this.closeIncomplete = false;
-            this.emit('close', null, null, this.closeInfoByHost());
-        });
+        const attempt = this.closeStep(this.transport, this.unreaped.map((held) => held.transport));
         this.closePromise = attempt;
         void attempt.catch(() => {
             if (this.closePromise === attempt)
@@ -760,14 +1466,60 @@ export class McplServerConnection extends EventEmitter {
         });
         return attempt;
     }
+    /** One close attempt. `heldBefore` are the launches earlier cleanups
+     *  couldn't reap, which it retries. */
+    async closeStep(transport, heldBefore) {
+        // An aborted reconnect cleans up its own launch, holding it if it can't.
+        // That cleanup was this attempt's try at it, so its failure is this
+        // attempt's, not retried here.
+        await this.reconnecting?.done;
+        const heldMeanwhile = this.unreaped.filter((held) => !heldBefore.includes(held.transport));
+        const failures = heldMeanwhile.map((held) => held.failure);
+        const targets = [];
+        for (const target of [transport, ...heldBefore]) {
+            if (target && !targets.includes(target) && !heldMeanwhile.some((held) => held.transport === target))
+                targets.push(target);
+        }
+        for (const target of targets) {
+            try {
+                // Kills the child / closes the socket.
+                await target.close();
+                this.unreaped = this.unreaped.filter((held) => held.transport !== target);
+            }
+            catch (error) {
+                const failure = errorOf(error);
+                failures.push(failure);
+                if (!this.unreaped.some((held) => held.transport === target))
+                    this.unreaped.push({ transport: target, failure });
+            }
+        }
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1) {
+            throw new AggregateError(failures, `MCPL server "${this.id}" did not close cleanly: ${failures.map((f) => f.message).join('; ')}`);
+        }
+        // The transport's own 'close' event is short-circuited by `this.closed`
+        // in setupLifecycle, so this is the single source of the connection
+        // 'close' when the host tears down a live transport.
+        if (this.closeIncomplete) {
+            this.closeIncomplete = false;
+            this.emit('close', null, null, this.closeInfoByHost());
+        }
+    }
     /**
      * Tear down a live transport after an awareness-accounting failure without
      * disabling configured auto-reconnect. The normal transport close handler
      * rejects requests, emits lifecycle state, and schedules the next bounded
-     * reconnect attempt. With reconnect disabled this leaves the server closed.
+     * reconnect attempt. With reconnect disabled the recycle ends the
+     * connection for good, as close() does: 'close' comes once the child's
+     * exit is confirmed, and a child it can't reap stays owned, holding the id.
      */
     async reconnectAfterFailure() {
         this.pauseDataPlane();
+        if (!this.reconnectEnabled) {
+            await this.close();
+            return;
+        }
         if (this.closed) {
             this.scheduleReconnect();
             return;
@@ -817,68 +1569,118 @@ export class McplServerConnection extends EventEmitter {
      * Attempt to reconnect by opening a fresh transport and performing the
      * handshake, then adopting that transport in place. Unlike the previous
      * approach this builds no throwaway connection instance, so there are no
-     * leaked listeners on a dead object.
+     * leaked listeners on a dead object. The attempt is close()'s to abort,
+     * and it settles only once its own launch is adopted, failed or cleaned up.
+     * One attempt at a time: a request that arrives while one is in flight (a
+     * recycle, say) starts nothing, since that attempt either adopts its
+     * launch or schedules the next retry itself. A second attempt would take
+     * close()'s ownership of the first (Iris-1827, room-293 #55410).
      */
-    attemptReconnect() {
-        if (this.reconnectPromise)
-            return this.reconnectPromise;
-        const attempt = this.reconnectOnce();
-        this.reconnectPromise = attempt;
-        const clear = () => { if (this.reconnectPromise === attempt)
-            this.reconnectPromise = null; };
-        void attempt.then(clear, clear);
-        return attempt;
-    }
-    async reconnectOnce() {
-        // A queued recovery timer may outlive an earlier successful handshake.
-        // Recheck disconnection before opening or replacing any owned transport.
-        if (!this.closed || !this.reconnectEnabled || !this.config || !this.hostCapabilities)
+    async attemptReconnect() {
+        // A queued recovery timer may outlive an earlier successful handshake:
+        // only a connection that is down reconnects, so it never replaces a live
+        // transport.
+        if (this.reconnecting || !this.closed || !this.reconnectEnabled || !this.config || !this.hostCapabilities)
             return;
+        const abort = new AbortController();
+        const done = this.reconnectOnce(this.config, this.hostCapabilities, abort.signal);
+        this.reconnecting = { abort, done };
+        await done;
+        if (this.reconnecting?.done === done)
+            this.reconnecting = null;
+    }
+    /** One reconnect attempt. It never rejects: each outcome is an event, a
+     *  scheduled retry, or a launch held as unreaped. */
+    async reconnectOnce(config, hostCapabilities, signal) {
         // Ordinal of this attempt: 0 was the initial connect, so the Nth retry
         // reports attempt N (reconnectAttempts counts failures so far).
         const attempt = Math.max(1, this.reconnectAttempts);
-        try {
-            const { transport, capabilities, droppedCapabilities, mcpToolsAdvertised } = await McplServerConnection.handshake(this.config, this.hostCapabilities);
-            if (!this.reconnectEnabled) {
-                // The prior transport was disconnected before this retry began. Keep
-                // the fresh, unadmitted transport owned by close(), including on a
-                // failed transport cleanup, instead of reviving a stopped connection.
-                // It isn't wired, and the handshake has removed its own listeners, so
-                // an error it reports from here on, such as a malformed frame from a
-                // WebSocket server while close() closes it, is logged here rather than
-                // thrown where nothing catches it.
-                transport.on('error', (err) => {
-                    console.error(`[mcpl] ${this.id}: a transport kept for close() reported an error: ${err.message}`);
-                });
-                this.transport = transport;
+        // The previous launch must be gone before another starts. A transport
+        // the host closed itself (reconnectAfterFailure) may still be reaping its
+        // child; one whose child already exited resolves at once.
+        const previous = this.transport;
+        if (previous) {
+            try {
+                await previous.close();
+            }
+            catch (error) {
+                this.holdUnreaped(previous, errorOf(error));
+                if (!signal.aborted)
+                    this.emit('reconnect-failed', { error: this.unreapedFailure(), attempt, permanent: true });
                 return;
             }
-            // Close the data plane before the new transport can emit. The reconnect
-            // lifecycle event bypasses buffering; its framework listener installs the
-            // awareness barrier synchronously, then releases control traffic needed
-            // to establish the server while data remains held.
-            this.pauseDataPlane();
-            this.resetPolicyForTransportBoundary();
-            this.transport = transport;
-            this.capabilities = capabilities;
-            this.droppedCapabilities = droppedCapabilities;
-            this.mcpToolsAdvertised = mcpToolsAdvertised;
-            this.allowHostCommands = this.config?.allowHostCommands === true;
-            this.closed = false;
-            this.nextRequestId = 1;
-            this.pendingRequests.clear();
-            this.wireTransport(transport);
-            console.error(`MCPL server "${this.id}" reconnected successfully`);
-            this.reconnectAttempts = 0;
-            this.emit('reconnect', { attempts: attempt });
+        }
+        if (signal.aborted)
+            return;
+        let established;
+        try {
+            established = await McplServerConnection.handshake(config, hostCapabilities, signal);
         }
         catch (error) {
-            console.error(`MCPL server "${this.id}" reconnect failed: ${error.message}${withStderr(error)}`);
+            const unreaped = error instanceof HandshakeCleanupError;
+            if (unreaped)
+                this.holdUnreaped(error.transport, error.cleanup);
+            // Closed by the host meanwhile: not a failed attempt.
+            if (signal.aborted)
+                return;
+            const failure = unreaped ? error.failure : errorOf(error);
+            const redact = (text) => redactServerText(text, this.config ?? {});
+            console.error(`MCPL server "${this.id}" reconnect failed: ${redact(failure.message)}${withStderr(failure, redact)}`);
             this.reconnectAttempts = attempt + 1;
-            const stderrTail = stderrTailOf(error);
-            this.emit('reconnect-failed', { error: error.message, ...(stderrTail ? { stderrTail } : {}), attempt });
-            this.scheduleReconnect();
+            // No common protocol revision: every further attempt would restart the
+            // server to hear the same answer. Stop retrying; the configuration is
+            // what has to change. A launch that couldn't be reaped halts retrying
+            // for good: close() can confirm its exit, but close() is terminal, so
+            // nothing resumes this connection. Every other failure keeps the
+            // backoff loop.
+            if (error instanceof McplProtocolVersionError)
+                this.reconnectEnabled = false;
+            const permanent = unreaped || error instanceof McplProtocolVersionError;
+            const message = unreaped ? `${failure.message}; ${this.unreapedFailure()}` : failure.message;
+            const stderrTail = stderrTailOf(failure);
+            this.emit('reconnect-failed', { error: message, ...(stderrTail ? { stderrTail } : {}), attempt, ...(permanent ? { permanent: true } : {}) });
+            if (!permanent)
+                this.scheduleReconnect();
+            return;
+        }
+        const { transport, capabilities, droppedCapabilities, mcpToolsAdvertised, protocolVersion } = established;
+        if (signal.aborted) {
+            // Closed by the host while the handshake finished: this launch never
+            // serves. close() is waiting on this attempt, so it hears the verdict.
+            // The transport isn't wired, and the handshake has taken its own
+            // listeners off, so an error it reports while it closes, such as a
+            // malformed frame from a WebSocket server, is logged here rather than
+            // thrown where nothing catches it.
+            transport.on('error', (err) => {
+                console.error(`[mcpl] ${this.id}: a transport closed before it served reported an error: ${redactServerText(err.message, config)}`);
+            });
+            await transport.close().catch((error) => this.holdUnreaped(transport, errorOf(error)));
+            return;
         }
+        // Close both planes before the new transport can emit, as at initial
+        // connect: its traffic is admitted against the grant, which this
+        // boundary resets, so control traffic too (a server's channels/register
+        // right after initialize) must wait for the new grant rather than be
+        // refused against the empty one. The reconnect lifecycle event bypasses
+        // buffering; its framework listener installs the awareness barrier,
+        // re-establishes the grant (§5.3 policy responses are never buffered),
+        // and then opens the planes.
+        this.controlPlaneReady = false;
+        this.dataPlaneReady = false;
+        this.resetPolicyForTransportBoundary();
+        this.transport = transport;
+        this.capabilities = capabilities;
+        this.droppedCapabilities = droppedCapabilities;
+        this.mcpToolsAdvertised = mcpToolsAdvertised;
+        this.protocolVersion = protocolVersion;
+        this.allowHostCommands = this.config?.allowHostCommands === true;
+        this.closed = false;
+        this.nextRequestId = 1;
+        this.pendingRequests.clear();
+        this.wireTransport(transport);
+        console.error(`MCPL server "${this.id}" reconnected successfully`);
+        this.reconnectAttempts = 0;
+        this.emit('reconnect', { attempts: attempt });
     }
     // ==========================================================================
     // Private: message sending
@@ -896,7 +1698,29 @@ export class McplServerConnection extends EventEmitter {
      */
     sendRequest(method, params, options = {}) {
         if (this.closed) {
-            return Promise.reject(new Error(`Cannot send request: connection to "${this.id}" is closed`));
+            // After this host's own close, which a restart makes before connecting
+            // again and a removal makes for good, only that this host closed it
+            // holds, and one next step holds for both: calling again reaches the
+            // restarted server, or fails where it's gone.
+            return Promise.reject(new McplRequestError(this.closedByThisHost
+                ? `The request wasn't sent: this host closed its connection to the "${this.id}" server, so nothing ran. ` +
+                    'If calling it again fails, ask whoever runs this host.'
+                : `The request wasn't sent: the connection to the "${this.id}" server is closed, so nothing ran. ` +
+                    (this.willReconnect
+                        ? 'This host is reconnecting to it; try again later.'
+                        : "This host won't reconnect to it on its own. If you need it, ask whoever runs this host."), 'not-sent'));
+        }
+        // Once the child's stdin or stdout has failed, the transport is ending
+        // it and writes nothing more to it, so a request is refused here as not
+        // sent rather than left to wait out its timeout. The method and the
+        // pipe's error are the operator's, so they go to the log.
+        const pipeFailure = this.transport?.pipeFailure;
+        if (pipeFailure) {
+            console.error(`MCPL server "${this.id}": ${method} not sent, since its stdio pipe failed: ${logDetail(pipeFailure.message)}`);
+            return Promise.reject(new McplRequestError(`The request wasn't sent: this host can no longer write to the "${this.id}" server, so nothing ran. ` +
+                (this.willReconnect
+                    ? 'This host is reconnecting to it; try again later.'
+                    : "This host won't reconnect to it on its own. If you need it, ask whoever runs this host."), 'not-sent'));
         }
         const id = this.nextRequestId++;
         const request = {
@@ -912,22 +1736,48 @@ export class McplServerConnection extends EventEmitter {
                 pending.timer = setTimeout(() => {
                     this.pendingRequests.delete(id);
                     if (options.surfaceOrphanedResponse) {
-                        this.orphanedRequests.set(id, { method, ...(method === 'push/render' ? { renderParams: { featureSet: params.featureSet, key: params.key, eventId: params.eventId } } : {}) });
+                        this.orphanedRequests.set(id, {
+                            method,
+                            ...(method === 'push/render'
+                                ? {
+                                    renderParams: {
+                                        featureSet: params.featureSet,
+                                        key: params.key,
+                                        eventId: params.eventId,
+                                        ...(typeof params.channelId === 'string' ? { channelId: params.channelId } : {}),
+                                    },
+                                }
+                                : {}),
+                        });
                         if (this.orphanedRequests.size > 4096)
                             this.orphanedRequests.delete(this.orphanedRequests.keys().next().value);
                     }
-                    reject(new Error(`MCPL server "${this.id}" did not respond to ${method} (id=${id}) ` +
-                        `within ${timeoutMs}ms — the server may be hung. The response ` +
-                        `outcome is unknown: the request was abandoned locally but was not ` +
-                        `cancelled, so the tool may still have completed server-side; verify ` +
-                        `state before retrying; a blind retry of a stateful/side-effecting ` +
-                        `tool may duplicate it.`));
+                    // The method and id are the operator's, so they go to the log.
+                    console.error(`MCPL server "${this.id}" did not respond to ${method} (id=${id}) within ${timeoutMs}ms; ` +
+                        'the request was abandoned here, not cancelled');
+                    const seconds = timeoutMs / 1000;
+                    reject(new McplRequestError(`The "${this.id}" server didn't answer within ${seconds} second${seconds === 1 ? '' : 's'}, ` +
+                        'so whether the request took effect is unknown: ' +
+                        'it was abandoned here, not cancelled, and may still complete on the server. ' +
+                        'Check its effect before trying again, since repeating something that changes state may do it twice.', 'no-response'));
                 }, timeoutMs);
                 // Don't hold the event loop open for the watchdog alone.
                 pending.timer.unref?.();
             }
             this.pendingRequests.set(id, pending);
-            this.transport.writeLine(JSON.stringify(request));
+            try {
+                this.transport.writeLine(JSON.stringify(request));
+            }
+            catch (err) {
+                // A synchronous write rejection sent no request. Remove its pending
+                // state and watchdog before reporting that it is safe to retry. The
+                // method, id and the transport's words are the operator's.
+                this.pendingRequests.delete(id);
+                if (pending.timer)
+                    clearTimeout(pending.timer);
+                console.error(`MCPL server "${this.id}": writing ${method} (id=${id}) failed: ${logDetail(err instanceof Error ? err.message : err)}`);
+                reject(new McplRequestError(`The request wasn't sent: this host couldn't write it to the "${this.id}" server, so nothing ran. Try again later.`, 'not-sent'));
+            }
         });
     }
     /**
@@ -1011,12 +1861,17 @@ export class McplServerConnection extends EventEmitter {
         this.setupLifecycle(transport);
         // Surface transport diagnostics (stdio child stderr) as 'stderr' events,
         // preserving the `{ line }` payload existing consumers expect.
-        transport.on('stderr', (line) => this.emit('stderr', { line }));
+        // Through the same containment boundary as every inbound event, so a
+        // stderr listener that throws is reported, not thrown into the transport.
+        transport.on('stderr', (line) => this.dispatchInboundEvent('stderr', { line }));
     }
     /**
      * Wire up the transport's line stream to route incoming JSON-RPC messages.
      */
     setupMessageRouting(transport) {
+        // The boundary this transport serves within: a line read once it has
+        // passed is the dead process's (afterBoundary).
+        const epoch = this.transportEpoch;
         transport.on('line', (line) => {
             let msg;
             try {
@@ -1026,63 +1881,191 @@ export class McplServerConnection extends EventEmitter {
                 // Ignore non-JSON lines
                 return;
             }
-            // Is this a response to one of our outbound requests?
-            if ('id' in msg && msg.id != null && !('method' in msg)) {
-                this.handleResponse(msg);
+            // JSON-RPC messages must be objects. Ignore unrelated stdout/log values
+            // before property access, just as malformed JSON lines are ignored.
+            if (msg === null || typeof msg !== 'object' || Array.isArray(msg))
                 return;
+            try {
+                this.dispatchMessage(msg, epoch);
             }
-            // It is an inbound request or notification from the server
-            const request = msg;
-            const eventName = McplServerConnection.METHOD_TO_EVENT[request.method];
-            // §7 is removed in 0.5.0: scope/elevate is no longer a method. Answer
-            // rather than hang (§6.6 — a method that will never be answered MUST
-            // return an error).
-            // featureSets/changed is REMOVED in 0.5.0 (§6.7 — it carried a
-            // server-authored change payload, the self-attestation defect; the
-            // need is met by §17's host-diffed manifest fetch). It was still
-            // routed, control-plane classified, and mutating declarations — a
-            // live ungated self-attestation path (PR #79 review blocker 4).
-            if (request.method === McplMethod.FeatureSetsChanged) {
-                if (request.id != null) {
-                    this.sendErrorResponse(request.id, -32601, 'featureSets/changed removed in MCPL 0.5.0 (superseded by mcpl/manifestChanged, SPEC §17)');
-                }
-                else {
-                    console.error(`[mcpl] ${this.id}: discarded featureSets/changed — removed in 0.5.0 (§6.7/§17)`);
-                }
-                return;
+            catch (error) {
+                const request = msg;
+                this.reportInboundFailure(error, {
+                    ...(typeof request.method === 'string' ? { event: request.method } : {}),
+                    ...(typeof request.id === 'string' || typeof request.id === 'number' ? { requestId: request.id } : {}),
+                });
             }
-            if (request.method === McplMethod.ScopeElevate) {
-                if (request.id != null) {
-                    this.sendErrorResponse(request.id, -32601, 'scope/elevate removed in MCPL 0.5.0 (SPEC §7)');
-                }
-                return;
+        });
+    }
+    /** Contain synchronous dispatch failures; async RPC handlers own their promises. */
+    dispatchMessage(msg, epoch) {
+        // Is this a response to one of our outbound requests?
+        if ('id' in msg && msg.id != null && !('method' in msg)) {
+            this.handleResponse(msg, epoch !== this.transportEpoch);
+            return;
+        }
+        // It is an inbound request or notification from the server
+        const request = msg;
+        // Read after its transport's boundary, it is the dead process's: the
+        // boundary's rule applies (afterBoundary).
+        if (epoch !== this.transportEpoch) {
+            this.afterBoundary(request, epoch);
+            return;
+        }
+        // MCP's ping, which either side may send: its receiver answers promptly
+        // with an empty result. It's answered as it arrives, before admission and
+        // buffering, since it asks only whether the connection is alive, and a
+        // paused plane mustn't hold that answer. A ping sent as a notification
+        // has nothing to answer. The handshake answers one too.
+        if (request.method === 'ping') {
+            if (request.id != null)
+                this.sendResponse(request.id, {});
+            return;
+        }
+        const eventName = typeof request.method === 'string' && Object.hasOwn(McplServerConnection.METHOD_TO_EVENT, request.method)
+            ? McplServerConnection.METHOD_TO_EVENT[request.method] : undefined;
+        // §7 is removed in 0.5.0: scope/elevate is no longer a method. Answer
+        // rather than hang (§6.6 — a method that will never be answered MUST
+        // return an error).
+        // featureSets/changed is REMOVED in 0.5.0 (§6.7 — it carried a
+        // server-authored change payload, the self-attestation defect; the
+        // need is met by §17's host-diffed manifest fetch). It was still
+        // routed, control-plane classified, and mutating declarations — a
+        // live ungated self-attestation path (PR #79 review blocker 4).
+        if (request.method === McplMethod.FeatureSetsChanged) {
+            if (request.id != null) {
+                this.sendErrorResponse(request.id, -32601, 'featureSets/changed removed in MCPL 0.5.0 (superseded by mcpl/manifestChanged, SPEC §17)');
             }
-            // Positive-grant enforcement (§5.4, §14.1) happens at ADMISSION, in
-            // the emit() override below — the one choke-point that live routing
-            // and staged-buffer flushes share. See the comment there for why
-            // rejecting here, at line receipt, was wrong for staged connections.
-            if (eventName) {
-                // Emit the typed event with params and (for requests) a respond callback
-                if (request.id != null) {
-                    // Server expects a response — provide a respond helper
-                    this.emit(eventName, request.params, {
-                        id: request.id,
-                        respond: (result) => this.sendResponse(request.id, result),
-                        respondError: (code, message, data) => this.sendErrorResponse(request.id, code, message, data),
-                    });
-                }
-                else {
-                    // Notification — no response expected
-                    this.emit(eventName, request.params);
-                }
+            else {
+                console.error(`[mcpl] ${this.id}: discarded featureSets/changed — removed in 0.5.0 (§6.7/§17)`);
             }
-        });
+            return;
+        }
+        if (request.method === McplMethod.ScopeElevate) {
+            if (request.id != null) {
+                this.sendErrorResponse(request.id, -32601, 'scope/elevate removed in MCPL 0.5.0 (SPEC §7)');
+            }
+            return;
+        }
+        // Positive-grant enforcement (§5.4, §14.1) happens at ADMISSION, in
+        // the emit() override below — the one choke-point that live routing
+        // and staged-buffer flushes share. See the comment there for why
+        // rejecting here, at line receipt, was wrong for staged connections.
+        if (!eventName) {
+            // §6.6: a request that will never be answered MUST get an error, so a
+            // request (it has an id) whose method isn't a string, or isn't one this
+            // host handles, is answered -32601. A notification nobody handles is
+            // ignored, as JSON-RPC asks.
+            if (request.id != null) {
+                this.sendErrorResponse(request.id, -32601, 'Method not found');
+                console.error(`[mcpl] ${this.id}: answered -32601 to a request for ${describeMethod(request.method)}, which this host doesn't handle`);
+            }
+            return;
+        }
+        // Emit the typed event with params and (for requests) a respond callback
+        if (request.id != null) {
+            // Server expects a response — provide a respond helper
+            this.dispatchInboundEvent(eventName, request.params, this.responderFor(request.id, epoch));
+        }
+        else {
+            // Notification — no response expected
+            this.dispatchInboundEvent(eventName, request.params);
+        }
+    }
+    /**
+     * A request's responder, bound to the transport it came on (`epoch`): an
+     * answer, or a streamed inference's chunk, sent after that transport has
+     * closed reaches nothing, never a server that didn't ask it.
+     */
+    responderFor(id, epoch) {
+        return {
+            id,
+            respond: (result) => this.sendResponse(id, result, epoch),
+            respondError: (code, message, data) => this.sendErrorResponse(id, code, message, data, epoch),
+            sendChunk: (params) => this.sendInferenceChunk(params, epoch),
+        };
+    }
+    /**
+     * A request or notification read from a transport after its boundary has
+     * passed: the boundary's rule (resetPolicyForTransportBoundary). An
+     * incoming message or push is held as kept, for the next transport's
+     * grant, and any other is dropped and logged. (A response read then goes to
+     * handleResponse, flagged late.) A stdio
+     * server's transport closes on the child's 'exit', when its stdout may
+     * still be open, as it is while a process the server started holds it, and
+     * it is read until the next reconnect attempt closes its reader. No
+     * transport serves meanwhile, so what is held waits for the next grant
+     * (flushHeld). A connection closed for good, which won't reconnect, reads
+     * it while its writer lives, with no grant to come, so it drops and logs
+     * all of it; hold's bounds cap what any other keeps.
+     */
+    afterBoundary(request, epoch) {
+        const event = typeof request.method === 'string' && Object.hasOwn(McplServerConnection.METHOD_TO_EVENT, request.method)
+            ? McplServerConnection.METHOD_TO_EVENT[request.method] : undefined;
+        if (this.closedForGood || event === undefined || !McplServerConnection.WORLD_EVENTS.has(event)) {
+            console.error(`[mcpl] ${this.id}: dropped a message read after its transport closed` +
+                `${this.closedForGood ? ', with no transport to come' : ''}: ${describeMethod(request.method)}`);
+            return;
+        }
+        this.hold(event, request.id != null ? [request.params, this.responderFor(request.id, epoch)] : [request.params], true);
+    }
+    /** Live delivery and delayed plane flushes share the same containment boundary. */
+    dispatchInboundEvent(event, ...args) {
+        try {
+            this.emit(event, ...args);
+        }
+        catch (error) {
+            const requestId = args[1]?.id;
+            this.reportInboundFailure(error, {
+                event,
+                ...(typeof requestId === 'string' || typeof requestId === 'number' ? { requestId } : {}),
+            });
+        }
+    }
+    /** Report a failure the containment boundary caught, naming the event (or
+     *  method) and request it was dispatching, and what failed. The message is
+     *  what the framework's 'error' listener traces. */
+    reportInboundFailure(cause, context = {}) {
+        const where = (show) => (context.event === undefined ? '' : ` for ${show(context.event)}`) +
+            (context.requestId === undefined ? '' : ` (request ${show(String(context.requestId))})`);
+        // The error's message is what the 'error' listener traces, as text a
+        // reader parses, so it is bounded rather than escaped (boundedForLog);
+        // the log line prints the same through log-value.
+        const error = new Error(`MCPL server "${this.id}" inbound dispatch failed${where(boundedForLog)}: ${boundedForLog(describeCause(cause))}`, { cause });
+        console.error(`[mcpl] ${this.id}: inbound dispatch failed${where(logValue)}: ${logDetail(describeCause(cause))}`);
+        this.emitToErrorListeners(error);
+    }
+    /**
+     * Give an error to the connection's 'error' listeners, and say whether it
+     * has any. EventEmitter throws an 'error' that nothing listens for, and
+     * from a transport's callback, where these errors arise, nothing catches
+     * that throw, so it ends the process. A bare connection has no listener:
+     * the class is exported, and a probe, a playtest or a harness often attaches
+     * none. So with no listener, the error is the caller's to log, unless it
+     * already has. A listener that throws is caught and logged, with the error
+     * it was handling.
+     */
+    emitToErrorListeners(error) {
+        if (this.listenerCount('error') === 0)
+            return false;
+        try {
+            this.emit('error', error);
+        }
+        catch (listenerError) {
+            console.error(`[mcpl] ${this.id}: an 'error' listener failed: ${logDetail(describeCause(listenerError))}` +
+                `, handling ${logDetail(error.message)}`);
+        }
+        return true;
     }
     /**
      * Handle a JSON-RPC response by resolving/rejecting the corresponding pending request.
      */
-    handleResponse(response) {
-        const pending = this.pendingRequests.get(response.id);
+    handleResponse(response, late = false) {
+        // One read after its transport's boundary answers a request the close
+        // ended. It's matched against none of this connection's request records,
+        // since the next transport numbers its requests afresh, and goes the way
+        // of any late answer: a stateful one is surfaced as an orphaned response.
+        const pending = late ? undefined : this.pendingRequests.get(response.id);
         if (!pending) {
             // Orphaned response — the request already timed out (or was settled) and
             // was removed from pendingRequests. A late STATEFUL result must be
@@ -1090,12 +2073,20 @@ export class McplServerConnection extends EventEmitter {
             // Selected side-effecting calls are also surfaced even without state so
             // their outcome-unknown receipt remains visible. We cannot safely
             // re-inject either result because the original dispatch context is gone.
-            const orphaned = this.orphanedRequests.get(response.id);
-            this.orphanedRequests.delete(response.id);
-            if (orphaned?.renderParams) {
-                this.emit('orphaned-render-response', { params: orphaned.renderParams, result: response.result, error: response.error });
-                return; // audit only: a timeout fallback can never be replaced
-            }
+            const orphaned = late ? undefined : this.orphanedRequests.get(response.id);
+            if (!late)
+                this.orphanedRequests.delete(response.id);
+            // A push/render answered after its timeout (RFC-006 §5.3) is reported
+            // with the render's featureSet, key, eventId and, for a channel-scoped
+            // subject, channelId, kept from its request when the timeout fired, so
+            // its discarded answer can be recorded beside its batch's other
+            // coalescing records (§11). It is only reported: the fallback the
+            // timeout materialized stands (§5.4 rule 3). A late JSON-RPC error is
+            // passed on as `error`, so its record can be told from a late result's,
+            // and so is one beside a result, which JSON-RPC forbids: the live path
+            // rejects such an answer as an error.
+            const render = orphaned?.renderParams ?? {};
+            const failure = response.error ? { error: { code: response.error.code, message: response.error.message } } : {};
             const result = response.result;
             if (result && typeof result === 'object') {
                 const r = result;
@@ -1105,6 +2096,8 @@ export class McplServerConnection extends EventEmitter {
                         method: orphaned?.method,
                         hadState: r.state !== undefined,
                         hadCheckpoint: r.checkpoint !== undefined,
+                        ...render,
+                        ...failure,
                     });
                 }
             }
@@ -1114,6 +2107,8 @@ export class McplServerConnection extends EventEmitter {
                     method: orphaned.method,
                     hadState: false,
                     hadCheckpoint: false,
+                    ...render,
+                    ...failure,
                 });
             }
             return; // Orphaned response — ignore
@@ -1122,7 +2117,27 @@ export class McplServerConnection extends EventEmitter {
         if (pending.timer)
             clearTimeout(pending.timer);
         if (response.error) {
-            pending.reject(new Error(`MCPL server "${this.id}" returned error for ${pending.method}: [${response.error.code}] ${response.error.message}`));
+            // The server's own words, after a word on whose they are, bounded as
+            // errors.ts says, since they're the server's text. Only a string is
+            // words: a message of any other JSON value reads as none. The method,
+            // id and JSON-RPC code are the operator's, so they go to the log, which
+            // prints any value a server can send without throwing (logValue). The
+            // caller's text keeps the server's words unredacted, as a JSON-RPC
+            // answer passes (redactServerText's scope); the log is a record of the
+            // server's text, so the message is redacted there, whatever JSON value
+            // it is, as every other line this connection writes is.
+            const said = typeof response.error.message === 'string' ? boundedForLog(response.error.message.trim()) : '';
+            // The call is settled before its log line: its entry is gone and its
+            // timer cleared, so nothing else would settle it, and a host's logger
+            // can throw. The dispatch's containment reports such a throw. (A
+            // configuration that can't be read withholds the message rather than
+            // throw: redactServerText.)
+            pending.reject(new McplRequestError(said
+                ? `The "${this.id}" server answered with an error: ${said}`
+                : `The "${this.id}" server answered with an error without saying what went wrong, so whether the request took effect is unknown. ` +
+                    'Check its effect before trying again.', 'error-response', response.error.data));
+            console.error(`MCPL server "${this.id}" answered ${pending.method} (id=${response.id}) with error ${logValue(response.error.code)}: ` +
+                logValueRedacted(response.error.message, (text) => redactServerText(text, this.config ?? {})));
         }
         else {
             pending.resolve(response.result);
@@ -1131,17 +2146,30 @@ export class McplServerConnection extends EventEmitter {
     /**
      * Send a successful JSON-RPC response back to the server.
      */
-    sendResponse(id, result) {
-        if (this.closed)
+    sendResponse(id, result, epoch = this.transportEpoch) {
+        // A closed connection's epoch is past every request's, so a refusal
+        // while it is closed is logged too.
+        if (!this.sameTransport(id, epoch) || this.closed)
             return;
         const response = { jsonrpc: '2.0', id, result };
         this.transport?.writeLine(JSON.stringify(response));
     }
+    /** Whether a response to a request received on `epoch` may go out now.
+     *  The id is the server's, so it's logged as a field; `answer`, which the
+     *  caller has formatted for the log, ends the line. */
+    sameTransport(id, epoch, answer) {
+        if (epoch === this.transportEpoch)
+            return true;
+        console.error(`[mcpl] ${this.id}: not answering request ${logValue(id)}: the transport it came on has closed${answer ? `, with ${answer}` : ''}`);
+        return false;
+    }
     /**
      * Send a JSON-RPC error response back to the server.
      */
-    sendErrorResponse(id, code, message, data) {
-        if (this.closed)
+    sendErrorResponse(id, code, message, data, epoch = this.transportEpoch) {
+        // A refusal that can't be answered still says what it refused: a held
+        // message admitted under the next transport's grant is refused here.
+        if (!this.sameTransport(id, epoch, `error ${code} ${logDetail(message)}`) || this.closed)
             return;
         const response = {
             jsonrpc: '2.0',
@@ -1161,26 +2189,41 @@ export class McplServerConnection extends EventEmitter {
     setupLifecycle(transport) {
         this.hostCloseRequested = false;
         transport.on('error', (err) => {
-            this.emit('error', new Error(`MCPL server "${this.id}" transport error: ${err.message}`));
+            const error = new Error(`MCPL server "${this.id}" transport error: ${err.message}`);
+            if (!this.emitToErrorListeners(error))
+                console.error(`[mcpl] ${this.id}: transport error: ${logDetail(err.message)}`);
         });
-        transport.on('close', (info) => {
+        const lost = (info) => {
             if (!this.closed) {
                 this.closed = true;
                 this.resetPolicyForTransportBoundary();
-                // Reject all pending requests
-                for (const [id, pending] of this.pendingRequests) {
+                // A teardown the host asked for via reconnectAfterFailure() arrives
+                // here too; it's reported as such below.
+                const byHost = this.hostCloseRequested;
+                this.hostCloseRequested = false;
+                // Reject all pending requests. The words hold whether the server
+                // dropped or this host closed the transport to recover; how it closed
+                // is the operator's, so it goes to the log, not into the messages.
+                if (this.pendingRequests.size > 0) {
+                    // Whatever the host asked for, the close's own details are kept, so
+                    // a drop that races a recycle loses nothing.
+                    const how = `${byHost ? 'closed by this host, ' : ''}` +
+                        `code=${info.code ?? 'n/a'}, signal=${info.signal ?? 'n/a'}, reason=${closeReasonText(info)}`;
+                    console.error(`MCPL server "${this.id}" disconnected (${how}) with ${this.unansweredRequests()}`);
+                }
+                for (const pending of this.pendingRequests.values()) {
                     if (pending.timer)
                         clearTimeout(pending.timer);
-                    pending.reject(new Error(`MCPL server "${this.id}" disconnected unexpectedly (code=${info.code ?? 'n/a'}, signal=${info.signal ?? 'n/a'}, reason=${info.reason ?? 'unknown'}) while awaiting ${pending.method} (id=${id})`));
+                    pending.reject(new McplRequestError(`The connection to the "${this.id}" server closed before it answered, so whether the request took effect is unknown. ` +
+                        (this.reconnectEnabled
+                            ? 'Check its effect before trying again; this host is reconnecting to it.'
+                            : "This host won't reconnect to it on its own. If you need it, ask whoever runs this host."), 'no-response'));
                 }
                 this.pendingRequests.clear();
                 this.orphanedRequests.clear();
                 // Forward the transport's close info so listeners can tell a server
                 // that refused the credential (WebSocket 4001) from a crash, and act
-                // before the reconnect below redials. A teardown the host asked for
-                // via reconnectAfterFailure() arrives here too; report it as such.
-                const byHost = this.hostCloseRequested;
-                this.hostCloseRequested = false;
+                // before the reconnect below redials.
                 const closeInfo = {
                     transport: transport.kind,
                     code: info.code ?? null,
@@ -1195,6 +2238,22 @@ export class McplServerConnection extends EventEmitter {
                     this.scheduleReconnect();
                 }
             }
+        };
+        transport.on('close', lost);
+        // A stdio child whose stdin or stdout failed, and that outlived SIGKILL
+        // too: the transport stays open, owning the child. The connection holds
+        // it as a launch it can't reap, as a reconnect does, which halts
+        // reconnecting, and is lost as on a close, with the permanent failure
+        // that raises the alert and takes its tools off the list. Its id stays
+        // held until close() confirms the exit. A close the host has begun
+        // reports the failure itself. During a handshake nothing listens yet:
+        // the handshake's own cleanup holds the launch, once the handshake fails.
+        transport.on('unreaped', (failure) => {
+            if (this.closed || this.transport !== transport)
+                return;
+            this.holdUnreaped(transport, failure);
+            lost({ reason: `its stdio pipe failed with ${transport.pipeFailure?.message ?? 'an error'}, and its child outlived SIGKILL` });
+            this.emit('reconnect-failed', { error: this.unreapedFailure(), attempt: Math.max(1, this.reconnectAttempts), permanent: true });
         });
     }
 }