@gajae-code/coding-agent 0.18.1 → 0.18.6

package/src/sdk/broker/startup-budget.ts

@@ -11,6 +11,9 @@ export const MAX_PREPARATION_TIMEOUT_MS = 120_000;
 /** Bounded workspace install window; independent of child semantic readiness. */
 export const DEFAULT_DEPENDENCY_PREPARATION_TIMEOUT_MS = 30_000;
 
+/** Non-worktree broker pre-spawn cap, also limited by the admission window remaining since receipt. */
+export const DEFAULT_BROKER_PRESPAWN_PREPARATION_TIMEOUT_MS = 30_000;
+
 export function isValidReadinessTimeoutMs(value: unknown): value is number {
 	return (
 		typeof value === "number" &&
@@ -98,7 +101,9 @@ export function lifecycleStartupBudgetMs(requestedReadinessTimeoutMs: number): n
  *
  * Worktree launches add independent preparation budgets so git add / install cannot
  * cut the caller while the broker still owns the request. One-arg
- * {@link lifecycleStartupBudgetMs} stays queue+readiness for no-worktree callers.
+ * {@link lifecycleStartupBudgetMs} stays queue+readiness for no-worktree callers:
+ * broker-derived pre-spawn work uses only the unspent admission window from receipt,
+ * and the fresh readiness window ends within that unchanged caller budget.
  */
 export function lifecycleRequestTimeoutMs(operation: string, input: Record<string, unknown>): number | undefined {
 	const deadlineFields = [

package/src/sdk/broker/transport.ts

@@ -1,4 +1,5 @@
 import { createHash, timingSafeEqual } from "node:crypto";
+import { logger } from "@gajae-code/utils";
 import type { ServerWebSocket } from "bun";
 import type { Broker } from "./broker";
 
@@ -7,6 +8,8 @@ const PROTOCOL_VERSION = 3;
 const MAX_BROKER_JSON_FRAME_BYTES = 4 * 1024 * 1024;
 
 const BROKER_OPERATIONS = new Set([
+	// Observation-only published diagnostics; it starts, ensures and recovers nothing.
+	"broker.diagnostics",
 	"session.list",
 	"session.get_endpoint",
 	"session.create",
@@ -160,7 +163,8 @@ export class BrokerTransport {
 		try {
 			const result = await this.#broker.handleRequest(frame.operation, frame.input, frame.idempotencyKey);
 			send(socket, { type: "broker_response", id: frame.id, ...result });
-		} catch {
+		} catch (error) {
+			logger.warn(`sdk broker request failed: ${error instanceof Error ? error.message : String(error)}`);
 			sendError(socket, frame.id, "unavailable", "broker request failed");
 		}
 	}

package/src/sdk/bus/chat-daemon-control.ts

@@ -141,8 +141,8 @@ export type ChatDaemonAction = "stop" | "reload";
  * crashes, recovery, and attachment retirement cannot replay ambiguous work.
  */
 export const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>> = {
-	discord: 81,
-	slack: 88,
+	discord: 82,
+	slack: 89,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {

package/src/sdk/bus/index.ts

@@ -116,6 +116,7 @@ import { type AbortScope, type ControlSurface, dispatchControl, TypedControlErro
 import { BROKER_RUNTIME_CLOSE_CAPABILITY_FIELD } from "../host/control/runtime-gate";
 import { isAutoroutingInactive, markAutoroutingInactive } from "../host/internal-autorouting-state";
 import { CursorRegistry, QueryHandlers, RevisionStore, type SessionSurface } from "../host/query";
+import { RESPONSE_CEILING_BYTES } from "../host/query/handlers";
 import type { SdkFrame } from "../host/types";
 import {
 	parseSyntheticModelId,
@@ -137,6 +138,7 @@ import {
 	assistantFailureCode,
 	failedPromptOutcome,
 	formatPromptFailureForLocalLog,
+	isSafePromptFailureCode,
 	PROMPT_FAILURE_MESSAGE_DEADLINE,
 	providerDiagnosticField,
 	publishedPromptFailure,
@@ -4246,6 +4248,16 @@ export function shouldAwaitNotificationStartup(event: {
 	return event.type !== "session_switch" || event.transition?.origin !== INTERACTIVE_SELECTOR_RESUME_ORIGIN;
 }
 
+export function boundedCorrelatedAgentEndFrame(frame: Record<string, unknown>): Record<string, unknown> {
+	const finalText = typeof frame.finalText === "string" ? frame.finalText : "";
+	if (finalText.length <= RESPONSE_CEILING_BYTES / 8) return frame;
+	return {
+		...frame,
+		finalText: `${finalText.slice(0, RESPONSE_CEILING_BYTES / 8)}[truncated]`,
+		finalTextTruncated: true,
+	};
+}
+
 export function createNotificationsExtension(
 	api: ExtensionAPI,
 	options: {
@@ -5080,6 +5092,8 @@ export function createNotificationsExtension(
 			acknowledged: boolean;
 			connectionId: string;
 			abandoned: boolean;
+			terminalRetry?: Promise<void>;
+			backlogDropLogged?: boolean;
 			failed: boolean;
 			terminal: boolean;
 			retainCorrelation: boolean;
@@ -5331,6 +5345,289 @@ export function createNotificationsExtension(
 			submission.abandoned = true;
 			submission.bufferedFrames.length = 0;
 		};
+		const isCorrelatedDeltaFrame = (frame: Record<string, unknown>): boolean => {
+			if (frame.type !== "event" || frame.kind !== "message_update") return false;
+			const payload = frame.payload as {
+				event?: { assistantMessageEvent?: { type?: string } };
+			};
+			const type = payload.event?.assistantMessageEvent?.type;
+			return type === "text_delta" || type === "thinking_delta";
+		};
+		const boundedCorrelatedFrames = (frame: Record<string, unknown>): Record<string, unknown>[] | undefined => {
+			if (frame.type === "event" && frame.kind === "message_update") {
+				const payload = frame.payload as {
+					event?: {
+						message?: { role?: string };
+						assistantMessageEvent?: { type?: string; delta?: string };
+					};
+				};
+				const update = payload.event?.assistantMessageEvent;
+				if (update?.type !== "text_delta" && update?.type !== "thinking_delta") return undefined;
+				// ACP consumes deltas, so retain the delta while discarding the replaceable
+				// accumulated message snapshot. Split giant deltas without changing content.
+				const delta = update.delta ?? "";
+				const makeFrame = (chunk: string): Record<string, unknown> => ({
+					...frame,
+					payload: {
+						event_type: "message_update",
+						event: {
+							type: "message_update",
+							message: { role: payload.event?.message?.role ?? "assistant", content: [] },
+							assistantMessageEvent: { type: update.type, delta: chunk },
+						},
+					},
+				});
+				const frames: Record<string, unknown>[] = [];
+				let offset = 0;
+				while (offset < delta.length || (offset === 0 && delta.length === 0)) {
+					let low = 1;
+					let high = delta.length - offset + 1;
+					let bestEnd = 0;
+					while (low < high) {
+						const candidateLength = Math.floor((low + high) / 2);
+						let candidateEnd = offset + candidateLength;
+						if (
+							candidateEnd < delta.length &&
+							delta.charCodeAt(candidateEnd) >= 0xdc00 &&
+							delta.charCodeAt(candidateEnd) <= 0xdfff
+						)
+							candidateEnd += 1;
+						const candidate = JSON.stringify(makeFrame(delta.slice(offset, candidateEnd)));
+						if (Buffer.byteLength(candidate) <= RESPONSE_CEILING_BYTES) {
+							bestEnd = candidateEnd;
+							low = candidateLength + 1;
+						} else {
+							high = candidateLength;
+						}
+					}
+					if (bestEnd === 0) return undefined;
+					frames.push(makeFrame(delta.slice(offset, bestEnd)));
+					offset = bestEnd;
+					if (delta.length === 0) break;
+				}
+				return frames;
+			}
+			if (frame.type === "event" && frame.kind === "message_end") {
+				const payload = frame.payload as {
+					event?: { message?: { role?: string; content?: Array<{ type?: string; text?: string }> } };
+				};
+				const message = payload.event?.message;
+				const textBlocks =
+					message?.content
+						?.filter(
+							(block): block is { type: "text"; text: string } =>
+								block.type === "text" && typeof block.text === "string",
+						)
+						.map(block => block.text) ?? [];
+				const makeMessageEndFrame = (
+					content: Array<{ type: "text"; text: string }>,
+					textTruncated?: true,
+					omittedTextBlocks?: number,
+				): Record<string, unknown> => ({
+					...frame,
+					payload: {
+						event_type: "message_end",
+						event: {
+							type: "message_end",
+							message: {
+								role: message?.role ?? "assistant",
+								content,
+								...(textTruncated ? { textTruncated } : {}),
+								...(omittedTextBlocks ? { omittedTextBlocks } : {}),
+							},
+						},
+					},
+				});
+				const fits = (candidate: Record<string, unknown>): boolean =>
+					Buffer.byteLength(JSON.stringify(candidate)) <= RESPONSE_CEILING_BYTES;
+				const content: Array<{ type: "text"; text: string }> = [];
+				let textTruncated = false;
+				let omittedTextBlocks = 0;
+				for (const [index, textBlock] of textBlocks.entries()) {
+					const wholeBlock = [...content, { type: "text" as const, text: textBlock }];
+					if (fits(makeMessageEndFrame(wholeBlock))) {
+						content.push({ type: "text", text: textBlock });
+						continue;
+					}
+					textTruncated = true;
+					const remainingTextBlocks = textBlocks.length - index;
+					let low = 1;
+					let high = textBlock.length + 1;
+					let bestEnd = 0;
+					while (low < high) {
+						const candidateLength = Math.floor((low + high) / 2);
+						let candidateEnd = candidateLength;
+						if (
+							candidateEnd < textBlock.length &&
+							textBlock.charCodeAt(candidateEnd) >= 0xdc00 &&
+							textBlock.charCodeAt(candidateEnd) <= 0xdfff
+						)
+							candidateEnd += 1;
+						const candidateContent = [
+							...content,
+							...(candidateEnd > 0 ? [{ type: "text" as const, text: textBlock.slice(0, candidateEnd) }] : []),
+						];
+						const candidateOmittedTextBlocks = remainingTextBlocks - (candidateEnd > 0 ? 1 : 0);
+						if (
+							fits(
+								makeMessageEndFrame(
+									candidateContent,
+									true,
+									candidateOmittedTextBlocks > 0 ? candidateOmittedTextBlocks : undefined,
+								),
+							)
+						) {
+							bestEnd = candidateEnd;
+							low = candidateLength + 1;
+						} else high = candidateLength;
+					}
+					if (bestEnd > 0) content.push({ type: "text", text: textBlock.slice(0, bestEnd) });
+					omittedTextBlocks = remainingTextBlocks - (bestEnd > 0 ? 1 : 0);
+					break;
+				}
+				return [
+					makeMessageEndFrame(
+						content,
+						textTruncated ? true : undefined,
+						omittedTextBlocks > 0 ? omittedTextBlocks : undefined,
+					),
+				];
+			}
+			if (frame.type === "agent_end") {
+				return [boundedCorrelatedAgentEndFrame(frame)];
+			}
+			if (frame.type === "agent_failed") {
+				const outcome = frame.outcome as Extract<SdkPromptTerminalOutcome, { kind: "failed" }> | undefined;
+				return [
+					{
+						...frame,
+						error: { code: outcome?.code ?? "prompt_failed", message: "Prompt failure details were truncated." },
+						...(outcome ? { outcome: { ...outcome, message: "Prompt failure details were truncated." } } : {}),
+					},
+				];
+			}
+			return undefined;
+		};
+		const deliverCorrelatedFrame = (submission: PromptSubmission, frame: Record<string, unknown>) => {
+			if (submission.abandoned) return;
+			const activeRuntime = runtime;
+			if (!activeRuntime) return;
+			const fail = (cause: string, frameBytes: number, failedJson = JSON.stringify(frame)) => {
+				// A non-terminal frame only reports progress from a still-running
+				// prompt. Abandon its delivery on failure instead of publishing a
+				// synthetic terminal that could race the real run and make ACP
+				// settle the prompt while provider/tool execution continues.
+				if (frame.type !== "agent_end" && frame.type !== "agent_failed") {
+					if (cause === "writer_backlog_full") {
+						if (!submission.backlogDropLogged) {
+							submission.backlogDropLogged = true;
+							logger.warn(
+								`sdk: correlated non-terminal delivery dropped: cause=${cause} frameBytes=${frameBytes}`,
+							);
+						}
+						return;
+					}
+					logger.warn(`sdk: correlated non-terminal delivery abandoned: cause=${cause} frameBytes=${frameBytes}`);
+					abandonPrompt(submission);
+					return;
+				}
+				if (cause === "writer_backlog_full") {
+					const correlation = { commandId: String(frame.commandId), turnId: String(frame.turnId) };
+					const key = promptSubmissionKey(correlation);
+					submission.terminalRetry = (async () => {
+						const deadline = Date.now() + 3_000;
+						while (Date.now() < deadline) {
+							await Bun.sleep(50);
+							try {
+								activeRuntime.server.sendTo(submission.connectionId, failedJson);
+								return;
+							} catch (retryError) {
+								if (!String(retryError).includes("cause=writer_backlog_full")) break;
+							}
+						}
+						terminalDeliveryFailure(cause, frameBytes);
+					})().finally(() => {
+						submission.terminalRetry = undefined;
+						if (submission.terminal && promptSubmissions.get(key) === submission) {
+							if (!submission.abandoned) submission.phase = "delivered";
+							finalizePrompt(key, correlation);
+						}
+					});
+					return;
+				}
+				terminalDeliveryFailure(cause, frameBytes);
+			};
+			const terminalDeliveryFailure = (cause: string, frameBytes: number) => {
+				const safeCause = isSafePromptFailureCode(cause) ? cause : "unknown";
+				const correlation = { commandId: String(frame.commandId), turnId: String(frame.turnId) };
+				const outcome = failedPromptOutcome({
+					code: "prompt_failed",
+					provenance: "agent_failed",
+					providerCode: safeCause,
+					evidence: {},
+				});
+				try {
+					activeRuntime.server.sendTo(
+						submission.connectionId,
+						JSON.stringify({
+							type: "agent_failed",
+							sessionId: activeRuntime.id,
+							...correlation,
+							error: {
+								code: "delivery_failed",
+								message: "Prompt frame delivery failed.",
+								cause: safeCause,
+								frameBytes,
+							},
+							outcome,
+						}),
+					);
+				} catch (error) {
+					logger.warn(`sdk: correlated delivery failure terminal failed: ${String(error)}`);
+				}
+				abandonPrompt(submission);
+			};
+			const original = JSON.stringify(frame);
+			const originalBytes = Buffer.byteLength(original);
+			let framesToSend = [frame];
+			if (originalBytes > RESPONSE_CEILING_BYTES) {
+				const bounded = boundedCorrelatedFrames(frame);
+				if (!bounded) {
+					if (frame.type === "event" && frame.kind === "message_update" && !isCorrelatedDeltaFrame(frame)) return;
+					fail("oversized_frame", originalBytes);
+					return;
+				}
+				framesToSend = bounded;
+			}
+			for (const frameToSend of framesToSend) {
+				const json = JSON.stringify(frameToSend);
+				if (Buffer.byteLength(json) > RESPONSE_CEILING_BYTES) {
+					fail("oversized_frame", originalBytes);
+					return;
+				}
+				try {
+					activeRuntime.server.sendTo(submission.connectionId, json);
+				} catch (error) {
+					const detail = String(error);
+					if (detail.includes("cause=oversized_frame") && json === original) {
+						const bounded = boundedCorrelatedFrames(frame);
+						if (bounded) {
+							try {
+								for (const retryFrame of bounded)
+									activeRuntime.server.sendTo(submission.connectionId, JSON.stringify(retryFrame));
+								return;
+							} catch (retryError) {
+								logger.warn(`sdk: bounded correlated delivery failed: ${String(retryError)}`);
+							}
+						}
+					}
+					logger.warn(`sdk: correlated delivery failed: ${detail}`);
+					const cause = /cause=([a-z_]+)/.exec(detail)?.[1] ?? "unknown";
+					fail(cause, originalBytes, json);
+					return;
+				}
+			}
+		};
 		const emitPromptLifecycle = (
 			correlation: { commandId: string; turnId: string } | undefined,
 			frame: PromptLifecycleFrame,
@@ -5353,13 +5650,9 @@ export function createNotificationsExtension(
 				submission.bufferedFrames.push(frame);
 				return;
 			}
-			try {
-				runtime.server.sendTo(submission.connectionId, JSON.stringify(frame));
-			} catch (error) {
-				logger.warn(`sdk: correlated lifecycle delivery failed: ${String(error)}`);
-				abandonPrompt(submission);
-			}
+			deliverCorrelatedFrame(submission, frame);
 			if (submission.terminal) {
+				if (submission.terminalRetry) return;
 				submission.phase = "delivered";
 				finalizePrompt(key, correlation);
 			}
@@ -5497,12 +5790,7 @@ export function createNotificationsExtension(
 				submission.bufferedFrames.push(frame);
 				return;
 			}
-			try {
-				runtime.server.sendTo(submission.connectionId, JSON.stringify(frame));
-			} catch (error) {
-				logger.warn(`sdk: correlated agent event delivery failed: ${String(error)}`);
-				abandonPrompt(submission);
-			}
+			deliverCorrelatedFrame(submission, frame);
 		};
 		/**
 		 * Status of a registered deadline expiry attempt after an awaited
@@ -5666,15 +5954,13 @@ export function createNotificationsExtension(
 		};
 		const flushPromptLifecycle = (key: string, submission: PromptSubmission) => {
 			for (const frame of submission.bufferedFrames.splice(0)) {
-				try {
-					server.sendTo(submission.connectionId, JSON.stringify(frame));
-				} catch (error) {
-					logger.warn(`sdk: buffered correlated lifecycle delivery failed: ${String(error)}`);
-					abandonPrompt(submission);
-					break;
-				}
+				deliverCorrelatedFrame(submission, frame);
+				if (submission.abandoned) break;
 			}
 			if (submission.terminal) {
+				if (submission.terminalRetry) {
+					return;
+				}
 				submission.phase = "delivered";
 				const [commandId, turnId] = key.split(":", 2);
 				if (commandId && turnId) finalizePrompt(key, { commandId, turnId });

package/src/sdk/bus/telegram-daemon-contract.ts

@@ -297,7 +297,7 @@ export const SDK_LIFECYCLE_ROUTER_PROTOCOL_VERSION = 1;
  * Generation 193 gates streamed content on negotiated observer capabilities,
  * so existing owners are replaced before exposing the new observer path.
  */
-export const DAEMON_GENERATION = 197;
+export const DAEMON_GENERATION = 200;
 
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 7

package/src/sdk/bus/telegram-daemon-control.ts

@@ -53,6 +53,16 @@ const nodeFs: TelegramDaemonFs = {
 const DEFAULT_GRACEFUL_TIMEOUT_MS = 8_000;
 const DEFAULT_KILL_TIMEOUT_MS = 3_000;
 const DEFAULT_WAIT_STEP_MS = 25;
+// Windows process handles cannot deliver SIGTERM cooperatively. The request
+// file is therefore the sole notification channel, so a captured owner gets
+// enough time to finish its long poll, network slack, and shutdown joins before
+// an explicit force request may escalate. Short explicit timeouts are clamped
+// to this floor only for hard-termination authorities; POSIX keeps 8 seconds.
+const HARD_TERMINATION_LONG_POLL_MS = 25_000;
+const HARD_TERMINATION_NETWORK_SLACK_MS = 5_000;
+const HARD_TERMINATION_SHUTDOWN_JOINS_MS = 10_000;
+const HARD_TERMINATION_GRACE_MS =
+	HARD_TERMINATION_LONG_POLL_MS + HARD_TERMINATION_NETWORK_SLACK_MS + HARD_TERMINATION_SHUTDOWN_JOINS_MS;
 
 export interface TelegramDaemonControlRequest {
 	version: 1;
@@ -641,17 +651,6 @@ export class TelegramDaemonController implements BuiltInDaemonController {
 		const signalResult = attestedLegacyOwner
 			? await this.#signalAttestedLegacyOwner(attestedLegacyOwner, fp, chatId, "SIGTERM")
 			: await this.signalCapturedOwner(modernCapturedOwner!, fp, chatId, "SIGTERM");
-		if (signalResult === "hard_termination") {
-			await this.clearOwnRequest(requestId);
-			return this.result(
-				action,
-				false,
-				"telegram daemon has hard process authority; refusing cooperative SIGTERM",
-				before,
-				await this.status(),
-				warnings,
-			);
-		}
 		if (signalResult === "ownership_changed") {
 			await this.clearOwnRequest(requestId);
 			return this.result(
@@ -667,7 +666,11 @@ export class TelegramDaemonController implements BuiltInDaemonController {
 		// death through the normal path — waitForPidDeath returns immediately for a
 		// dead pid, so stop succeeds and reload proceeds to spawn the replacement.
 
-		let dead = await this.waitForPidDeath(oldPid, gracefulTimeoutMs);
+		const cooperativeGraceMs =
+			signalResult === "hard_termination"
+				? Math.max(gracefulTimeoutMs, HARD_TERMINATION_GRACE_MS)
+				: gracefulTimeoutMs;
+		let dead = await this.waitForPidDeath(oldPid, cooperativeGraceMs);
 		if (!dead) {
 			// Old pid still alive after the cooperative SIGTERM. Inspect current ownership.
 			const currentSnapshot = await readOwnerFreshnessSnapshot({ settings: this.settings, fs: this.fsImpl });

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

@@ -362,6 +362,7 @@ const BOT_API_RETRY_ATTEMPTS = 3;
 // Backoff after a failed getUpdates long-poll so a persistent outage does not
 // busy-loop the daemon.
 const POLL_BACKOFF_MS = 1_000;
+const CONTROL_STOP_WATCH_INTERVAL_MS = 750;
 const AUTOMATIC_RELOAD_COOLDOWN_MS = 10 * 60 * 1_000;
 // Default freshness-poll window a cooldown contender waits for a sibling's
 // replacement daemon to publish a fresh ready owner before reloading itself.
@@ -4567,6 +4568,7 @@ export class TelegramNotificationDaemon {
 	private stopRequested = false;
 	/** First observed stop cause wins, including an explicit stop. */
 	#stopCause: TelegramDaemonStopCause | undefined;
+	#controlStopCheck: Promise<boolean> | undefined;
 	/** Signal cause resolution is asynchronous because control requests are file-backed. */
 	#stopCauseResolution: Promise<void> | undefined;
 
@@ -12875,6 +12877,9 @@ export class TelegramNotificationDaemon {
 				throw new Error("validation forum destination must be the exact supergroup forum returned by getChat");
 		}
 		let ownershipProved = false;
+		let controlWatchTimer: Timer | NodeJS.Timeout | undefined;
+		let controlWatchActive = true;
+		const clearTimeoutImpl = this.opts.clearTimeoutImpl ?? clearTimeout;
 		try {
 			const renewed = await renewDaemonHeartbeat({
 				settings: this.opts.settings,
@@ -12935,6 +12940,19 @@ export class TelegramNotificationDaemon {
 			}
 			await this.#attachmentRouter.start();
 			let idleSince = this.runtime.now();
+			const setTimeoutImpl = this.opts.setTimeoutImpl ?? setTimeout;
+			const watchControl = () => {
+				if (!controlWatchActive || !this.running || !this.opts.control) return;
+				controlWatchTimer = setTimeoutImpl(() => {
+					controlWatchTimer = undefined;
+					void this.controlStopRequested()
+						.catch(() => false)
+						.finally(() => {
+							if (controlWatchActive && this.running) watchControl();
+						});
+				}, CONTROL_STOP_WATCH_INTERVAL_MS);
+			};
+			if (this.opts.control) watchControl();
 			while (this.running) {
 				if (await this.controlStopRequested()) break;
 				// A thrown renewal (e.g. a transient Windows EPERM/EACCES/EBUSY while
@@ -13003,6 +13021,8 @@ export class TelegramNotificationDaemon {
 			this.requestStop("unexpected_exception");
 			throw error;
 		} finally {
+			controlWatchActive = false;
+			if (controlWatchTimer !== undefined) clearTimeoutImpl(controlWatchTimer);
 			this.requestStop();
 			await this.#stopCauseResolution;
 			this.running = false;
@@ -13089,8 +13109,21 @@ export class TelegramNotificationDaemon {
 	private async controlStopRequested(): Promise<boolean> {
 		if (this.runtime.stopRequested) return true;
 		if (!this.opts.control) return false;
+		if (this.#controlStopCheck) return this.#controlStopCheck;
+		const check = this.checkControlStopRequested();
+		this.#controlStopCheck = check;
+		try {
+			return await check;
+		} finally {
+			if (this.#controlStopCheck === check) this.#controlStopCheck = undefined;
+		}
+	}
+
+	private async checkControlStopRequested(): Promise<boolean> {
 		try {
-			const requested = await this.opts.control.shouldStop(this.opts.ownerId);
+			const control = this.opts.control;
+			if (!control) return false;
+			const requested = await control.shouldStop(this.opts.ownerId);
 			if (!requested) return false;
 			this.#resolveControlStopCause("stop");
 			this.requestStop();