oh-my-opencode 5.0.0-beta.3 → 5.0.0-beta.31

package/packages/lsp-core/src/lsp/manager-lifecycle.test.ts

@@ -0,0 +1,262 @@
+import { describe, expect, it } from "bun:test";
+
+import type { LspClient } from "./client.js";
+import { LspManager } from "./manager.js";
+import type { ResolvedServer } from "./types.js";
+
+const SERVER: ResolvedServer = {
+	id: "typescript",
+	command: ["typescript-language-server", "--stdio"],
+	extensions: [".ts"],
+	priority: 1,
+};
+
+/** Simulates a stop that lingers (production stops reach ~21s), which is the behavior under test. */
+const SLOW_STOP_MS = 50;
+
+interface RecordingClientOptions {
+	readonly stopDelayMs: number;
+	readonly initializeError?: Error;
+	readonly alive: boolean;
+}
+
+class RecordingFakeClient {
+	alive: boolean;
+	stopCallCount = 0;
+
+	constructor(
+		readonly root: string,
+		private readonly log: EventLog,
+		private readonly options: RecordingClientOptions,
+	) {
+		this.alive = options.alive;
+	}
+
+	async start(): Promise<void> {
+		this.log.push(`spawn:${this.root}`);
+	}
+
+	async initialize(): Promise<void> {
+		if (this.options.initializeError !== undefined) {
+			throw this.options.initializeError;
+		}
+	}
+
+	isAlive(): boolean {
+		return this.alive;
+	}
+
+	command(): string[] {
+		return [...SERVER.command];
+	}
+
+	async stop(): Promise<void> {
+		this.stopCallCount += 1;
+		this.log.push(`stop-start:${this.root}`);
+		await delay(this.options.stopDelayMs);
+		this.alive = false;
+		this.log.push(`stop-end:${this.root}`);
+	}
+}
+
+class EventLog {
+	readonly entries: string[] = [];
+	private waiters: Array<{ readonly event: string; readonly resolve: () => void }> = [];
+
+	push(event: string): void {
+		this.entries.push(event);
+		const due = this.waiters.filter((waiter) => waiter.event === event);
+		if (due.length === 0) return;
+		this.waiters = this.waiters.filter((waiter) => waiter.event !== event);
+		for (const waiter of due) waiter.resolve();
+	}
+
+	waitFor(event: string): Promise<void> {
+		if (this.entries.includes(event)) return Promise.resolve();
+		return new Promise<void>((resolve) => {
+			this.waiters.push({ event, resolve });
+		});
+	}
+}
+
+function delay(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+interface HarnessOptions {
+	readonly maxResidentClients?: number;
+	readonly stopDelayMs?: number;
+	/** Leading generations whose initialize() rejects; later generations start cleanly. */
+	readonly initializeFailures?: number;
+	/** Generations at or above this index report alive; earlier ones emulate a crash-looping server. */
+	readonly aliveFromGeneration?: number;
+}
+
+function managerHarness(options: HarnessOptions = {}): {
+	readonly manager: LspManager;
+	readonly clients: RecordingFakeClient[];
+	readonly log: EventLog;
+	readonly clock: { value: number };
+} {
+	const clients: RecordingFakeClient[] = [];
+	const log = new EventLog();
+	const clock = { value: 1_000 };
+	const generations = new Map<string, number>();
+	const aliveFrom = options.aliveFromGeneration ?? 1;
+	const stopDelayMs = options.stopDelayMs ?? 0;
+	const initializeFailures = options.initializeFailures ?? 0;
+	const manager = new LspManager({
+		maxResidentClients: options.maxResidentClients ?? 6,
+		reaperIntervalMs: 60_000,
+		idleTimeoutMs: 60_000_000,
+		now: () => clock.value,
+		clientFactory: (root) => {
+			const generation = (generations.get(root) ?? 0) + 1;
+			generations.set(root, generation);
+			const client = new RecordingFakeClient(root, log, {
+				stopDelayMs,
+				alive: generation >= aliveFrom,
+				...(generation <= initializeFailures ? { initializeError: new Error("initialize boom") } : {}),
+			});
+			clients.push(client);
+			return client as unknown as LspClient;
+		},
+	});
+	return { manager, clients, log, clock };
+}
+
+describe("LspManager pending-stop tombstones", () => {
+	it("#given a slow-stopping client evicted at the resident cap #when the evicted root is re-acquired while the stop is pending #then the replacement spawns only after the old client stopped", async () => {
+		// given
+		const { manager, log } = managerHarness({ maxResidentClients: 1, stopDelayMs: SLOW_STOP_MS });
+		try {
+			await manager.getClient("/root-a", SERVER);
+			manager.releaseClient("/root-a", SERVER.id);
+
+			// when: admitting root-b synchronously evicts idle root-a (void stop), and root-a is
+			// re-acquired in the same window while the evicted client's stop is still pending.
+			const rootBPromise = manager.getClient("/root-b", SERVER);
+			const rootAPromise = manager.getClient("/root-a", SERVER);
+			await Promise.all([rootBPromise, rootAPromise]);
+			manager.releaseClient("/root-b", SERVER.id);
+			manager.releaseClient("/root-a", SERVER.id);
+
+			// then
+			expect(log.entries.filter((event) => event.endsWith("/root-a"))).toEqual([
+				"spawn:/root-a",
+				"stop-start:/root-a",
+				"stop-end:/root-a",
+				"spawn:/root-a",
+			]);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given an invalidated client whose stop is still pending #when the same root is re-acquired #then the replacement spawns only after the invalidated client stopped", async () => {
+		// given
+		const { manager, log } = managerHarness({ stopDelayMs: SLOW_STOP_MS });
+		try {
+			await manager.getClient("/root-a", SERVER);
+			manager.releaseClient("/root-a", SERVER.id);
+
+			// when
+			manager.invalidateClient("/root-a", SERVER.id);
+			await manager.getClient("/root-a", SERVER);
+
+			// then
+			expect(log.entries).toEqual([
+				"spawn:/root-a",
+				"stop-start:/root-a",
+				"stop-end:/root-a",
+				"spawn:/root-a",
+			]);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given a client whose initialization failed while its stop is pending #when another getClient races the stop #then the replacement spawns only after the failed client stopped", async () => {
+		// given
+		const { manager, log } = managerHarness({
+			stopDelayMs: SLOW_STOP_MS,
+			initializeFailures: 1,
+		});
+		try {
+			const failing = manager.getClient("/root-fail", SERVER);
+
+			// when: the second acquisition starts once the first one's stop is provably in flight.
+			await log.waitFor("stop-start:/root-fail");
+			const racing = manager.getClient("/root-fail", SERVER);
+			await expect(failing).rejects.toThrow("initialize boom");
+			await racing;
+			manager.releaseClient("/root-fail", SERVER.id);
+
+			// then
+			expect(log.entries).toEqual([
+				"spawn:/root-fail",
+				"stop-start:/root-fail",
+				"stop-end:/root-fail",
+				"spawn:/root-fail",
+			]);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});
+
+describe("LspManager dead-client respawn budget", () => {
+	it("#given a crash-looping client that is dead on every acquisition #when getClient is called repeatedly #then respawn attempts stay within the retry budget", async () => {
+		// given
+		const { manager, clients } = managerHarness({ aliveFromGeneration: Number.POSITIVE_INFINITY });
+		try {
+			// when
+			for (let attempt = 0; attempt < 8; attempt += 1) {
+				await manager
+					.getClient("/root-crash", SERVER)
+					.then(
+						() => manager.releaseClient("/root-crash", SERVER.id),
+						() => undefined,
+					);
+			}
+
+			// then: one initial generation plus at most two budgeted respawns.
+			expect(clients.length).toBeLessThanOrEqual(3);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given the respawn budget is exhausted #when getClient is called again #then it rejects with a budget error instead of respawning", async () => {
+		// given
+		const { manager } = managerHarness({ aliveFromGeneration: Number.POSITIVE_INFINITY });
+		try {
+			await expect(manager.getClient("/root-crash", SERVER)).rejects.toThrow(/respawn budget/);
+
+			// when / then
+			await expect(manager.getClient("/root-crash", SERVER)).rejects.toThrow(/respawn budget/);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given the budget was exhausted but the cooldown elapsed and the server recovered #when getClient is called #then it spawns again and resets the budget on a healthy generation", async () => {
+		// given: generations one and two crash, the third is healthy.
+		const { manager, clients, clock } = managerHarness({ aliveFromGeneration: 3 });
+		try {
+			await expect(manager.getClient("/root-crash", SERVER)).rejects.toThrow(/respawn budget/);
+
+			// when: cooldown elapses (60s default) and the server stays alive again.
+			clock.value += 60_001;
+			const recovered = await manager.getClient("/root-crash", SERVER);
+			manager.releaseClient("/root-crash", SERVER.id);
+
+			// then
+			expect(clients.length).toBe(3);
+			await expect(manager.getClient("/root-crash", SERVER)).resolves.toBe(recovered);
+			manager.releaseClient("/root-crash", SERVER.id);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});

package/packages/lsp-core/src/lsp/manager-max-clients.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it } from "bun:test";
+
+import type { LspClient } from "./client.js";
+import { LspManager } from "./manager.js";
+import type { ResolvedServer } from "./types.js";
+
+const SERVER: ResolvedServer = {
+	id: "typescript",
+	command: ["typescript-language-server", "--stdio"],
+	extensions: [".ts"],
+	priority: 1,
+};
+
+class FakeLspClient {
+	alive = true;
+	stopCallCount = 0;
+
+	constructor(readonly root: string) {}
+
+	async start(): Promise<void> {}
+
+	async initialize(): Promise<void> {}
+
+	isAlive(): boolean {
+		return this.alive;
+	}
+
+	command(): string[] {
+		return [...SERVER.command];
+	}
+
+	async stop(): Promise<void> {
+		this.stopCallCount += 1;
+		this.alive = false;
+	}
+}
+
+function managerWithFakes(maxResidentClients: number): {
+	readonly manager: LspManager;
+	readonly clients: Map<string, FakeLspClient>;
+	readonly clock: { value: number };
+} {
+	const clients = new Map<string, FakeLspClient>();
+	const clock = { value: 1_000 };
+	const manager = new LspManager({
+		maxResidentClients,
+		reaperIntervalMs: 60_000,
+		idleTimeoutMs: 60_000_000,
+		now: () => clock.value,
+		clientFactory: (root) => {
+			const client = new FakeLspClient(root);
+			clients.set(root, client);
+			return client as unknown as LspClient;
+		},
+	});
+	return { manager, clients, clock };
+}
+
+describe("LspManager resident client cap", () => {
+	it("#given a cap of two idle clients #when a third client is admitted #then the least recently used one is stopped and evicted", async () => {
+		// given
+		const { manager, clients, clock } = managerWithFakes(2);
+		try {
+			await manager.getClient("/root-a", SERVER);
+			manager.releaseClient("/root-a", SERVER.id);
+			clock.value += 10;
+			await manager.getClient("/root-b", SERVER);
+			manager.releaseClient("/root-b", SERVER.id);
+			clock.value += 10;
+
+			// when
+			await manager.getClient("/root-c", SERVER);
+			manager.releaseClient("/root-c", SERVER.id);
+
+			// then
+			expect(manager.clientCount()).toBe(2);
+			expect(manager.hasClient("/root-a", SERVER.id)).toBe(false);
+			expect(manager.hasClient("/root-b", SERVER.id)).toBe(true);
+			expect(manager.hasClient("/root-c", SERVER.id)).toBe(true);
+			expect(clients.get("/root-a")?.stopCallCount).toBe(1);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+
+	it("#given the least recently used client is mid-request #when a new client is admitted #then the busy client survives and an idle one is evicted", async () => {
+		// given
+		const { manager, clients, clock } = managerWithFakes(2);
+		try {
+			await manager.getClient("/root-busy", SERVER);
+			clock.value += 10;
+			await manager.getClient("/root-idle", SERVER);
+			manager.releaseClient("/root-idle", SERVER.id);
+			clock.value += 10;
+
+			// when
+			await manager.getClient("/root-new", SERVER);
+			manager.releaseClient("/root-new", SERVER.id);
+
+			// then
+			expect(manager.hasClient("/root-busy", SERVER.id)).toBe(true);
+			expect(manager.hasClient("/root-idle", SERVER.id)).toBe(false);
+			expect(clients.get("/root-busy")?.stopCallCount).toBe(0);
+			expect(clients.get("/root-idle")?.stopCallCount).toBe(1);
+		} finally {
+			manager.releaseClient("/root-busy", SERVER.id);
+			await manager.stopAll();
+		}
+	});
+
+	it("#given every resident client is busy #when a new client is admitted #then nothing is evicted and the cap is exceeded rather than breaking a live request", async () => {
+		// given
+		const { manager, clients } = managerWithFakes(1);
+		try {
+			await manager.getClient("/root-busy", SERVER);
+
+			// when
+			await manager.getClient("/root-second", SERVER);
+
+			// then
+			expect(manager.clientCount()).toBe(2);
+			expect(clients.get("/root-busy")?.stopCallCount).toBe(0);
+		} finally {
+			manager.releaseClient("/root-busy", SERVER.id);
+			manager.releaseClient("/root-second", SERVER.id);
+			await manager.stopAll();
+		}
+	});
+
+	it("#given warmup requests beyond the cap #when a warm client is admitted #then the idle least recently used client is evicted too", async () => {
+		// given
+		const { manager, clients, clock } = managerWithFakes(1);
+		try {
+			await manager.getClient("/root-first", SERVER);
+			manager.releaseClient("/root-first", SERVER.id);
+			clock.value += 10;
+
+			// when
+			manager.warmupClient("/root-warm", SERVER);
+			await Promise.resolve();
+			await Promise.resolve();
+
+			// then
+			expect(manager.hasClient("/root-first", SERVER.id)).toBe(false);
+			expect(clients.get("/root-first")?.stopCallCount).toBe(1);
+			expect(manager.hasClient("/root-warm", SERVER.id)).toBe(true);
+		} finally {
+			await manager.stopAll();
+		}
+	});
+});

package/packages/lsp-core/src/lsp/manager.ts

@@ -1,6 +1,14 @@
 import { reportBestEffortCleanupError } from "./cleanup-errors.js";
 import { LspClient } from "./client.js";
-import { IDLE_TIMEOUT_MS, INIT_TIMEOUT_MS, REAPER_INTERVAL_MS } from "./constants.js";
+import {
+	CLIENT_RESPAWN_COOLDOWN_MS,
+	CLIENT_RESPAWN_RETRY_LIMIT,
+	IDLE_TIMEOUT_MS,
+	INIT_TIMEOUT_MS,
+	MAX_RESIDENT_CLIENTS,
+	REAPER_INTERVAL_MS,
+} from "./constants.js";
+import { LspClientRespawnBudgetExceededError } from "./errors.js";
 import { installProcessSignalCleanup } from "./process-signal-cleanup.js";
 import type { ResolvedServer } from "./types.js";
 
@@ -14,6 +22,11 @@ interface ManagedClient {
 	initializingSince: number | null;
 }
 
+interface RespawnBudget {
+	deadGenerations: number;
+	exhaustedAt: number | null;
+}
+
 export interface ClientSnapshot {
 	root: string;
 	serverId: string;
@@ -28,6 +41,7 @@ export interface ClientSnapshot {
 export interface LspManagerOptions {
 	idleTimeoutMs?: number;
 	initTimeoutMs?: number;
+	maxResidentClients?: number;
 	reaperIntervalMs?: number;
 	clientFactory?: (root: string, server: ResolvedServer) => LspClient;
 	now?: () => number;
@@ -74,12 +88,16 @@ function awaitWithSignal<T>(promise: Promise<T>, signal: AbortSignal | undefined
 
 export class LspManager {
 	private readonly clients = new Map<string, ManagedClient>();
+	/** In-flight stops per key; getClient awaits these instead of spawning a duplicate client. */
+	private readonly pendingStops = new Map<string, Promise<void>>();
+	private readonly respawnBudgets = new Map<string, RespawnBudget>();
 	private reaperHandle: NodeJS.Timeout | null = null;
 	private signalDisposer: (() => void) | null = null;
 	private disposed = false;
 
 	private readonly idleTimeoutMs: number;
 	private readonly initTimeoutMs: number;
+	private readonly maxResidentClients: number;
 	private readonly reaperIntervalMs: number;
 	private readonly clientFactory: (root: string, server: ResolvedServer) => LspClient;
 	private readonly now: () => number;
@@ -87,6 +105,7 @@ export class LspManager {
 	constructor(options: LspManagerOptions = {}) {
 		this.idleTimeoutMs = options.idleTimeoutMs ?? IDLE_TIMEOUT_MS;
 		this.initTimeoutMs = options.initTimeoutMs ?? INIT_TIMEOUT_MS;
+		this.maxResidentClients = options.maxResidentClients ?? MAX_RESIDENT_CLIENTS;
 		this.reaperIntervalMs = options.reaperIntervalMs ?? REAPER_INTERVAL_MS;
 		this.clientFactory = options.clientFactory ?? ((root, server) => new LspClient(root, server));
 		this.now = options.now ?? (() => Date.now());
@@ -109,6 +128,50 @@ export class LspManager {
 		return `${root}::${serverId}`;
 	}
 
+	/**
+	 * Deletes-then-stops with a tombstone: the pending stop is recorded so a concurrent getClient
+	 * for the same key awaits it instead of spawning a duplicate client while the old one lingers
+	 * (production stops reach ~21s). The tombstone removes itself once the stop settles.
+	 */
+	private tombstoneStop(key: string, client: LspClient): Promise<void> {
+		const stop = stopClientBestEffort(client);
+		this.pendingStops.set(key, stop);
+		void stop.finally(() => {
+			if (this.pendingStops.get(key) === stop) {
+				this.pendingStops.delete(key);
+			}
+		});
+		return stop;
+	}
+
+	private recordDeadGeneration(key: string): void {
+		let budget = this.respawnBudgets.get(key);
+		if (budget === undefined) {
+			budget = { deadGenerations: 0, exhaustedAt: null };
+			this.respawnBudgets.set(key, budget);
+		}
+		budget.deadGenerations += 1;
+	}
+
+	private markHealthyGeneration(key: string): void {
+		this.respawnBudgets.delete(key);
+	}
+
+	/** Throws while the respawn budget is spent and the cooldown has not elapsed. */
+	private ensureRespawnAllowed(key: string, root: string, serverId: string): void {
+		const budget = this.respawnBudgets.get(key);
+		if (budget === undefined || budget.deadGenerations < CLIENT_RESPAWN_RETRY_LIMIT) return;
+		if (budget.exhaustedAt === null) {
+			budget.exhaustedAt = this.now();
+			throw new LspClientRespawnBudgetExceededError(serverId, root, CLIENT_RESPAWN_RETRY_LIMIT);
+		}
+		if (this.now() - budget.exhaustedAt < CLIENT_RESPAWN_COOLDOWN_MS) {
+			throw new LspClientRespawnBudgetExceededError(serverId, root, CLIENT_RESPAWN_RETRY_LIMIT);
+		}
+		budget.deadGenerations = 0;
+		budget.exhaustedAt = null;
+	}
+
 	private reapStale(): void {
 		const t = this.now();
 		for (const [key, managed] of this.clients) {
@@ -117,8 +180,8 @@ export class LspManager {
 				managed.initializingSince !== null &&
 				t - managed.initializingSince > this.initTimeoutMs
 			) {
-				void stopClientBestEffort(managed.client);
 				this.clients.delete(key);
+				void this.tombstoneStop(key, managed.client);
 				continue;
 			}
 
@@ -128,12 +191,38 @@ export class LspManager {
 				managed.pendingWaiters === 0 &&
 				t - managed.lastUsedAt > this.idleTimeoutMs
 			) {
-				void stopClientBestEffort(managed.client);
 				this.clients.delete(key);
+				void this.tombstoneStop(key, managed.client);
 			}
 		}
 	}
 
+	/**
+	 * Frees capacity for one new client by stopping the least recently used idle client.
+	 *
+	 * Only clients with no in-flight work are eligible, so a resident server is never torn down
+	 * underneath a live request; when every resident client is busy the cap is exceeded instead.
+	 */
+	private evictForAdmission(): void {
+		while (this.clients.size >= this.maxResidentClients) {
+			const victim = this.leastRecentlyUsedIdleClient();
+			if (!victim) return;
+			this.clients.delete(victim.key);
+			void this.tombstoneStop(victim.key, victim.managed.client);
+		}
+	}
+
+	private leastRecentlyUsedIdleClient(): { readonly key: string; readonly managed: ManagedClient } | null {
+		let candidate: { readonly key: string; readonly managed: ManagedClient } | null = null;
+		for (const [key, managed] of this.clients) {
+			if (managed.refCount > 0 || managed.pendingWaiters > 0 || managed.isInitializing) continue;
+			if (candidate === null || managed.lastUsedAt < candidate.managed.lastUsedAt) {
+				candidate = { key, managed };
+			}
+		}
+		return candidate;
+	}
+
 	private async tryDeleteIfOrphaned(key: string, managed: ManagedClient): Promise<void> {
 		if (
 			managed.refCount === 0 &&
@@ -142,7 +231,7 @@ export class LspManager {
 			this.clients.get(key) === managed
 		) {
 			this.clients.delete(key);
-			await stopClientBestEffort(managed.client);
+			await this.tombstoneStop(key, managed.client);
 		}
 	}
 
@@ -153,6 +242,16 @@ export class LspManager {
 		signal?.throwIfAborted();
 
 		const key = this.getKey(root, server.id);
+		for (;;) {
+			const pendingStop = this.pendingStops.get(key);
+			if (pendingStop === undefined) break;
+			await awaitWithSignal(pendingStop, signal);
+			signal?.throwIfAborted();
+		}
+		if (this.disposed) {
+			throw new Error("LspManager has been disposed");
+		}
+
 		let managed = this.clients.get(key);
 
 		if (managed) {
@@ -162,8 +261,8 @@ export class LspManager {
 				managed.initializingSince !== null &&
 				t - managed.initializingSince > this.initTimeoutMs
 			) {
-				await stopClientBestEffort(managed.client);
 				this.clients.delete(key);
+				await this.tombstoneStop(key, managed.client);
 				managed = undefined;
 			}
 		}
@@ -187,16 +286,23 @@ export class LspManager {
 			}
 
 			if (!managed.client.isAlive()) {
-				await stopClientBestEffort(managed.client);
-				this.clients.delete(key);
+				this.recordDeadGeneration(key);
+				if (this.clients.get(key) === managed) {
+					this.clients.delete(key);
+				}
+				await this.tombstoneStop(key, managed.client);
 				return this.getClient(root, server, signal);
 			}
 
+			this.markHealthyGeneration(key);
 			managed.refCount++;
 			managed.lastUsedAt = this.now();
 			return managed.client;
 		}
 
+		this.evictForAdmission();
+		this.ensureRespawnAllowed(key, root, server.id);
+
 		const client = this.clientFactory(root, server);
 		const initStartedAt = this.now();
 		const initPromise = (async () => {
@@ -222,7 +328,7 @@ export class LspManager {
 			if (this.clients.get(key) === newManaged) {
 				this.clients.delete(key);
 			}
-			await stopClientBestEffort(client);
+			await this.tombstoneStop(key, client);
 			throw err;
 		}
 
@@ -236,6 +342,16 @@ export class LspManager {
 			signal.throwIfAborted();
 		}
 
+		if (!client.isAlive()) {
+			this.recordDeadGeneration(key);
+			if (this.clients.get(key) === newManaged) {
+				this.clients.delete(key);
+			}
+			await this.tombstoneStop(key, client);
+			return this.getClient(root, server, signal);
+		}
+
+		this.markHealthyGeneration(key);
 		newManaged.refCount++;
 		newManaged.lastUsedAt = this.now();
 		return client;
@@ -256,13 +372,20 @@ export class LspManager {
 		if (!managed) return;
 		if (client && managed.client !== client) return;
 		this.clients.delete(key);
-		void stopClientBestEffort(managed.client);
+		void this.tombstoneStop(key, managed.client);
 	}
 
 	warmupClient(root: string, server: ResolvedServer): void {
 		if (this.disposed) return;
 		const key = this.getKey(root, server.id);
-		if (this.clients.has(key)) return;
+		if (this.clients.has(key) || this.pendingStops.has(key)) return;
+
+		this.evictForAdmission();
+		try {
+			this.ensureRespawnAllowed(key, root, server.id);
+		} catch {
+			return;
+		}
 
 		const client = this.clientFactory(root, server);
 		const initStartedAt = this.now();
@@ -293,7 +416,7 @@ export class LspManager {
 				if (this.clients.get(key) === managed) {
 					this.clients.delete(key);
 				}
-				void stopClientBestEffort(client);
+				void this.tombstoneStop(key, client);
 			},
 		);
 	}
@@ -346,8 +469,11 @@ export class LspManager {
 		for (const managed of this.clients.values()) {
 			stopPromises.push(stopClientBestEffort(managed.client));
 		}
+		const tombstonedStops = [...this.pendingStops.values()];
 		this.clients.clear();
-		await Promise.allSettled(stopPromises);
+		this.respawnBudgets.clear();
+		await Promise.allSettled([...stopPromises, ...tombstonedStops]);
+		this.pendingStops.clear();
 	}
 }