@gajae-code/coding-agent 0.16.3 → 0.16.4

package/src/runtime-mcp/manager.ts

@@ -20,6 +20,7 @@ import {
 	listResources,
 	listResourceTemplates,
 	listTools,
+	MCPConnectionCleanupFailure,
 	readResource,
 	serverSupportsPrompts,
 	serverSupportsResources,
@@ -344,6 +345,8 @@ export class MCPManager {
 	#pendingConnections = new Map<string, Promise<MCPServerConnection>>();
 	#pendingConnectionControllers = new Map<string, AbortController>();
 	#pendingToolLoads = new Map<string, Promise<ToolLoadResult>>();
+	#pendingConnectionCleanups = new Map<string, MCPConnectionCleanupFailure>();
+	#pendingAcquireCleanups = new Map<string, Set<MCPPoolAcquireAbortError>>();
 	#sources = new Map<string, SourceMeta>();
 	#authStorage: AuthStorage | null = null;
 	#inputRequestHandler: MCPInputRequestHandler | null = null;
@@ -373,6 +376,79 @@ export class MCPManager {
 	#serverError(message: string): string {
 		return this.#toolsOnly ? "MCP server unavailable" : message;
 	}
+
+	#removePendingAcquireCleanup(name: string, error: MCPPoolAcquireAbortError): void {
+		const pending = this.#pendingAcquireCleanups.get(name);
+		pending?.delete(error);
+		if (pending?.size === 0) this.#pendingAcquireCleanups.delete(name);
+	}
+
+	#retainPendingAcquireCleanup(name: string, error: MCPPoolAcquireAbortError): void {
+		if (error.cleanupGeneration === undefined || !error.cleanup || !this.#pool.hasPendingAcquireCleanup(error))
+			return;
+		let pending = this.#pendingAcquireCleanups.get(name);
+		if (!pending) {
+			pending = new Set();
+			this.#pendingAcquireCleanups.set(name, pending);
+		}
+		if (pending.has(error)) return;
+		pending.add(error);
+		void error.cleanup.catch(() => {});
+	}
+
+	#retainConnectionCleanupFailure(name: string, error: unknown): MCPConnectionCleanupFailure | undefined {
+		if (error instanceof MCPPoolAcquireAbortError) {
+			this.#retainPendingAcquireCleanup(name, error);
+			return undefined;
+		}
+		if (!(error instanceof MCPConnectionCleanupFailure)) return undefined;
+		if (!this.#pool.ownsPendingAcquireCleanupFailure(error)) this.#pendingConnectionCleanups.set(name, error);
+		return error;
+	}
+	async #closePendingConnectionCleanup(name: string, waitForAcquireFlight = true): Promise<void> {
+		const failures: unknown[] = [];
+		const pendingAcquires = [...(this.#pendingAcquireCleanups.get(name) ?? [])];
+		const acquireResults = await Promise.allSettled(
+			pendingAcquires.map(error => {
+				if (!error.cleanup) return Promise.resolve();
+				if (!waitForAcquireFlight && !this.#pool.getPendingAcquireCleanupFailure(error)) return Promise.resolve();
+				return error.cleanup.then(
+					() => undefined,
+					() =>
+						this.#pool.closePendingAcquireCleanup(error.poolKey, error.cleanupGeneration!).then(() => undefined),
+				);
+			}),
+		);
+		for (const [index, result] of acquireResults.entries()) {
+			const pendingAcquire = pendingAcquires[index];
+			if (!pendingAcquire) continue;
+			if (result.status === "rejected") failures.push(result.reason);
+			if (!this.#pool.hasPendingAcquireCleanup(pendingAcquire)) {
+				this.#removePendingAcquireCleanup(name, pendingAcquire);
+			}
+		}
+
+		const cleanup = this.#pendingConnectionCleanups.get(name);
+		if (cleanup) {
+			let cleanupFailed = false;
+			try {
+				await cleanup.close();
+			} catch (error) {
+				cleanupFailed = true;
+				const retained = error instanceof MCPConnectionCleanupFailure ? error : cleanup;
+				if (this.#pendingConnectionCleanups.get(name) === cleanup) {
+					this.#pendingConnectionCleanups.set(name, retained);
+				}
+				failures.push(error);
+			}
+			if (this.#pendingConnectionCleanups.get(name) === cleanup && !cleanupFailed) {
+				this.#pendingConnectionCleanups.delete(name);
+			}
+		}
+		if (failures.length === 1) throw failures[0];
+		if (failures.length > 1) throw new AggregateError(failures, `MCP server cleanup failed: ${name}`);
+	}
+
 	#assertRawMCPAccessAllowed(): void {
 		if (this.#toolsOnly) throw new Error("Tools-only MCP manager does not allow raw MCP access");
 	}
@@ -413,6 +489,11 @@ export class MCPManager {
 		connectionAbort: AbortController,
 		trackManagerLease = true,
 	): Promise<MCPPoolLease> {
+		const pendingCleanup = this.#pendingConnectionCleanups.get(name);
+		if (pendingCleanup) throw pendingCleanup;
+		if (connectionAbort.signal.aborted) {
+			throw connectionAbort.signal.reason ?? new Error(`MCP connection acquisition aborted: ${name}`);
+		}
 		const sharedConfig = originalConfig.sharing === "shared";
 		const sharedEligible =
 			sharedConfig &&
@@ -435,6 +516,7 @@ export class MCPManager {
 			effectiveHeaders:
 				resolvedConfig.type === "http" || resolvedConfig.type === "sse" ? resolvedConfig.headers : undefined,
 			onRequest: (method, params) => this.#handleServerRequest(method, params),
+			onCleanupPending: error => this.#retainPendingAcquireCleanup(name, error),
 		});
 		if (trackManagerLease) this.#leaseByConnection.set(lease.connection, lease);
 		if (!this.#toolsOnly) lease.updateRoots(this.#getRoots().roots);
@@ -958,6 +1040,21 @@ export class MCPManager {
 		const connectionTasks: ConnectionTask[] = [];
 
 		for (const [name, config] of Object.entries(configs)) {
+			const pendingAcquire = this.#pendingAcquireCleanups.get(name);
+			const pendingCleanup = this.#pendingConnectionCleanups.get(name);
+			if (pendingCleanup || pendingAcquire) {
+				const message =
+					pendingCleanup?.message ??
+					(pendingAcquire
+						? [...pendingAcquire]
+								.map(error => this.#pool.getPendingAcquireCleanupFailure(error)?.message ?? error.message)
+								.at(0)
+						: undefined) ??
+					"MCP connection cleanup pending";
+				errors.set(name, this.#serverError(message));
+				reportedErrors.add(name);
+				continue;
+			}
 			if (sources[name]) {
 				this.#sources.set(name, sources[name]);
 				const existing = this.#connections.get(name);
@@ -1136,6 +1233,7 @@ export class MCPManager {
 					if (!this.#toolsOnly) await this.#loadServerResourcesAndPrompts(name, connection);
 				})
 				.catch(error => {
+					this.#retainConnectionCleanupFailure(name, error);
 					if (this.#pendingToolLoads.get(name) !== toolsPromise) return;
 					this.#pendingToolLoads.delete(name);
 					if (!allowBackgroundLogging || reportedErrors.has(name) || this.#toolsOnly) return;
@@ -1270,6 +1368,7 @@ export class MCPManager {
 					}
 				} else if (task.tracked.status === "rejected") {
 					const reason = task.tracked.reason;
+					this.#retainConnectionCleanupFailure(name, reason);
 					const message = reason instanceof Error ? reason.message : String(reason);
 					errors.set(name, this.#serverError(message));
 					reportedErrors.add(name);
@@ -1582,6 +1681,7 @@ export class MCPManager {
 			});
 			result = await Promise.race([callbackPromise, abortPromise]);
 		} catch (error) {
+			this.#retainConnectionCleanupFailure(operation.name, error);
 			failed = true;
 			primaryError = error;
 		} finally {
@@ -1609,6 +1709,28 @@ export class MCPManager {
 	get retiredLeaseReleaseCountForTests(): number {
 		return this.#retiredLeaseReleases.size;
 	}
+
+	/** Read-only test seam for retained failed-connection cleanup owners. */
+	get pendingConnectionCleanupCountForTests(): number {
+		return (
+			this.#pendingConnectionCleanups.size +
+			[...this.#pendingAcquireCleanups.values()].reduce((count, pending) => count + pending.size, 0)
+		);
+	}
+
+	/** Read-only test seam for retained failed-connection cleanup causes. */
+	getPendingConnectionCleanupFailureForTests(name: string): MCPConnectionCleanupFailure | undefined {
+		const pendingAcquire = this.#pendingAcquireCleanups.get(name);
+		return (
+			this.#pendingConnectionCleanups.get(name) ??
+			(pendingAcquire
+				? [...pendingAcquire]
+						.map(error => this.#pool.getPendingAcquireCleanupFailure(error))
+						.find((error): error is MCPConnectionCleanupFailure => error !== undefined)
+				: undefined)
+		);
+	}
+
 	/**
 	 * Get all connected server names.
 	 */
@@ -1621,7 +1743,13 @@ export class MCPManager {
 	 */
 	getAllServerNames(): string[] {
 		return Array.from(
-			new Set([...this.#sources.keys(), ...this.#connections.keys(), ...this.#pendingConnections.keys()]),
+			new Set([
+				...this.#sources.keys(),
+				...this.#connections.keys(),
+				...this.#pendingConnections.keys(),
+				...this.#pendingConnectionCleanups.keys(),
+				...this.#pendingAcquireCleanups.keys(),
+			]),
 		);
 	}
 
@@ -1652,11 +1780,20 @@ export class MCPManager {
 		this.#subscribedResources.delete(name);
 
 		let closeError: unknown;
+		try {
+			await this.#closePendingConnectionCleanup(name);
+		} catch (error) {
+			closeError = error;
+		}
 		if (connection) {
 			try {
 				await this.#releaseLease(name);
 			} catch (error) {
-				closeError = this.#logLeaseReleaseFailure(name, connection, error);
+				const leaseError = this.#logLeaseReleaseFailure(name, connection, error);
+				closeError =
+					closeError !== undefined
+						? new AggregateError([closeError, leaseError], `MCP server cleanup failed: ${name}`)
+						: leaseError;
 			}
 			if (this.#connections.get(name) === connection) this.#connections.delete(name);
 		}
@@ -1672,7 +1809,7 @@ export class MCPManager {
 
 		// Notify prompt consumers so stale commands are cleared
 		if (connection?.prompts?.length) this.#onPromptsChanged?.(name);
-		if (closeError) throw closeError;
+		if (closeError !== undefined) throw closeError;
 	}
 
 	#abortConnectionTask(task: ConnectionTask): void {
@@ -1692,12 +1829,8 @@ export class MCPManager {
 	}
 
 	async #terminateConnectionTask(task: ConnectionTask): Promise<void> {
-		const connection = await task.connectionPromise.catch(async error => {
-			if (error instanceof MCPPoolAcquireAbortError && error.cleanup) {
-				await error.cleanup.catch(cleanupError => {
-					logger.error("MCP aborted acquire cleanup failed", { path: `mcp:${task.name}`, error: cleanupError });
-				});
-			}
+		const connection = await task.connectionPromise.catch(error => {
+			this.#retainConnectionCleanupFailure(task.name, error);
 			logger.debug("MCP connection task did not publish before cleanup", { path: `mcp:${task.name}`, error });
 			return undefined;
 		});
@@ -1731,6 +1864,14 @@ export class MCPManager {
 		const lifecycleEpoch = this.#beginScopedLifecycle("disconnecting");
 		this.#deferredSharedRebinds.clear();
 		try {
+			const cleanupNames = new Set([
+				...this.#pendingConnectionCleanups.keys(),
+				...this.#pendingAcquireCleanups.keys(),
+				...this.#pendingConnectionControllers.keys(),
+				...this.#pendingConnections.keys(),
+				...this.#serverConfigs.keys(),
+				...[...this.#scopedOperations.values()].map(operation => operation.name),
+			]);
 			// Invalidate any in-flight reconnection attempts that outlive this call.
 			// They captured the old epoch; after increment they'll detect staleness.
 			this.#epoch++;
@@ -1757,6 +1898,11 @@ export class MCPManager {
 			}
 			this.#reconnectBackoffs.clear();
 			this.#pendingReconnections.clear();
+			for (const name of this.#pendingConnectionCleanups.keys()) cleanupNames.add(name);
+			for (const name of this.#pendingAcquireCleanups.keys()) cleanupNames.add(name);
+			const pendingCleanupResults = await Promise.allSettled(
+				[...cleanupNames].map(name => this.#closePendingConnectionCleanup(name, false)),
+			);
 			const retiredReleaseFailures = await this.#drainRetiredLeaseReleases();
 			this.#deferredSharedRebinds.clear();
 			this.#pendingResourceRefresh.clear();
@@ -1770,6 +1916,9 @@ export class MCPManager {
 				...releaseResults
 					.filter((result): result is PromiseRejectedResult => result.status === "rejected")
 					.map(result => result.reason),
+				...pendingCleanupResults
+					.filter((result): result is PromiseRejectedResult => result.status === "rejected")
+					.map(result => result.reason),
 				...retiredReleaseFailures,
 			];
 			if (releaseFailures.length > 0) {
@@ -1793,7 +1942,8 @@ export class MCPManager {
 	 * Tears down the stale connection, re-resolves auth, establishes a new
 	 * connection, reloads tools, and notifies consumers.
 	 * Concurrent calls for the same server share one reconnection attempt.
-	 * Returns the new connection, or null if reconnection failed.
+	 * Returns the new connection, or null if reconnection fails after cleanup.
+	 * Throws a retryable cleanup failure while the previous transport owner remains incomplete.
 	 */
 	async reconnectServer(name: string): Promise<MCPServerConnection | null> {
 		if (this.#connectionSetSealed) return null;
@@ -1801,6 +1951,14 @@ export class MCPManager {
 		const pending = this.#pendingReconnections.get(name);
 		if (pending) return pending;
 
+		const attempt = this.#closePendingConnectionCleanup(name).then(() => this.#startReconnect(name));
+		this.#pendingReconnections.set(name, attempt);
+		return attempt.finally(() => {
+			if (this.#pendingReconnections.get(name) === attempt) this.#pendingReconnections.delete(name);
+		});
+	}
+
+	#startReconnect(name: string): Promise<MCPServerConnection | null> {
 		const lease = this.#leases.get(name);
 		const sharedKey = lease?.sharingMode === "shared" ? lease.key : undefined;
 		let attempt: Promise<MCPServerConnection | null>;
@@ -1831,10 +1989,7 @@ export class MCPManager {
 					.finally(() => this.#pool.releaseRestart(sharedKey));
 			}
 		}
-		this.#pendingReconnections.set(name, attempt);
-		return attempt.finally(() => {
-			if (this.#pendingReconnections.get(name) === attempt) this.#pendingReconnections.delete(name);
-		});
+		return attempt;
 	}
 
 	async #doReconnect(name: string): Promise<MCPServerConnection | null> {
@@ -1905,6 +2060,7 @@ export class MCPManager {
 					logger.debug("MCP reconnected", { path: `mcp:${name}`, tools: connection.tools?.length ?? 0 });
 					return connection;
 				} catch (error) {
+					const cleanupFailure = this.#retainConnectionCleanupFailure(name, error);
 					if ((this.#disconnectEpochs.get(name) ?? 0) !== reconnectEpoch || backoffAbort.signal.aborted) {
 						logger.debug("MCP reconnect aborted after server disconnected", {
 							path: `mcp:${name}`,
@@ -1913,6 +2069,7 @@ export class MCPManager {
 						});
 						return null;
 					}
+					if (cleanupFailure) throw cleanupFailure;
 
 					const msg = error instanceof Error ? error.message : String(error);
 					if (attempt < delays.length) {

package/src/runtime-mcp/pool.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, test } from "bun:test";
+import { MCPConnectionCleanupFailure } from "./client";
+import { MCPManager } from "./manager";
 import { MCPConnectionPool, MCPPoolAcquireAbortError, MCPPoolLeaseInvalidatedError } from "./pool";
 import { MCPPoolConfigError } from "./pool-key";
 import { legacyEraObservation } from "./protocol";
@@ -48,6 +50,17 @@ class FakeTransport implements MCPTransport {
 	}
 }
 
+class ToolListTransport extends FakeTransport {
+	override async request<T = unknown>(
+		method: string,
+		params?: Record<string, unknown>,
+		options?: MCPRequestOptions,
+	): Promise<T> {
+		if (method === "tools/list") return { tools: [] } as T;
+		return super.request<T>(method, params, options);
+	}
+}
+
 class DelayedSubscriptionTransport extends FakeTransport {
 	readonly subscribeStarted = Promise.withResolvers<void>();
 	readonly allowSubscribe = Promise.withResolvers<void>();
@@ -373,6 +386,202 @@ describe("MCPConnectionPool", () => {
 		await pool.shutdown();
 	});
 
+	test("retains cancelled cleanup before late failure and fences each cleanup generation", async () => {
+		const flights = [Promise.withResolvers<MCPServerConnection>(), Promise.withResolvers<MCPServerConnection>()];
+		const starts = [Promise.withResolvers<void>(), Promise.withResolvers<void>()];
+		const recoveryTransports: FakeTransport[] = [];
+		let opens = 0;
+		const pool = new MCPConnectionPool({
+			connect: async (name, cfg) => {
+				opens += 1;
+				if (opens === 1) {
+					starts[0]?.resolve();
+					return flights[0]!.promise;
+				}
+				if (opens === 3) {
+					starts[1]?.resolve();
+					return flights[1]!.promise;
+				}
+				const transport = new FakeTransport();
+				recoveryTransports.push(transport);
+				return connection(name, cfg, transport);
+			},
+		});
+		const acquireCancelledFlight = async (index: number): Promise<MCPPoolAcquireAbortError> => {
+			const controller = new AbortController();
+			const acquire = pool.acquire("server", config(), {
+				sessionId: "retained-cleanup",
+				signal: controller.signal,
+			});
+			await starts[index]!.promise;
+			controller.abort(new Error(`caller abort ${index}`));
+			const error = await acquire.catch(error => error);
+			expect(error).toBeInstanceOf(MCPPoolAcquireAbortError);
+			if (!(error instanceof MCPPoolAcquireAbortError)) throw new Error("Expected aborted pool acquisition");
+			return error;
+		};
+
+		const firstAbort = await acquireCancelledFlight(0);
+		expect(pool.pendingAcquireCleanupCountForTests).toBe(1);
+		expect(opens).toBe(1);
+		const firstCleanupTransport = new FakeTransport();
+		let fencedSettled = false;
+		const fenced = pool.acquire("server", config(), { sessionId: "retained-cleanup" });
+		void fenced.then(
+			() => {
+				fencedSettled = true;
+			},
+			() => {
+				fencedSettled = true;
+			},
+		);
+		await Promise.resolve();
+		expect(fencedSettled).toBe(false);
+		expect(opens).toBe(1);
+		flights[0]!.reject(new MCPConnectionCleanupFailure(new Error("late cleanup failure 1"), firstCleanupTransport));
+		await expect(fenced).resolves.toBeDefined();
+		expect(firstCleanupTransport.closeCount).toBe(1);
+		expect(opens).toBe(2);
+
+		const secondLease = await fenced;
+		await secondLease.release();
+		const secondAbort = await acquireCancelledFlight(1);
+		expect(secondAbort.cleanupGeneration).toBeGreaterThan(firstAbort.cleanupGeneration ?? 0);
+		const secondCleanupTransport = new FakeTransport();
+		flights[1]!.reject(new MCPConnectionCleanupFailure(new Error("late cleanup failure 2"), secondCleanupTransport));
+		await expect(secondAbort.cleanup).rejects.toBeInstanceOf(MCPConnectionCleanupFailure);
+		await pool.closePendingAcquireCleanup(firstAbort.poolKey, firstAbort.cleanupGeneration!);
+		expect(secondCleanupTransport.closeCount).toBe(0);
+		expect(pool.pendingAcquireCleanupCountForTests).toBe(1);
+		await pool.closePendingAcquireCleanup(secondAbort.poolKey, secondAbort.cleanupGeneration!);
+		expect(secondCleanupTransport.closeCount).toBe(1);
+		expect(pool.pendingAcquireCleanupCountForTests).toBe(0);
+		const recovered = await pool.acquire("server", config(), { sessionId: "retained-cleanup" });
+		expect(opens).toBe(4);
+		await recovered.release();
+		expect(recoveryTransports).toHaveLength(2);
+	});
+
+	test("manager disconnect joins and retries pool-owned late cleanup without spawning", async () => {
+		const firstFlight = Promise.withResolvers<MCPServerConnection>();
+		const firstStarted = Promise.withResolvers<void>();
+		const cleanupTransport = new FakeTransport();
+		const retryFailure = new Error("deferred cleanup retry failed");
+		let cleanupAttempts = 0;
+		cleanupTransport.close = async () => {
+			cleanupAttempts += 1;
+			if (cleanupAttempts === 1) throw retryFailure;
+			cleanupTransport.connected = false;
+		};
+		let opens = 0;
+		const pool = new MCPConnectionPool({
+			connect: async (name, cfg) => {
+				opens += 1;
+				if (opens === 1) {
+					firstStarted.resolve();
+					return firstFlight.promise;
+				}
+				return connection(name, cfg, new FakeTransport());
+			},
+		});
+		const manager = new MCPManager(".", null, { pool, sessionId: "disconnect-cleanup" });
+		const serverConfig = config();
+		const controller = new AbortController();
+		const operation = manager.withPreparedLease("server", serverConfig, async () => undefined, {
+			signal: controller.signal,
+		});
+		await firstStarted.promise;
+		controller.abort(new Error("abort before deferred cleanup failure"));
+		await expect(operation).rejects.toBeInstanceOf(MCPPoolAcquireAbortError);
+		expect(manager.pendingConnectionCleanupCountForTests).toBe(1);
+
+		const disconnect = manager.disconnectServer("server");
+		const fenced = await manager.connectServers({ server: serverConfig }, {});
+		expect(fenced.errors.has("server")).toBe(true);
+		expect(opens).toBe(1);
+		const primaryFailure = new Error("late connection cleanup failed");
+		firstFlight.reject(new MCPConnectionCleanupFailure(primaryFailure, cleanupTransport));
+		const disconnectError = await disconnect.catch(error => error);
+		expect(disconnectError).toBeInstanceOf(MCPConnectionCleanupFailure);
+		if (!(disconnectError instanceof MCPConnectionCleanupFailure)) {
+			throw new Error("Expected retained disconnect cleanup failure");
+		}
+		expect(disconnectError.cause).toBeInstanceOf(AggregateError);
+		if (!(disconnectError.cause instanceof AggregateError)) throw new Error("Expected combined cleanup causes");
+		expect(disconnectError.cause.errors).toEqual([primaryFailure, retryFailure]);
+		expect(cleanupAttempts).toBe(1);
+		expect(manager.pendingConnectionCleanupCountForTests).toBe(1);
+		expect(pool.pendingAcquireCleanupCountForTests).toBe(1);
+
+		await manager.disconnectServer("server");
+		expect(cleanupAttempts).toBe(2);
+		expect(manager.pendingConnectionCleanupCountForTests).toBe(0);
+		expect(pool.pendingAcquireCleanupCountForTests).toBe(0);
+		await manager.withPreparedLease("server", serverConfig, async lease => {
+			expect(lease.serverName).toBe("server");
+		});
+		expect(opens).toBe(2);
+		await manager.disconnectAll();
+	});
+
+	test("manager reconnect retries pool-owned cleanup before replacing the live connection", async () => {
+		const transientFlight = Promise.withResolvers<MCPServerConnection>();
+		const transientStarted = Promise.withResolvers<void>();
+		const cleanupTransport = new FakeTransport();
+		const cleanupRetryFailure = new Error("reconnect cleanup retry failed");
+		let cleanupAttempts = 0;
+		cleanupTransport.close = async () => {
+			cleanupAttempts += 1;
+			if (cleanupAttempts === 1) throw cleanupRetryFailure;
+			cleanupTransport.connected = false;
+		};
+		let opens = 0;
+		const transports: ToolListTransport[] = [];
+		const pool = new MCPConnectionPool({
+			connect: async (name, cfg) => {
+				opens += 1;
+				if (opens === 2) {
+					transientStarted.resolve();
+					return transientFlight.promise;
+				}
+				const transport = new ToolListTransport();
+				transports.push(transport);
+				return connection(name, cfg, transport);
+			},
+		});
+		const manager = new MCPManager(".", null, { pool, sessionId: "reconnect-cleanup", sleep: async () => {} });
+		const serverConfig = config();
+		await manager.connectServers({ server: serverConfig }, {});
+		const original = manager.getConnection("server");
+		const controller = new AbortController();
+		const transient = manager.withPreparedLease(
+			"server",
+			{ type: "stdio", command: "fake-mcp", args: ["--transient"] },
+			async () => undefined,
+			{ signal: controller.signal },
+		);
+		await transientStarted.promise;
+		controller.abort(new Error("abort transient before reconnect"));
+		await expect(transient).rejects.toBeInstanceOf(MCPPoolAcquireAbortError);
+
+		const firstReconnect = manager.reconnectServer("server");
+		transientFlight.reject(
+			new MCPConnectionCleanupFailure(new Error("late reconnect cleanup failed"), cleanupTransport),
+		);
+		await expect(firstReconnect).rejects.toBeInstanceOf(MCPConnectionCleanupFailure);
+		expect(cleanupAttempts).toBe(1);
+		expect(opens).toBe(2);
+		expect(manager.getConnection("server")).toBe(original);
+		const replacement = await manager.reconnectServer("server");
+		expect(cleanupAttempts).toBe(2);
+		expect(opens).toBe(3);
+		expect(replacement).toBeDefined();
+		expect(replacement).not.toBe(original);
+		expect(manager.pendingConnectionCleanupCountForTests).toBe(0);
+		await manager.disconnectAll();
+		expect(transports.every(transport => transport.closeCount === 1)).toBe(true);
+	});
+
 	test("shutdown aborts hanging opens, settles waiters, and closes late transports", async () => {
 		let resolveOpen: ((value: MCPServerConnection) => void) | undefined;
 		let openSignal: AbortSignal | undefined;