@gajae-code/coding-agent 0.17.4 → 0.17.5

package/src/modes/components/gjc-bundle-settings.ts

@@ -1,4 +1,4 @@
-import { Container, type SelectItem, SelectList, Spacer, Text } from "@gajae-code/tui";
+import { Container, type SelectItem, SelectList, Spacer, Text, truncateToWidth } from "@gajae-code/tui";
 import {
 	applyGjcBundleUpdate,
 	type GjcLifecycleContext,
@@ -20,8 +20,11 @@ import type {
 	GjcUpdatePreview,
 } from "../../extensibility/gjc-plugins/types";
 import { getSelectListTheme, theme } from "../../modes/theme/theme";
+import { sanitizeStatusText } from "../shared";
 import { DynamicBorder } from "./dynamic-border";
 
+const MAX_RUNTIME_FINDING_DISPLAY_WIDTH = 120;
+
 /** Injectable lifecycle boundary; Settings never reads registries or executes bundle code. */
 export interface GjcBundleLifecyclePort {
 	listGjcBundles(ctx: GjcLifecycleContext): Promise<GjcBundleSummary[]>;
@@ -244,6 +247,23 @@ export class GjcBundleSettingsComponent extends Container {
 				),
 			);
 		}
+		const runtime = findingsForBundle(
+			this.dependencies.runtimeSnapshotProvider,
+			bundle.identity,
+			this.dependencies.activationGeneration ?? 0,
+		);
+		if (runtime.status === "current") {
+			for (const finding of runtime.findings) {
+				const detail = truncateToWidth(
+					sanitizeStatusText(`${finding.surfaceId}: ${finding.message}`),
+					MAX_RUNTIME_FINDING_DISPLAY_WIDTH,
+				);
+				const label = finding.decision === "error" ? "Runtime error" : "Runtime finding";
+				this.addChild(
+					new Text(theme.fg(finding.decision === "error" ? "error" : "warning", `  ${label}: ${detail}`), 0, 0),
+				);
+			}
+		}
 		if (this.#message) this.addChild(new Text(theme.fg("warning", `  ${this.#message}`), 0, 0));
 		const actions: SelectItem[] = [];
 		if (bundle.enabled || !bundle.quarantined) {

package/src/modes/components/tool-status-header.ts

@@ -41,6 +41,33 @@ import { getSeparator } from "./status-line/separators";
 import { calculateTokensPerSecond } from "./status-line/token-rate";
 import type { SeparatorDef } from "./status-line/types";
 
+function usageReportAccountId(report: unknown): string | undefined {
+	if (!report || typeof report !== "object") return undefined;
+	const record = report as {
+		metadata?: unknown;
+		limits?: unknown;
+	};
+	const metadata = record.metadata;
+	const rawMetadataAccountId =
+		metadata && typeof metadata === "object" ? (metadata as { accountId?: unknown }).accountId : undefined;
+	const metadataAccountId =
+		typeof rawMetadataAccountId === "string" && rawMetadataAccountId.trim() ? rawMetadataAccountId.trim() : undefined;
+	if (!Array.isArray(record.limits)) return metadataAccountId;
+
+	const scopeAccountIds = new Set<string>();
+	for (const limit of record.limits) {
+		if (!limit || typeof limit !== "object") continue;
+		const scope = (limit as { scope?: unknown }).scope;
+		if (!scope || typeof scope !== "object") continue;
+		const accountId = (scope as { accountId?: unknown }).accountId;
+		if (typeof accountId === "string" && accountId.trim()) scopeAccountIds.add(accountId.trim());
+	}
+	if (scopeAccountIds.size > 1) return undefined;
+	const [scopeAccountId] = scopeAccountIds;
+	if (metadataAccountId && scopeAccountId && metadataAccountId !== scopeAccountId) return undefined;
+	return metadataAccountId ?? scopeAccountId;
+}
+
 export interface StatusLineSegmentOptions {
 	model?: { showThinkingLevel?: boolean; showContextPercent?: boolean };
 	path?: { abbreviate?: boolean; maxLength?: number; stripWorkPrefix?: boolean };
@@ -218,6 +245,7 @@ export class StatusLineComponent implements Component {
 	#cachedUsage: SegmentContext["usage"] = null;
 	#cachedUsageReports: unknown = null;
 	#cachedUsageProvider: string | undefined;
+	#cachedUsageAccountId: string | undefined;
 	#usageFetchedAt = 0;
 	#usageInFlight = false;
 
@@ -702,7 +730,12 @@ export class StatusLineComponent implements Component {
 			.then(reports => {
 				this.#cachedUsageReports = reports;
 				this.#cachedUsageProvider = this.#activeUsageProvider();
-				this.#cachedUsage = this.#normalizeUsageReports(reports);
+				this.#cachedUsageAccountId = this.#activeCodexAccountId(this.#cachedUsageProvider);
+				this.#cachedUsage = this.#normalizeUsageReports(
+					reports,
+					this.#cachedUsageProvider,
+					this.#cachedUsageAccountId,
+				);
 				this.#usageFetchedAt = Date.now();
 				if (this.#onBranchChange) {
 					this.#onBranchChange();
@@ -720,10 +753,25 @@ export class StatusLineComponent implements Component {
 			});
 	}
 
-	#normalizeUsageReports(reports: unknown): SegmentContext["usage"] {
-		const activeProvider = this.#activeUsageProvider();
-
+	#normalizeUsageReports(
+		reports: unknown,
+		activeProvider = this.#activeUsageProvider(),
+		activeCodexAccountId = this.#activeCodexAccountId(activeProvider),
+	): SegmentContext["usage"] {
 		if (!activeProvider || !Array.isArray(reports)) return null;
+		const activeCodexReportCount =
+			activeProvider === "openai-codex" && activeCodexAccountId
+				? reports.filter(report => {
+						if (!report || typeof report !== "object") return false;
+						const provider = (report as { provider?: unknown }).provider;
+						return (
+							typeof provider === "string" &&
+							resolveOAuthStorageProvider(provider) === activeProvider &&
+							usageReportAccountId(report) === activeCodexAccountId
+						);
+					}).length
+				: 0;
+		const ambiguousActiveCodexReports = activeCodexReportCount > 1;
 		const windows: NonNullable<SegmentContext["usage"]>["windows"] = [];
 		const seen = new Set<string>();
 		const now = Date.now();
@@ -759,6 +807,14 @@ export class StatusLineComponent implements Component {
 			const provider = (report as { provider?: unknown }).provider;
 			const providerId = typeof provider === "string" ? resolveOAuthStorageProvider(provider) : undefined;
 			if (providerId !== activeProvider) continue;
+			// Codex usage fetches cover every OAuth account; fail closed unless this session's account matches uniquely.
+			if (
+				providerId === "openai-codex" &&
+				(!activeCodexAccountId ||
+					ambiguousActiveCodexReports ||
+					usageReportAccountId(report) !== activeCodexAccountId)
+			)
+				continue;
 			const limits = (report as { limits?: unknown }).limits;
 			if (!Array.isArray(limits)) continue;
 			for (const limit of limits) {
@@ -808,11 +864,21 @@ export class StatusLineComponent implements Component {
 		return typeof provider === "string" && provider.length > 0 ? resolveOAuthStorageProvider(provider) : undefined;
 	}
 
+	#activeCodexAccountId(activeProvider: string | undefined): string | undefined {
+		if (activeProvider !== "openai-codex") return undefined;
+		const modelRegistry = this.session.modelRegistry;
+		return modelRegistry.authStorage.getOAuthAccountId(activeProvider, this.session.credentialSessionId, {
+			owner: modelRegistry.getAuthStorageOwner(),
+		});
+	}
+
 	#syncCachedUsageForActiveProvider(): void {
 		const activeProvider = this.#activeUsageProvider();
-		if (this.#cachedUsageProvider === activeProvider) return;
+		const activeCodexAccountId = this.#activeCodexAccountId(activeProvider);
+		if (this.#cachedUsageProvider === activeProvider && this.#cachedUsageAccountId === activeCodexAccountId) return;
 		this.#cachedUsageProvider = activeProvider;
-		this.#cachedUsage = this.#normalizeUsageReports(this.#cachedUsageReports);
+		this.#cachedUsageAccountId = activeCodexAccountId;
+		this.#cachedUsage = this.#normalizeUsageReports(this.#cachedUsageReports, activeProvider, activeCodexAccountId);
 	}
 
 	#buildSegmentContext(

package/src/modes/controllers/runtime-mcp-command-controller.ts

@@ -1606,7 +1606,7 @@ export class MCPCommandController {
 		if (!this.ctx.mcpManager) {
 			return;
 		}
-		if (this.ctx.mcpManager.isConnectionSetSealed()) {
+		if (this.ctx.mcpManager.isConnectionSetMutationBlocked()) {
 			throw new Error("This session's plugin-bundle MCP connections are fixed for its lifetime.");
 		}
 

package/src/runtime-mcp/loader.ts

@@ -44,10 +44,13 @@ export interface MCPToolsLoadOptions {
 	sharedPoolIdleMs?: number;
 }
 
-async function resolveToolCache(storage: AgentStorage | null | undefined): Promise<MCPToolCache | null> {
+export async function resolveMCPToolCache(
+	storage?: AgentStorage | null,
+	dbPath?: string,
+): Promise<MCPToolCache | null> {
 	if (storage === null) return null;
 	try {
-		const resolved = storage ?? (await AgentStorage.open());
+		const resolved = storage ?? (await AgentStorage.open(dbPath));
 		return new MCPToolCache(resolved);
 	} catch (error) {
 		logger.warn("MCP tool cache unavailable", { error: String(error) });
@@ -63,7 +66,7 @@ async function resolveToolCache(storage: AgentStorage | null | undefined): Promi
  * @returns MCP tools in LoadedCustomTool format for integration
  */
 export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoadOptions): Promise<MCPToolsLoadResult> {
-	const toolCache = await resolveToolCache(options?.cacheStorage);
+	const toolCache = await resolveMCPToolCache(options?.cacheStorage);
 	const manager = new MCPManager(cwd, toolCache, { sharedPoolIdleMs: options?.sharedPoolIdleMs });
 	if (options?.authStorage) {
 		manager.setAuthStorage(options.authStorage);

package/src/runtime-mcp/manager.ts

@@ -52,7 +52,7 @@ import type {
 	MCPServerConnection,
 	MCPToolDefinition,
 } from "./types";
-import { MCPExpectedFailure, MCPNotificationMethods } from "./types";
+import { MCPExpectedFailure, MCPHttpRequestError, MCPJsonRpcError, MCPNotificationMethods } from "./types";
 
 type ToolLoadResult = {
 	connection: MCPServerConnection;
@@ -158,6 +158,24 @@ export function withinDeclaredConnectionWindow(config: MCPServerConfig, elapsedM
 	return elapsedMs < timeout;
 }
 
+/** Keep startup logs bounded and free of remote response text. */
+function classifyMCPStartupFailure(error: unknown): string {
+	if (error instanceof MCPExpectedFailure) {
+		return error.cause === undefined ? "expected-mcp-failure" : classifyMCPStartupFailure(error.cause);
+	}
+	if (error instanceof MCPHttpRequestError) {
+		return Number.isInteger(error.status) && error.status >= 100 && error.status <= 599
+			? `http-status:${error.status}`
+			: "http-request-error";
+	}
+	if (error instanceof MCPJsonRpcError) {
+		return Number.isInteger(error.code) && Math.abs(error.code) <= 1_000_000
+			? `json-rpc-code:${error.code}`
+			: "json-rpc-error";
+	}
+	return "transport-error";
+}
+
 function trackPromise<T>(promise: Promise<T>): TrackedPromise<T> {
 	const tracked: TrackedPromise<T> = { promise, status: "pending" };
 	promise.then(
@@ -312,10 +330,10 @@ export interface MCPManagerOptions {
 	/** Restrict this instance to tools from an explicit MCP config. */
 	toolsOnly?: boolean;
 	/**
-	 * Ceiling for the startup wait, in milliseconds. Only ACP lifecycle launches
-	 * set this, so a slow ACP MCP handshake gets the readiness budget while every
-	 * other consumer keeps the short default. Non-positive or non-finite values
-	 * are ignored and the default applies.
+	 * Ceiling for the startup wait, in milliseconds. ACP lifecycle launches and
+	 * plugin MCP startup use bounded caller-owned budgets; other consumers keep
+	 * the short default. Non-positive or non-finite values are ignored and the
+	 * default applies.
 	 */
 	maxStartupTimeoutMs?: number;
 	/** Connection pool used for every physical MCP open/close. */
@@ -324,6 +342,8 @@ export interface MCPManagerOptions {
 	sessionId?: string;
 	/** Idle retention for shared pool entries. */
 	sharedPoolIdleMs?: number;
+	/** Limit tool-cache reads and writes to this manager's conventional servers. */
+	toolCacheServerNames?: ReadonlySet<string>;
 	/** Test seam for deterministic reconnect backoff scheduling. */
 	sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
 	/** Test seam for fencing the acquisition-to-registration replacement race. */
@@ -412,7 +432,8 @@ export class MCPManager {
 	#authStorage: AuthStorage | null = null;
 	#inputRequestHandler: MCPInputRequestHandler | null = null;
 	#onNotification?: (serverName: string, method: string, params: unknown) => void;
-	#onToolsChanged?: (tools: CustomTool<TSchema, MCPToolDetails>[]) => void;
+	#onToolsChanged?: (tools: readonly Readonly<CustomTool<TSchema, MCPToolDetails>>[]) => void;
+	readonly #toolChangeListeners = new Set<(tools: readonly Readonly<CustomTool<TSchema, MCPToolDetails>>[]) => void>();
 	#onResourcesChanged?: (serverName: string, uri: string) => void;
 	#onPromptsChanged?: (serverName: string) => void;
 	#notificationsEnabled = false;
@@ -438,13 +459,21 @@ export class MCPManager {
 	#scopedLifecycle: "open" | "disconnecting" | "reconnecting" = "open";
 	#scopedLifecycleEpoch = 0;
 	readonly #toolsOnly: boolean;
+	#toolCacheServerNames: Set<string> | undefined;
 	#toolsOnlyConfigLoaded = false;
+	#connectionSetMutationBlocked = false;
 	#connectionSetSealed = false;
 
 	#serverError(message: string): string {
 		return this.#toolsOnly ? "MCP server unavailable" : message;
 	}
 
+	#shouldCacheServerTools(name: string): boolean {
+		return (
+			this.toolCache !== null && (this.#toolCacheServerNames === undefined || this.#toolCacheServerNames.has(name))
+		);
+	}
+
 	#removePendingAcquireCleanup(name: string, error: MCPPoolAcquireAbortError): void {
 		const pending = this.#pendingAcquireCleanups.get(name);
 		pending?.delete(error);
@@ -548,13 +577,27 @@ export class MCPManager {
 		return this.#scopedLifecycleEpoch;
 	}
 	#assertConnectionSetMutable(): void {
-		if (this.#connectionSetSealed) throw new Error("MCP manager connection set is sealed");
+		if (this.#connectionSetMutationBlocked) {
+			throw new Error(
+				this.#connectionSetSealed ? "MCP manager connection set is sealed" : "MCP manager connection set is frozen",
+			);
+		}
+	}
+
+	/** Block config mutations and reloads while keeping existing servers reconnectable. */
+	freezeConnectionSet(): void {
+		this.#connectionSetMutationBlocked = true;
 	}
 
 	sealConnectionSet(): void {
+		this.freezeConnectionSet();
 		this.#connectionSetSealed = true;
 	}
 
+	isConnectionSetMutationBlocked(): boolean {
+		return this.#connectionSetMutationBlocked;
+	}
+
 	isConnectionSetSealed(): boolean {
 		return this.#connectionSetSealed;
 	}
@@ -951,6 +994,7 @@ export class MCPManager {
 		options: MCPManagerOptions = {},
 	) {
 		this.#toolsOnly = options.toolsOnly === true;
+		this.#toolCacheServerNames = options.toolCacheServerNames ? new Set(options.toolCacheServerNames) : undefined;
 		this.#maxStartupTimeoutMs = options.maxStartupTimeoutMs;
 		this.#sleep = options.sleep ?? delay;
 		this.#afterLeaseAcquiredForTests = options.afterLeaseAcquiredForTests;
@@ -972,13 +1016,46 @@ export class MCPManager {
 	}
 
 	/**
-	 * Set a callback to fire when any server's tools change.
+	 * Set a callback to receive a read-only catalog snapshot when server tools change.
 	 */
-	setOnToolsChanged(handler: (tools: CustomTool<TSchema, MCPToolDetails>[]) => void): void {
+	setOnToolsChanged(handler: (tools: readonly Readonly<CustomTool<TSchema, MCPToolDetails>>[]) => void): void {
 		if (this.#toolsOnly) return;
 		this.#onToolsChanged = handler;
 	}
 
+	/** Subscribe to readonly catalog snapshots without replacing the manager owner's callback. */
+	subscribeToToolsChanged(
+		handler: (tools: readonly Readonly<CustomTool<TSchema, MCPToolDetails>>[]) => void,
+	): () => void {
+		if (this.#toolsOnly) return () => {};
+		this.#toolChangeListeners.add(handler);
+		return () => {
+			this.#toolChangeListeners.delete(handler);
+		};
+	}
+
+	#notifyToolsChanged(): void {
+		const listeners = [...this.#toolChangeListeners];
+		// Keep live MCPTool instances for reconnect behavior, but never expose the
+		// manager-owned array; callback types make their tool descriptors readonly.
+		const snapshot = this.#onToolsChanged || listeners.length > 0 ? Object.freeze([...this.#tools]) : undefined;
+		if (snapshot && this.#onToolsChanged) {
+			try {
+				this.#onToolsChanged(snapshot);
+			} catch (error) {
+				logger.warn("MCP tool catalog owner callback failed", { error: classifyMCPStartupFailure(error) });
+			}
+		}
+		if (!snapshot) return;
+		for (const listener of listeners) {
+			try {
+				listener(snapshot);
+			} catch (error) {
+				logger.warn("MCP tool catalog listener failed", { error: classifyMCPStartupFailure(error) });
+			}
+		}
+	}
+
 	/**
 	 * Set a callback to fire when any server's resources change.
 	 */
@@ -1107,6 +1184,11 @@ export class MCPManager {
 			nativeOnly: options?.nativeOnly,
 			configPath: options?.configPath,
 		});
+		if (this.#toolCacheServerNames !== undefined) {
+			this.#toolCacheServerNames = new Set(
+				Object.keys(configs).filter(name => sources[name]?.provider !== "gjc-plugins"),
+			);
+		}
 		const result = await this.#connectServers(configs, sources, options?.onConnecting);
 		if (configurationWarning) result.errors.set("$config", "MCP configuration unavailable");
 		result.exaApiKeys = exaApiKeys;
@@ -1362,8 +1444,9 @@ export class MCPManager {
 						this.#exactToolOptions(name, config.sharing === "shared"),
 					);
 					this.#replaceServerTools(name, customTools);
-					if (!this.#toolsOnly) this.#onToolsChanged?.(this.#tools);
-					if (!this.#toolsOnly) void this.toolCache?.set(name, config, serverTools);
+					if (!this.#toolsOnly) this.#notifyToolsChanged();
+					if (!this.#toolsOnly && this.#shouldCacheServerTools(name))
+						void this.toolCache?.set(name, config, serverTools);
 					if (!this.#toolsOnly) await this.#loadServerResourcesAndPrompts(name, connection);
 				})
 				.catch(error => {
@@ -1374,7 +1457,11 @@ export class MCPManager {
 					const message = error instanceof Error ? error.message : String(error);
 					errors.set(name, this.#serverError(message));
 					reportedErrors.add(name);
-					logger.error("MCP tool load failed", { path: `mcp:${name}`, serverName: name, error: message });
+					logger.error("MCP tool load failed", {
+						path: `mcp:${name}`,
+						serverName: name,
+						error: classifyMCPStartupFailure(error),
+					});
 				});
 		}
 
@@ -1430,6 +1517,7 @@ export class MCPManager {
 				if (this.toolCache && !this.#toolsOnly) {
 					await Promise.all(
 						pendingTasks.map(async task => {
+							if (!this.#shouldCacheServerTools(task.name)) return;
 							const cached = await this.toolCache?.get(task.name, task.config);
 							if (cached) {
 								cachedTools.set(task.name, cached);
@@ -1438,51 +1526,55 @@ export class MCPManager {
 					);
 				}
 
-				const pendingWithoutCache = pendingTasks.filter(task => !cachedTools.has(task.name));
-				if (pendingWithoutCache.length > 0) {
-					// The startup wait elapsing means "stop blocking session start", not
-					// "this server failed". A server whose operator declared a `timeout`
-					// (`gjc mcp add --timeout`) asked to wait that long for it, so while it
-					// is still inside that window it keeps connecting in the background
-					// under `connectToServer`'s own timeout, and the background tool load
-					// adopts it. Only a server that declared no window, or already spent it,
-					// is torn down and reported. Exact-config (`toolsOnly`) startup still
-					// fails fast: it builds a catalog once, so a missing server is an error.
-					const startupElapsedMs = Date.now() - startupStartedAt;
-					for (const task of pendingWithoutCache) {
-						if (!this.#toolsOnly && withinDeclaredConnectionWindow(task.config, startupElapsedMs)) {
-							logger.warn("MCP server still connecting after the startup wait", {
-								path: `mcp:${task.name}`,
-								serverName: task.name,
-								startupWaitMs: startupTimeoutMs,
-								declaredTimeoutMs: task.config.timeout,
-							});
-							continue;
-						}
-						const message = `MCP server connection timed out during startup: ${task.name}`;
-						if (!this.#toolsOnly) {
-							logger.warn("MCP server connection timed out during startup", {
-								path: `mcp:${task.name}`,
-								serverName: task.name,
-								startupWaitMs: startupTimeoutMs,
-								declaredTimeoutMs: task.config.timeout,
-								remediation: "Set a per-server timeout with `gjc mcp add --timeout <ms>` for slower servers.",
-							});
-						}
-						errors.set(task.name, this.#serverError(message));
-						reportedErrors.add(task.name);
-						task.connectionAbort.abort(new Error(message));
-						if (this.#pendingConnections.has(task.name)) this.#pendingConnections.delete(task.name);
-						if (this.#pendingToolLoads.get(task.name) === task.toolsPromise)
-							this.#pendingToolLoads.delete(task.name);
-						this.#pendingConnectionControllers.delete(task.name);
-						void this.#disconnectServer(task.name, { preserveConfig: this.#toolsOnly }).catch(error => {
-							this.#logLeaseReleaseFailure(task.name, undefined, error);
+				// Cached tools are only a fallback snapshot; they do not exempt the live
+				// connection from the startup cleanup contract. The startup wait elapsing
+				// means "stop blocking session start", not "this server failed". A server
+				// whose operator declared a `timeout` (`gjc mcp add --timeout`) asked to
+				// wait that long for it, so while it is still inside that window it keeps
+				// connecting in the background under `connectToServer`'s own timeout, and
+				// the background tool load adopts it. Only a server that declared no
+				// window, or already spent it, is torn down and reported. Exact-config
+				// (`toolsOnly`) startup still fails fast: it builds a catalog once, so a
+				// missing server is an error.
+				// Abort and disconnect in the background: a misbehaving stdio/MCP transport can
+				// ignore AbortSignal and keep startup blocked indefinitely, but it must not remain
+				// registered if it eventually connects.
+				const startupElapsedMs = Date.now() - startupStartedAt;
+				for (const task of pendingTasks) {
+					if (task.tracked.status !== "pending") continue;
+					if (!this.#toolsOnly && withinDeclaredConnectionWindow(task.config, startupElapsedMs)) {
+						logger.warn("MCP server still connecting after the startup wait", {
+							path: `mcp:${task.name}`,
+							serverName: task.name,
+							startupWaitMs: startupTimeoutMs,
+							declaredTimeoutMs: task.config.timeout,
+						});
+						continue;
+					}
+					const message = `MCP server connection timed out during startup: ${task.name}`;
+					if (!this.#toolsOnly) {
+						logger.warn("MCP server connection timed out during startup", {
+							path: `mcp:${task.name}`,
+							serverName: task.name,
+							startupWaitMs: startupTimeoutMs,
+							declaredTimeoutMs: task.config.timeout,
+							remediation: "Set a per-server timeout with `gjc mcp add --timeout <ms>` for slower servers.",
 						});
 					}
-					// Abort and disconnect in the background: a misbehaving stdio/MCP transport can
-					// ignore AbortSignal and keep startup blocked indefinitely, but it must not remain
-					// registered if it eventually connects.
+					errors.set(task.name, this.#serverError(message));
+					reportedErrors.add(task.name);
+					task.connectionAbort.abort(new Error(message));
+					if (this.#pendingConnections.has(task.name)) this.#pendingConnections.delete(task.name);
+					if (this.#pendingToolLoads.get(task.name) === task.toolsPromise)
+						this.#pendingToolLoads.delete(task.name);
+					this.#pendingConnectionControllers.delete(task.name);
+					void this.#disconnectServer(task.name, {
+						preserveConfig: this.#toolsOnly || cachedTools.has(task.name),
+						preserveSource: cachedTools.has(task.name),
+						preserveTools: cachedTools.has(task.name),
+					}).catch(error => {
+						this.#logLeaseReleaseFailure(task.name, undefined, error);
+					});
 				}
 			}
 
@@ -1524,7 +1616,7 @@ export class MCPManager {
 						logger.warn("MCP server connection failed during startup", {
 							path: `mcp:${name}`,
 							serverName: name,
-							error: message,
+							error: classifyMCPStartupFailure(reason),
 							remediation:
 								"Check the server command and set --timeout <ms> when startup is expected to be slow.",
 						});
@@ -1573,7 +1665,10 @@ export class MCPManager {
 		}
 
 		// Update cached tools
-		if (shouldPublishToolSnapshot) this.#publishToolCatalog(allTools);
+		if (shouldPublishToolSnapshot) {
+			this.#publishToolCatalog(allTools);
+			this.#notifyToolsChanged();
+		}
 		allowBackgroundLogging = true;
 
 		return {
@@ -2386,7 +2481,10 @@ export class MCPManager {
 		await this.#disconnectServer(name);
 	}
 
-	async #disconnectServer(name: string, options: { preserveConfig?: boolean } = {}): Promise<void> {
+	async #disconnectServer(
+		name: string,
+		options: { preserveConfig?: boolean; preserveSource?: boolean; preserveTools?: boolean } = {},
+	): Promise<void> {
 		const nextEpoch = (this.#disconnectEpochs.get(name) ?? 0) + 1;
 		this.#disconnectEpochs.set(name, nextEpoch);
 		this.#pendingConnectionControllers.get(name)?.abort(new Error(`MCP server disconnected: ${name}`));
@@ -2396,7 +2494,7 @@ export class MCPManager {
 		this.#pendingConnections.delete(name);
 		this.#pendingToolLoads.delete(name);
 		this.#pendingReconnections.delete(name);
-		this.#sources.delete(name);
+		if (!options.preserveSource) this.#sources.delete(name);
 		if (!options.preserveConfig) this.#serverConfigs.delete(name);
 		this.#pendingResourceRefresh.delete(name);
 		const connection = this.#connections.get(name);
@@ -2426,18 +2524,20 @@ export class MCPManager {
 			if (this.#connections.get(name) === connection) this.#connections.delete(name);
 		}
 
-		// Remove tools from this server and notify consumers
-		const hadTools = this.#tools.some(
-			tool => (tool instanceof MCPTool || tool instanceof DeferredMCPTool) && tool.mcpServerName === name,
-		);
-		const remainingTools = this.#tools.filter(
-			tool => !((tool instanceof MCPTool || tool instanceof DeferredMCPTool) && tool.mcpServerName === name),
-		);
-		if (hadTools) {
-			this.#publishToolCatalog(remainingTools);
-			this.#onToolsChanged?.(this.#tools);
-		} else {
-			this.#tools = remainingTools;
+		// Keep a published cache fallback available while its expired live connection closes.
+		if (!options.preserveTools) {
+			const hadTools = this.#tools.some(
+				tool => (tool instanceof MCPTool || tool instanceof DeferredMCPTool) && tool.mcpServerName === name,
+			);
+			const remainingTools = this.#tools.filter(
+				tool => !((tool instanceof MCPTool || tool instanceof DeferredMCPTool) && tool.mcpServerName === name),
+			);
+			if (hadTools) {
+				this.#publishToolCatalog(remainingTools);
+				this.#notifyToolsChanged();
+			} else {
+				this.#tools = remainingTools;
+			}
 		}
 
 		// Notify prompt consumers so stale commands are cleared
@@ -2545,7 +2645,9 @@ export class MCPManager {
 			this.#pendingExactSuspensions.clear();
 			this.#pendingExactControlServers.clear();
 			this.#connections.clear();
+			const hadTools = this.#tools.length > 0;
 			this.#publishToolCatalog([]);
+			if (hadTools) this.#notifyToolsChanged();
 			this.#subscribedResources.clear();
 			const releaseFailures = [
 				...scopedReleaseFailures,
@@ -2835,9 +2937,9 @@ export class MCPManager {
 				reconnect,
 				this.#exactToolOptions(name, config.sharing === "shared"),
 			);
-			void this.toolCache?.set(name, config, serverTools);
+			if (this.#shouldCacheServerTools(name)) void this.toolCache?.set(name, config, serverTools);
 			this.#replaceServerTools(name, customTools);
-			this.#onToolsChanged?.(this.#tools);
+			this.#notifyToolsChanged();
 			void this.#loadServerResourcesAndPrompts(name, connection);
 			return connection;
 		} catch (error) {
@@ -2905,11 +3007,11 @@ export class MCPManager {
 			reconnect,
 			this.#exactToolOptions(name, connection.config.sharing === "shared"),
 		);
-		void this.toolCache?.set(name, connection.config, serverTools);
+		if (this.#shouldCacheServerTools(name)) void this.toolCache?.set(name, connection.config, serverTools);
 
 		// Replace tools from this server
 		this.#replaceServerTools(name, customTools);
-		this.#onToolsChanged?.(this.#tools);
+		this.#notifyToolsChanged();
 	}
 
 	/**