@gajae-code/coding-agent 0.11.0 → 0.11.1

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

@@ -916,22 +916,15 @@ export class CommandController {
 		}
 	}
 
-	async #runNewSessionFlow(options?: NewSessionOptions, label: string = "New session started"): Promise<void> {
+	async #runNewSessionFlow(options?: NewSessionOptions, label: string = "New session started"): Promise<boolean> {
+		if (!(await this.ctx.session.newSession(options))) return false;
+
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();
 			this.ctx.loadingAnimation = undefined;
 		}
 		this.ctx.statusContainer.clear();
-
-		if (this.ctx.session.isCompacting) {
-			this.ctx.session.abortCompaction();
-			while (this.ctx.session.isCompacting) {
-				await Bun.sleep(10);
-			}
-		}
-		if (!(await this.ctx.session.newSession(options))) return;
 		this.ctx.resetIrcSidebarSession();
-
 		this.ctx.resetObserverRegistry();
 		setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
 
@@ -952,10 +945,11 @@ export class CommandController {
 		this.ctx.chatContainer.addChild(new Text(`${theme.fg("accent", `${theme.status.success} ${label}`)}`, 1, 0));
 		await this.ctx.reloadTodos();
 		this.ctx.ui.requestRender();
+		return true;
 	}
 
-	async handleClearCommand(): Promise<void> {
-		await this.#runNewSessionFlow();
+	async handleClearCommand(): Promise<boolean> {
+		return this.#runNewSessionFlow();
 	}
 
 	async handleContextClearCommand(): Promise<void> {
@@ -995,12 +989,12 @@ export class CommandController {
 		this.ctx.ui.requestRender();
 	}
 
-	async handleDropCommand(): Promise<void> {
+	async handleDropCommand(): Promise<boolean> {
 		if (!this.ctx.sessionManager.getSessionFile()) {
 			this.ctx.showError("Nothing to drop (in-memory session)");
-			return;
+			return false;
 		}
-		await this.#runNewSessionFlow({ drop: true }, "Session dropped");
+		return this.#runNewSessionFlow({ drop: true }, "Session dropped");
 	}
 
 	async handleForkCommand(): Promise<void> {

package/src/modes/controllers/extension-ui-controller.ts

@@ -53,6 +53,40 @@ export class ExtensionUiController {
 		overlay?.hide();
 	}
 
+	captureSessionUiCleanup(): () => void {
+		const terminalInputUnsubscribers = [...this.#extensionTerminalInputUnsubscribers];
+		const widgetsAbove = [...this.#hookWidgetsAbove.entries()];
+		const widgetsBelow = [...this.#hookWidgetsBelow.entries()];
+		const activeHookCustomComponent = this.#activeHookCustomComponent;
+		const activeHookCustomOverlay = this.#activeHookCustomOverlay;
+		return () => {
+			for (const unsubscribe of terminalInputUnsubscribers) {
+				unsubscribe();
+				this.#extensionTerminalInputUnsubscribers.delete(unsubscribe);
+			}
+			let widgetsChanged = false;
+			for (const [key, widget] of widgetsAbove) {
+				if (this.#hookWidgetsAbove.get(key) !== widget) continue;
+				this.#hookWidgetsAbove.delete(key);
+				widget.dispose?.();
+				widgetsChanged = true;
+			}
+			for (const [key, widget] of widgetsBelow) {
+				if (this.#hookWidgetsBelow.get(key) !== widget) continue;
+				this.#hookWidgetsBelow.delete(key);
+				widget.dispose?.();
+				widgetsChanged = true;
+			}
+			if (
+				this.#activeHookCustomComponent === activeHookCustomComponent &&
+				this.#activeHookCustomOverlay === activeHookCustomOverlay
+			) {
+				this.#clearActiveHookCustom();
+			}
+			if (widgetsChanged) this.#rebuildHookWidgets();
+		};
+	}
+
 	#sdkControl = async (operation: string, input: Record<string, unknown>): Promise<unknown> => {
 		const session = this.ctx.session;
 		switch (operation) {
@@ -414,36 +448,30 @@ export class ExtensionUiController {
 				this.ctx.showStatus("Reloaded session");
 			},
 			newSession: async options => {
-				// Stop any loading animation
+				const cleanupPreviousSessionUi = this.captureSessionUiCleanup();
+				const success = await this.ctx.session.newSession({ parentSession: options?.parentSession });
+				if (!success) {
+					return { cancelled: true };
+				}
+				cleanupPreviousSessionUi();
+
 				if (this.ctx.loadingAnimation) {
 					this.ctx.loadingAnimation.stop();
 					this.ctx.loadingAnimation = undefined;
 				}
 				this.ctx.statusContainer.clear();
-
-				// Create new session
-				this.clearExtensionTerminalInputListeners();
-				this.clearHookWidgets();
-				const success = await this.ctx.session.newSession({ parentSession: options?.parentSession });
-				if (!success) {
-					return { cancelled: true };
-				}
 				this.ctx.resetIrcSidebarSession();
-
 				setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
 
-				// Call setup callback if provided
 				if (options?.setup) {
 					await options.setup(this.ctx.sessionManager);
 				}
 
-				// Reset and update status line
 				this.ctx.statusLine.invalidate();
 				this.ctx.statusLine.setSessionStartTime(Date.now());
 				this.ctx.updateEditorTopBorder();
 				this.ctx.ui.requestRender();
 
-				// Clear UI state
 				prepareTranscriptRebuild(this.ctx.ui, "replace-identity");
 				this.ctx.chatContainer.clear();
 				this.ctx.pendingMessagesContainer.clear();
@@ -717,28 +745,24 @@ export class ExtensionUiController {
 				if (this.ctx.isBackgrounded) {
 					return { cancelled: true };
 				}
-				// Stop any loading animation
+				const cleanupPreviousSessionUi = this.captureSessionUiCleanup();
+				const success = await this.ctx.session.newSession({ parentSession: options?.parentSession });
+				if (!success) {
+					return { cancelled: true };
+				}
+				cleanupPreviousSessionUi();
+
 				if (this.ctx.loadingAnimation) {
 					this.ctx.loadingAnimation.stop();
 					this.ctx.loadingAnimation = undefined;
 				}
 				this.ctx.statusContainer.clear();
-
-				// Create new session
-				this.clearExtensionTerminalInputListeners();
-				this.clearHookWidgets();
-				const success = await this.ctx.session.newSession({ parentSession: options?.parentSession });
-				if (!success) {
-					return { cancelled: true };
-				}
 				this.ctx.resetIrcSidebarSession();
 
-				// Call setup callback if provided
 				if (options?.setup) {
 					await options.setup(this.ctx.sessionManager);
 				}
 
-				// Clear UI state
 				prepareTranscriptRebuild(this.ctx.ui, "replace-identity");
 				this.ctx.chatContainer.clear();
 				this.ctx.pendingMessagesContainer.clear();

package/src/modes/interactive-mode.ts

@@ -1820,19 +1820,22 @@ export class InteractiveMode implements InteractiveModeContext {
 		if (options.compactBeforeExecute) {
 			this.session.markPlanCompactAbortPending();
 		}
+		let sessionSwitchCompleted = true;
 		let compactOutcome: CompactionOutcome | undefined;
 		try {
 			await this.#exitPlanMode({ silent: true, paused: false });
 
 			if (!options.preserveContext) {
-				await this.handleClearCommand();
-				// The new session has a fresh local:// root — persist the approved plan there
-				// so `local://<title>.md` resolves correctly in the execution session.
-				const newLocalPath = resolveLocalUrlToPath(options.finalPlanFilePath, {
-					getArtifactsDir: () => this.sessionManager.getArtifactsDir(),
-					getSessionId: () => this.sessionManager.getSessionId(),
-				});
-				await Bun.write(newLocalPath, planContent);
+				sessionSwitchCompleted = await this.handleClearCommand();
+				if (sessionSwitchCompleted) {
+					// The new session has a fresh local:// root — persist the approved plan there
+					// so `local://<title>.md` resolves correctly in the execution session.
+					const newLocalPath = resolveLocalUrlToPath(options.finalPlanFilePath, {
+						getArtifactsDir: () => this.sessionManager.getArtifactsDir(),
+						getSessionId: () => this.sessionManager.getSessionId(),
+					});
+					await Bun.write(newLocalPath, planContent);
+				}
 			} else if (options.compactBeforeExecute) {
 				// Distill the plan-mode transcript before the execution turn is queued so
 				// the plan-approved synthetic prompt lands as a fresh cache anchor.
@@ -1866,6 +1869,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		if (previousTools.length > 0) {
 			await this.session.setActiveToolsByName(previousTools);
 		}
+		if (!sessionSwitchCompleted) {
+			this.showWarning("Plan approved, but the new session could not be created — execution was not dispatched.");
+			return;
+		}
 		this.session.setPlanReferencePath(options.finalPlanFilePath);
 
 		if (compactOutcome === "cancelled") {
@@ -2577,15 +2584,18 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#commandController.handleContextCommand();
 	}
 
-	#prepareSessionSwitch(): void {
+	#prepareSessionSwitch(cleanupPreviousSessionUi?: () => void): void {
 		this.#btwController.dispose();
-		this.#extensionUiController.clearExtensionTerminalInputListeners();
+		if (cleanupPreviousSessionUi) cleanupPreviousSessionUi();
+		else this.#extensionUiController.clearExtensionTerminalInputListeners();
 		this.#planReviewContainer = undefined;
 	}
 
-	handleClearCommand(): Promise<void> {
-		this.#prepareSessionSwitch();
-		return this.#commandController.handleClearCommand();
+	async handleClearCommand(): Promise<boolean> {
+		const cleanupPreviousSessionUi = this.#extensionUiController.captureSessionUiCleanup();
+		const switched = await this.#commandController.handleClearCommand();
+		if (switched) this.#prepareSessionSwitch(cleanupPreviousSessionUi);
+		return switched;
 	}
 
 	handleContextClearCommand(): Promise<void> {
@@ -2593,9 +2603,11 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#commandController.handleContextClearCommand();
 	}
 
-	handleDropCommand(): Promise<void> {
-		this.#prepareSessionSwitch();
-		return this.#commandController.handleDropCommand();
+	async handleDropCommand(): Promise<boolean> {
+		const cleanupPreviousSessionUi = this.#extensionUiController.captureSessionUiCleanup();
+		const switched = await this.#commandController.handleDropCommand();
+		if (switched) this.#prepareSessionSwitch(cleanupPreviousSessionUi);
+		return switched;
 	}
 
 	handleForkCommand(): Promise<void> {

package/src/modes/shared/agent-wire/workflow-gate-broker.ts

@@ -936,10 +936,14 @@ function assertPersistedGate(
 		invalidFileState(filePath);
 }
 
-function isUnsupportedWindowsDirectorySyncError(error: unknown): boolean {
-	if (process.platform !== "win32") return false;
+export function isUnsupportedWindowsDirectorySyncError(
+	error: unknown,
+	platform: NodeJS.Platform = process.platform,
+): boolean {
+	if (platform !== "win32") return false;
 	const code = (error as NodeJS.ErrnoException | undefined)?.code;
-	return code === "EINVAL" || code === "ENOTSUP" || code === "EOPNOTSUPP";
+	// Bun reports EPERM when fsyncSync is applied to a Windows directory handle.
+	return code === "EINVAL" || code === "ENOTSUP" || code === "EOPNOTSUPP" || code === "EPERM";
 }
 
 /** A write may have reached `rename` but not the directory fsync durability barrier. */

package/src/modes/types.ts

@@ -263,9 +263,9 @@ export interface InteractiveModeContext {
 	handleContextCommand(): void;
 	handleDumpCommand(): void;
 	handleDebugTranscriptCommand(): Promise<void>;
-	handleClearCommand(): Promise<void>;
+	handleClearCommand(): Promise<boolean>;
 	handleContextClearCommand(): Promise<void>;
-	handleDropCommand(): Promise<void>;
+	handleDropCommand(): Promise<boolean>;
 	handleForkCommand(): Promise<void>;
 	handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
 	handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;

package/src/sdk/broker/discovery.ts

@@ -40,6 +40,25 @@ async function syncFile(file: string): Promise<void> {
 		await handle.close();
 	}
 }
+
+async function syncDirectory(directory: string): Promise<void> {
+	let handle: fs.FileHandle;
+	try {
+		handle = await fs.open(directory, "r");
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (process.platform === "win32" && (code === "EPERM" || code === "EACCES")) return;
+		throw error;
+	}
+	try {
+		await handle.sync();
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (process.platform !== "win32" || (code !== "EPERM" && code !== "EACCES")) throw error;
+	} finally {
+		await handle.close();
+	}
+}
 export async function writeBrokerDiscovery(agentDir: string, discovery: BrokerDiscoveryWrite): Promise<void> {
 	const incarnation = discovery.incarnation ?? brokerProcessIncarnation(discovery.pid);
 	if (!incarnation) throw new Error(`Broker process incarnation is unavailable for pid ${discovery.pid}.`);
@@ -54,7 +73,7 @@ export async function writeBrokerDiscovery(agentDir: string, discovery: BrokerDi
 		await fs.chmod(temp, 0o600);
 		await syncFile(temp);
 		await fs.rename(temp, file);
-		await syncFile(dir);
+		await syncDirectory(dir);
 	} finally {
 		await fs.rm(temp, { force: true });
 	}

package/src/sdk/broker/ensure.ts

@@ -17,13 +17,33 @@ const DISCOVERY_TIMEOUT_MS = 10_000;
 // owned-process teardown convention (SIGTERM -> grace -> SIGKILL -> hard cap).
 const REAP_GRACEFUL_MS = 2_000;
 const REAP_SIGKILL_CAP_MS = 2_000;
+export interface FixtureBrokerLease {
+	close(): Promise<void>;
+}
+
+export interface StartedFixtureBroker {
+	discovery: BrokerDiscovery;
+	lease: FixtureBrokerLease;
+}
+
 interface BrokerOwner {
 	stop(): Promise<void>;
 	canReuse(discovery: BrokerDiscovery | null): boolean;
 	markReady(discovery: BrokerDiscovery): boolean;
 }
+type EnsureInitiator = "discovery" | "fixture-lease";
+type EnsureOutcome =
+	| { kind: "external-discovery"; discovery: BrokerDiscovery }
+	| { kind: "prior-local-owner"; discovery: BrokerDiscovery; owner: BrokerOwner }
+	| { kind: "local-started-discovery"; discovery: BrokerDiscovery }
+	| { kind: "local-started-fixture"; discovery: BrokerDiscovery; owner: BrokerOwner };
+interface EnsureInFlight {
+	initiator: EnsureInitiator;
+	promise: Promise<EnsureOutcome>;
+	discovery: Promise<BrokerDiscovery>;
+}
 const owners = new Map<string, BrokerOwner>();
-const ensureInFlight = new Map<string, Promise<BrokerDiscovery>>();
+const ensureInFlight = new Map<string, EnsureInFlight>();
 const reapErrorGuards = new WeakSet<ChildProcess>();
 interface ReapTiming {
 	gracefulMs: number;
@@ -142,18 +162,44 @@ function brokerSpawnEnvironment(command: SdkInternalSpawnCommand, override?: Nod
 	return environment;
 }
 
-async function ensureBrokerOnce(settings: EnsureBrokerSettings): Promise<BrokerDiscovery> {
+function fixtureLeaseUnavailable(): Error {
+	return new Error("fixture_broker_lease_unavailable");
+}
+
+function createFixtureLease(owner: BrokerOwner): FixtureBrokerLease {
+	let closeAttempt: Promise<void> | undefined;
+	let closed = false;
+	return {
+		close(): Promise<void> {
+			if (closed) return Promise.resolve();
+			if (closeAttempt) return closeAttempt;
+			closeAttempt = owner.stop().then(
+				() => {
+					closed = true;
+				},
+				(error: unknown) => {
+					closeAttempt = undefined;
+					throw error;
+				},
+			);
+			return closeAttempt;
+		},
+	};
+}
+
+async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: EnsureInitiator): Promise<EnsureOutcome> {
 	const priorOwner = owners.get(settings.agentDir);
 	const existing = await readBrokerDiscovery(settings.agentDir, settings.heartbeatTtlMs);
+	if (initiator === "fixture-lease" && (priorOwner || existing)) throw fixtureLeaseUnavailable();
 	if (priorOwner) {
 		// A retained cleanup failure fences every discovery record. Only a ready
 		// record bound to this exact child incarnation may be reused.
-		if (priorOwner.canReuse(existing)) return existing!;
+		if (priorOwner.canReuse(existing)) return { kind: "prior-local-owner", discovery: existing!, owner: priorOwner };
 		await priorOwner.stop();
 		const discoveredAfterCleanup = await readBrokerDiscovery(settings.agentDir, settings.heartbeatTtlMs);
-		if (discoveredAfterCleanup) return discoveredAfterCleanup;
+		if (discoveredAfterCleanup) return { kind: "external-discovery", discovery: discoveredAfterCleanup };
 	} else if (existing) {
-		return existing;
+		return { kind: "external-discovery", discovery: existing };
 	}
 
 	const command = resolveSdkInternalSpawnCommand("broker-internal");
@@ -172,27 +218,23 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings): Promise<BrokerD
 	const deadline = Date.now() + DISCOVERY_TIMEOUT_MS;
 	let discoveryError: unknown;
 	while (Date.now() < deadline) {
-		// Fail fast: if the spawn failed or the child already exited, discovery can
-		// never succeed — stop (a no-op once dead) and surface the failure instead
-		// of running out the discovery timeout with an orphaned child.
 		if (spawnError || child.exitCode !== null || child.signalCode !== null) break;
 		try {
 			const discovered = await readBrokerDiscovery(settings.agentDir, settings.heartbeatTtlMs);
 			if (discovered) {
-				if (owner.markReady(discovered)) return discovered;
+				if (owner.markReady(discovered)) {
+					return initiator === "fixture-lease"
+						? { kind: "local-started-fixture", discovery: discovered, owner }
+						: { kind: "local-started-discovery", discovery: discovered };
+				}
 				await owner.stop();
-				return discovered;
+				return { kind: "external-discovery", discovery: discovered };
 			}
 		} catch (error) {
-			// A transient read failure (e.g. a half-written record) must not orphan the
-			// child; remember it and keep polling. It is surfaced if discovery fails.
 			discoveryError = error;
 		}
 		await sleep(50);
 	}
-	// Discovery failed (timeout, early child exit, spawn error, or unreadable
-	// discovery): the spawned broker never became reachable. Terminate and reap it
-	// so the failure cannot leave a detached orphan behind, then surface why.
 	const exitedBeforeDiscovery = child.exitCode !== null || child.signalCode !== null;
 	const failure = spawnError
 		? new Error(`Failed to spawn detached SDK broker: ${spawnError.message}`)
@@ -211,17 +253,33 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings): Promise<BrokerD
 	throw failure;
 }
 
-/** Starts the detached broker entrypoint when discovery has no live owner. */
-export function ensureBroker(settings: EnsureBrokerSettings): Promise<BrokerDiscovery> {
-	const existing = ensureInFlight.get(settings.agentDir);
-	if (existing) return existing;
-	const pending = ensureBrokerOnce(settings);
-	ensureInFlight.set(settings.agentDir, pending);
+function startEnsure(settings: EnsureBrokerSettings, initiator: EnsureInitiator): EnsureInFlight {
+	const promise = ensureBrokerOnce(settings, initiator);
+	const discovery = promise.then(outcome => outcome.discovery);
+	void discovery.catch(() => {});
+	const entry = { initiator, promise, discovery };
+	ensureInFlight.set(settings.agentDir, entry);
 	const clear = (): void => {
-		if (ensureInFlight.get(settings.agentDir) === pending) ensureInFlight.delete(settings.agentDir);
+		if (ensureInFlight.get(settings.agentDir) === entry) ensureInFlight.delete(settings.agentDir);
 	};
-	void pending.then(clear, clear);
-	return pending;
+	void promise.then(clear, clear);
+	return entry;
+}
+
+/** Starts the detached broker entrypoint when discovery has no live owner. */
+export function ensureBroker(settings: EnsureBrokerSettings): Promise<BrokerDiscovery> {
+	const inFlight = ensureInFlight.get(settings.agentDir) ?? startEnsure(settings, "discovery");
+	return inFlight.discovery;
+}
+
+/** Starts one fresh fixture broker and returns its sole exact-child close lease. */
+export function startFixtureBrokerWithLeaseForTest(settings: EnsureBrokerSettings): Promise<StartedFixtureBroker> {
+	if (ensureInFlight.has(settings.agentDir)) return Promise.reject(fixtureLeaseUnavailable());
+	const inFlight = startEnsure(settings, "fixture-lease");
+	return inFlight.promise.then(outcome => {
+		if (outcome.kind !== "local-started-fixture") throw fixtureLeaseUnavailable();
+		return { discovery: outcome.discovery, lease: createFixtureLease(outcome.owner) };
+	});
 }
 
 /** Test hook: returns a stop handle for the detached broker this process spawned. */

package/src/sdk/bus/chat-effect-journal.ts

@@ -340,13 +340,15 @@ export class ChatEffectJournal {
 	}
 
 	async #pruneTerminal(): Promise<void> {
-		const referenced = new Set<string>();
-		for (const mapping of Object.values((await this.#mappings.load()).conversations))
-			collectEffectReferences(mapping, referenced);
 		const terminal = (await this.list())
 			.filter(effect => effect.state === "terminal")
 			.sort((left, right) => left.updatedAt - right.updatedAt);
-		for (const effect of terminal.slice(0, Math.max(0, terminal.length - MAX_TERMINAL_CHAT_EFFECTS))) {
+		if (terminal.length <= MAX_TERMINAL_CHAT_EFFECTS) return;
+
+		const referenced = new Set<string>();
+		for (const mapping of Object.values((await this.#mappings.load()).conversations))
+			collectEffectReferences(mapping, referenced);
+		for (const effect of terminal.slice(0, terminal.length - MAX_TERMINAL_CHAT_EFFECTS)) {
 			if (!referenced.has(effect.id)) await this.#store.delete(effect.id, effect.generation);
 		}
 	}

package/src/sdk/bus/discord-daemon.ts

@@ -78,6 +78,11 @@ export interface DiscordEndpointBinding {
 	send(frame: Record<string, unknown>): void | Promise<void>;
 }
 
+export interface DiscordLeaseRecoveryScheduler {
+	setTimeout(callback: () => void | Promise<void>, delayMs: number): unknown;
+	clearTimeout(handle: unknown): void;
+}
+
 export interface DiscordNotificationDaemonOptions {
 	agentDir: string;
 	repo: string;
@@ -85,6 +90,7 @@ export interface DiscordNotificationDaemonOptions {
 	parentChannelId: string;
 	provider: DiscordProvider;
 	now?: () => number;
+	leaseRecoveryScheduler?: DiscordLeaseRecoveryScheduler;
 	resolveEndpoint: (sessionId: string, expectedGeneration?: number) => Promise<DiscordEndpointBinding | null>;
 	onCommand?: (
 		sessionId: string,
@@ -151,6 +157,7 @@ type DiscordInboundClaim = {
 export class DiscordNotificationDaemon {
 	readonly #store: ConversationStore<DiscordConversation>;
 	readonly #now: () => number;
+	readonly #leaseRecoveryScheduler: DiscordLeaseRecoveryScheduler;
 	readonly #creates = new Map<string, Promise<DiscordConversation>>();
 	readonly #resumes = new Map<string, Promise<DiscordConversation | undefined>>();
 	readonly #archives = new Map<string, Promise<void>>();
@@ -167,7 +174,7 @@ export class DiscordNotificationDaemon {
 	#stopTask: Promise<void> | undefined;
 	#providerStarting = false;
 
-	#leaseRecoveryTimer: ReturnType<typeof setTimeout> | undefined;
+	#leaseRecoveryTimer: unknown;
 	#leaseRecoveryAt: number | undefined;
 	#leaseRecoveryFailures = 0;
 
@@ -179,6 +186,10 @@ export class DiscordNotificationDaemon {
 		this.#store = new ConversationStore({ agentDir: options.agentDir, kind: "discord", now: options.now });
 		this.#effects = new ChatEffectJournal({ agentDir: options.agentDir, transport: "discord", now: options.now });
 		this.#now = options.now ?? Date.now;
+		this.#leaseRecoveryScheduler = options.leaseRecoveryScheduler ?? {
+			setTimeout: (callback, delayMs) => setTimeout(() => void callback(), delayMs),
+			clearTimeout: handle => clearTimeout(handle as ReturnType<typeof setTimeout>),
+		};
 		this.#resolveEndpoint = options.resolveEndpoint;
 	}
 
@@ -240,7 +251,8 @@ export class DiscordNotificationDaemon {
 		} catch (error) {
 			if (lifecycleGeneration === this.#lifecycleGeneration) {
 				this.#started = false;
-				if (this.#leaseRecoveryTimer) clearTimeout(this.#leaseRecoveryTimer);
+				if (this.#leaseRecoveryTimer !== undefined)
+					this.#leaseRecoveryScheduler.clearTimeout(this.#leaseRecoveryTimer);
 				this.#leaseRecoveryTimer = undefined;
 				this.#leaseRecoveryAt = undefined;
 			}
@@ -255,7 +267,7 @@ export class DiscordNotificationDaemon {
 		const stopProvider = this.#started || this.#providerStarting;
 		++this.#lifecycleGeneration;
 		this.#started = false;
-		if (this.#leaseRecoveryTimer) clearTimeout(this.#leaseRecoveryTimer);
+		if (this.#leaseRecoveryTimer !== undefined) this.#leaseRecoveryScheduler.clearTimeout(this.#leaseRecoveryTimer);
 		this.#leaseRecoveryTimer = undefined;
 		this.#leaseRecoveryAt = undefined;
 
@@ -2128,8 +2140,11 @@ export class DiscordNotificationDaemon {
 	}
 	async #scheduleLeaseRecovery(recoveryFailed = false): Promise<void> {
 		if (!this.#started) return;
+		const lifecycleGeneration = this.#lifecycleGeneration;
+		const effects = await this.#effects.list();
+		if (!this.#started || lifecycleGeneration !== this.#lifecycleGeneration) return;
 		const now = this.#now();
-		const recoveryAt = (await this.#effects.list())
+		const recoveryAt = effects
 			.filter(effect => effect.transport === "discord")
 			.reduce<number | undefined>(
 				(earliest, effect) => {
@@ -2146,23 +2161,25 @@ export class DiscordNotificationDaemon {
 				recoveryFailed ? now : undefined,
 			);
 		if (recoveryAt === undefined) {
-			if (this.#leaseRecoveryTimer) clearTimeout(this.#leaseRecoveryTimer);
+			if (this.#leaseRecoveryTimer !== undefined)
+				this.#leaseRecoveryScheduler.clearTimeout(this.#leaseRecoveryTimer);
 			this.#leaseRecoveryTimer = undefined;
 			this.#leaseRecoveryAt = undefined;
 			this.#leaseRecoveryFailures = 0;
 			return;
 		}
 		if (this.#leaseRecoveryAt !== undefined && this.#leaseRecoveryAt <= recoveryAt) return;
-		if (this.#leaseRecoveryTimer) clearTimeout(this.#leaseRecoveryTimer);
+		if (this.#leaseRecoveryTimer !== undefined) this.#leaseRecoveryScheduler.clearTimeout(this.#leaseRecoveryTimer);
 		this.#leaseRecoveryAt = recoveryAt;
 		const delay =
 			recoveryAt <= now
 				? Math.min(1_000, 25 * 2 ** Math.min(this.#leaseRecoveryFailures, 5))
 				: Math.min(recoveryAt - now, 2_147_483_647);
-		this.#leaseRecoveryTimer = setTimeout(() => {
+		this.#leaseRecoveryTimer = this.#leaseRecoveryScheduler.setTimeout(() => {
+			if (lifecycleGeneration !== this.#lifecycleGeneration) return;
 			this.#leaseRecoveryTimer = undefined;
 			this.#leaseRecoveryAt = undefined;
-			void this.#track(this.#recoverLeasedEffects());
+			return this.#track(this.#recoverLeasedEffects()).catch(() => {});
 		}, delay);
 	}
 	async #recoverLeasedEffects(): Promise<void> {