@gajae-code/coding-agent 0.16.3 → 0.16.6

package/src/modes/types.ts

@@ -74,6 +74,20 @@ export type ActivityIndicatorStopOptions = Readonly<{
 	foregroundSettled?: boolean;
 }>;
 
+export function clearInteractiveActivityIndicator(ctx: {
+	loadingAnimation?: Loader;
+	statusContainer?: PartialActivityStatusContainer;
+	clearLoadingAnimation?: () => void;
+}): void {
+	if (ctx.clearLoadingAnimation) {
+		ctx.clearLoadingAnimation();
+		return;
+	}
+	ctx.loadingAnimation?.stop();
+	ctx.loadingAnimation = undefined;
+	ctx.statusContainer?.clear?.();
+}
+
 export function stopInteractiveActivityIndicator(
 	ctx: {
 		loadingAnimation?: Loader;
@@ -86,9 +100,7 @@ export function stopInteractiveActivityIndicator(
 		ctx.stopLoadingAnimation(options);
 		return;
 	}
-	ctx.loadingAnimation?.stop();
-	ctx.loadingAnimation = undefined;
-	ctx.statusContainer?.clear?.();
+	clearInteractiveActivityIndicator(ctx);
 }
 
 export function clearInteractiveActivityLoaders(
@@ -285,6 +297,7 @@ export interface InteractiveModeContext {
 	setWorkingMessage(message?: string): void;
 	applyPendingWorkingMessage(): void;
 	ensureLoadingAnimation(): void;
+	clearLoadingAnimation(): void;
 	syncActivityIndicator(): void;
 	suspendActivityIndicator(): () => void;
 	stopLoadingAnimation(options?: ActivityIndicatorStopOptions): void;
@@ -355,6 +368,7 @@ export interface InteractiveModeContext {
 	extractAssistantText(message: AssistantMessage): string;
 	/** Records one semantic visible-transcript mutation for the sticky viewport. */
 	recordVisibleTranscriptMutation?(): void;
+	resetAssistantTextPresentation(): void;
 	updateEditorTopBorder(): void;
 	updateEditorBorderColor(): void;
 	rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;

package/src/modes/utils/ui-helpers.ts

@@ -530,6 +530,7 @@ export class UiHelpers {
 					component.appendOutput(message.output);
 				}
 				component.setComplete(message.exitCode, message.cancelled, {
+					signal: message.signal,
 					truncation: message.meta?.truncation,
 				});
 				addChatChild(this.ctx, component);
@@ -944,6 +945,7 @@ export class UiHelpers {
 		this.ctx.pendingPythonComponents = this.ctx.pendingPythonComponents.filter(component =>
 			runningExecutionComponents.includes(component),
 		);
+		this.ctx.resetAssistantTextPresentation();
 		this.ctx.chatContainer.clear();
 
 		// Reuse a pre-built context when available (e.g. from navigateTree) to avoid a second O(N) walk.

package/src/prompts/system/system-prompt.md

@@ -47,6 +47,14 @@ Optimize for correctness first, maintainability second, and brevity third. Prefe
 - Do not defer actionable work. Underpromise and overdeliver: report only what is done or in progress, never announce remaining work instead of doing it.
 </communication>
 
+{{#if reasoningLanguageEnglish}}
+<reasoning-language>
+- Reason through development and technical problem-solving in English.
+- Keep user-facing answers in the language the user requested or used.
+- This changes reasoning language only; it does not relax correctness, safety, or communication requirements.
+</reasoning-language>
+{{/if}}
+
 <completion-contract>
 - Never present partial work as complete.
 - Never suppress tests or warnings to make code pass.

package/src/prompts/tools/search.md

@@ -5,6 +5,7 @@ Searches files using powerful regex matching.
 - `paths` accepts an array of files, directories, globs, or internal URLs; when omitted, the whole working directory is searched
 - `paths` is an array; do not embed commas or spaces inside a single entry. Pass `["src", "tests"]` not `["src,tests"]`.
 - Cross-line patterns are detected from literal `\n` or escaped `\\n` in `pattern`
+- `timeout` is in seconds (default 5, range 0.5–60). Increase it only for intentionally broad searches; narrow `paths` first
 </instruction>
 
 <output>
@@ -20,4 +21,5 @@ Searches files using powerful regex matching.
 <critical>
 - Search paths are an array; pass separate entries rather than comma-joined paths.
 - Use a cross-line pattern only when the match actually spans lines.
+- Do not retry a timed-out search unchanged; narrow `paths`/`pattern` or explicitly increase `timeout`.
 </critical>

package/src/prompts/tools/subagent.md

@@ -15,6 +15,7 @@ Inspect selected subagents by `ids`; omit `ids` to inspect current running subag
 ## `action: "await"`
 Wait for selected subagents by `ids`; omit `ids` to wait for current running subagents.
 - Always set `timeout_ms` when the result is not immediately required forever.
+- `heartbeat_ms` accepts integer intervals from 100 to 60,000 milliseconds (for example, 10,000 for ten seconds); `0` disables heartbeat updates and omission retains the 500 ms default. Terminal completion is event-driven, not delayed until the next heartbeat.
 - Await timeout only bounds this tool call's wait; it does not stop the subagent and is not a failure reason.
 - On timeout, inspect progress and keep doing independent work. Never cancel just because an await timed out; cancel only if the subagent has actually failed, gone off-track, or become unrecoverably wrong.
 - Completed results are receipt-first by default: bounded preview plus `agent://<id>` output ref when available, not full retained output.

package/src/runtime-mcp/client.ts

@@ -24,8 +24,8 @@ import {
 	normalizeMcpCacheHints,
 	resolveMCPProtocolPreference,
 } from "./protocol";
-import { createHttpTransport, HttpTransport } from "./transports/http";
-import { createStdioTransport } from "./transports/stdio";
+import { HttpTransport } from "./transports/http";
+import { StdioTransport } from "./transports/stdio";
 import type {
 	MCPDiscoverResultLite,
 	MCPGetPromptParams,
@@ -188,18 +188,18 @@ async function defaultRequestHandler(method: string, _params: unknown): Promise<
 /**
  * Create a transport for the given server config.
  */
-async function createTransport(config: MCPServerConfig): Promise<MCPTransport> {
+function createTransport(config: MCPServerConfig): StdioTransport | HttpTransport {
 	const serverType = config.type ?? "stdio";
 
 	switch (serverType) {
 		case "stdio":
-			return createStdioTransport(config as MCPStdioServerConfig);
+			return new StdioTransport(config as MCPStdioServerConfig);
 		case "http":
-			return createHttpTransport(config as MCPHttpServerConfig);
+			return new HttpTransport(config as MCPHttpServerConfig);
 		case "sse":
 			// Compatibility: `sse` configs use Streamable HTTP, not the legacy MCP SSE
 			// protocol. The configured URL receives JSON-RPC POST requests directly.
-			return createHttpTransport(config as MCPSseServerConfig);
+			return new HttpTransport(config as MCPSseServerConfig);
 		default:
 			throw new Error(`Unknown server type: ${serverType}`);
 	}
@@ -295,6 +295,42 @@ function unwrapTransportFailure(error: unknown): unknown {
 	return error instanceof MCPExpectedFailure && error.cause !== undefined ? error.cause : error;
 }
 
+function transportFailureCauses(error: unknown): unknown[] {
+	const failure = unwrapTransportFailure(error);
+	return failure instanceof AggregateError ? failure.errors : [failure];
+}
+
+function connectionAndCleanupCause(connectionError: unknown, cleanupError: unknown): AggregateError {
+	return new AggregateError(
+		[...transportFailureCauses(connectionError), ...transportFailureCauses(cleanupError)],
+		"MCP connection failed and transport cleanup also failed",
+	);
+}
+
+function combinedConnectionAndCleanupFailure(connectionError: unknown, cleanupError: unknown): MCPExpectedFailure {
+	return new MCPExpectedFailure(connectionAndCleanupCause(connectionError, cleanupError));
+}
+
+/** Failed connection whose still-owned transport cleanup can be retried explicitly. */
+export class MCPConnectionCleanupFailure extends MCPExpectedFailure {
+	#transport: MCPTransport;
+
+	constructor(cause: unknown, transport: MCPTransport) {
+		super(cause);
+		this.name = "MCPConnectionCleanupFailure";
+		this.#transport = transport;
+	}
+
+	/** Retry the same retained transport cleanup; failures preserve all prior causes. */
+	async close(): Promise<void> {
+		try {
+			await this.#transport.close();
+		} catch (cleanupError) {
+			throw new MCPConnectionCleanupFailure(connectionAndCleanupCause(this, cleanupError), this.#transport);
+		}
+	}
+}
+
 type ModernNegotiation =
 	| { outcome: "modern"; discovery: MCPDiscoverResultLite | null; discoverState: "yes" | "no"; versionRetry: boolean }
 	| { outcome: "legacy-fallback"; reason: MCPDowngradeReason };
@@ -505,14 +541,14 @@ export async function connectToServer(
 	},
 ): Promise<MCPServerConnection> {
 	const timeoutMs = config.timeout ?? CONNECTION_TIMEOUT_MS;
-	let transport: MCPTransport | undefined;
+	let transport: StdioTransport | HttpTransport | undefined;
 	const connectAbort = new AbortController();
 	const connectSignal = options?.signal ? AbortSignal.any([options.signal, connectAbort.signal]) : connectAbort.signal;
 
 	const preference = resolveMCPProtocolPreference(config.protocol);
 
 	const connect = async (): Promise<MCPServerConnection> => {
-		transport = await createTransport(config);
+		transport = createTransport(config);
 		if (options?.onNotification) {
 			transport.onNotification = options.onNotification;
 		}
@@ -561,6 +597,7 @@ export async function connectToServer(
 		};
 
 		try {
+			await transport.connect();
 			// stdio has no per-request HTTP era signals; it stays on the legacy handshake.
 			if ((config.type ?? "stdio") === "stdio") {
 				return await connectLegacy("legacy-forced", "stdio-transport");
@@ -609,8 +646,8 @@ export async function connectToServer(
 		} catch (error) {
 			try {
 				await transport.close();
-			} catch {
-				// Preserve the initialization failure when cleanup also fails.
+			} catch (cleanupError) {
+				throw combinedConnectionAndCleanupFailure(error, cleanupError);
 			}
 			throw error;
 		}
@@ -625,20 +662,26 @@ export async function connectToServer(
 		// abort initialization and wait for transport cleanup before returning.
 		const aborted = options?.signal?.aborted === true;
 		connectAbort.abort(error);
+		let failure = error;
+		let cleanupIncomplete = false;
 		if (transport) {
 			try {
 				await transport.close();
-			} catch {
-				// Preserve the primary connection failure when cleanup also fails.
+			} catch (cleanupError) {
+				failure = combinedConnectionAndCleanupFailure(failure, cleanupError);
+				cleanupIncomplete = true;
 			}
 		}
-		if (error instanceof MCPExpectedFailure) {
-			throw error;
+		if (cleanupIncomplete && transport) {
+			throw new MCPConnectionCleanupFailure(unwrapTransportFailure(failure), transport);
 		}
-		if (aborted || (error instanceof Error && error.message === connectionTimeoutMessage)) {
-			throw new MCPExpectedFailure(error);
+		if (failure instanceof MCPExpectedFailure) {
+			throw failure;
 		}
-		throw error;
+		if (aborted || (failure instanceof Error && failure.message === connectionTimeoutMessage)) {
+			throw new MCPExpectedFailure(failure);
+		}
+		throw failure;
 	}
 }
 

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,88 @@ 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);
+	}
+	#pruneSettledPendingAcquireCleanups(name: string): void {
+		for (const error of this.#pendingAcquireCleanups.get(name) ?? []) {
+			if (!this.#pool.hasPendingAcquireCleanup(error)) this.#removePendingAcquireCleanup(name, error);
+		}
+	}
+
+	#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
+			.finally(() => {
+				if (!this.#pool.hasPendingAcquireCleanup(error)) this.#removePendingAcquireCleanup(name, error);
+			})
+			.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 +498,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,7 +525,9 @@ 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),
 		});
+		this.#pruneSettledPendingAcquireCleanups(name);
 		if (trackManagerLease) this.#leaseByConnection.set(lease.connection, lease);
 		if (!this.#toolsOnly) lease.updateRoots(this.#getRoots().roots);
 		return lease;
@@ -958,6 +1050,25 @@ export class MCPManager {
 		const connectionTasks: ConnectionTask[] = [];
 
 		for (const [name, config] of Object.entries(configs)) {
+			// Another manager sharing the pool may have retried and completed an
+			// abandoned-acquire cleanup. Retire this manager's observation before
+			// applying its reconnect fence; pool ownership remains authoritative.
+			this.#pruneSettledPendingAcquireCleanups(name);
+			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 +1247,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 +1382,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 +1695,7 @@ export class MCPManager {
 			});
 			result = await Promise.race([callbackPromise, abortPromise]);
 		} catch (error) {
+			this.#retainConnectionCleanupFailure(operation.name, error);
 			failed = true;
 			primaryError = error;
 		} finally {
@@ -1609,6 +1723,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 +1757,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 +1794,24 @@ export class MCPManager {
 		this.#subscribedResources.delete(name);
 
 		let closeError: unknown;
+		try {
+			// A transport may ignore its abort signal while the initial connection
+			// is still opening. The pool owns that abandoned flight and closes any
+			// late connection, so disconnect must not wait for the uncooperative
+			// opener. Already-materialized cleanup failures are still retried here.
+			await this.#closePendingConnectionCleanup(name, false);
+		} 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 +1827,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 +1847,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 +1882,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 +1916,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 +1934,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 +1960,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 +1969,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 +2007,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 +2078,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 +2087,7 @@ export class MCPManager {
 						});
 						return null;
 					}
+					if (cleanupFailure) throw cleanupFailure;
 
 					const msg = error instanceof Error ? error.message : String(error);
 					if (attempt < delays.length) {