@gajae-code/coding-agent 0.18.5 → 0.18.7

package/src/sdk/broker/runtime.ts

@@ -6,7 +6,11 @@ import { currentExecutablePath } from "@gajae-code/natives";
 
 import internalSourceMarker from "./internal-source-marker-2178.txt" with { type: "file" };
 
-export type SdkInternalAction = "broker-internal" | "session-host-internal" | "stderr-drain-internal";
+export type SdkInternalAction =
+	| "broker-internal"
+	| "broker-trampoline-internal"
+	| "session-host-internal"
+	| "stderr-drain-internal";
 
 export type SdkInternalSpawnCommand =
 	| {

package/src/sdk/broker/task-artifact-owner-validation.ts

@@ -0,0 +1,259 @@
+import type { NativeExactUnlinkResult } from "@gajae-code/natives";
+import {
+	assertSessionRoot,
+	parseTaskArtifactOwnerDeletionEvidence,
+	parseTaskArtifactOwnerRetirementContinuation,
+	parseTaskArtifactOwnerRetirementOutcome,
+	type TaskArtifactOwnerDeletionEvidence,
+	type TaskArtifactOwnerRetirementContinuation,
+	type TaskArtifactOwnerRetirementOutcome,
+	type TaskArtifactOwnerStorageContext,
+} from "../../session/task-artifact-owner-codec";
+
+export type BrokerCleanupPhase = "artifacts" | "transcript" | "metadata" | "lifecycle";
+
+/** Exact owner-disposition wire shape. Evidence and continuation are supplied separately by cleanup replay. */
+export type BrokerTaskArtifactOwnerRetirementDisposition =
+	| { readonly kind: "completed"; readonly nativeOutcome?: NativeExactUnlinkResult }
+	| {
+			readonly kind: "payload_retired";
+			readonly namespace: "retained";
+			readonly nativeOutcome: NativeExactUnlinkResult;
+	  }
+	| { readonly kind: "cleanup_pending"; readonly nativeOutcome?: NativeExactUnlinkResult }
+	| { readonly kind: "uncertain"; readonly reason: string; readonly nativeOutcome?: NativeExactUnlinkResult };
+
+/** Owner-only projection of durable cleanup state accepted by the pure validator. */
+export interface BrokerTaskArtifactOwnerCleanupFields {
+	readonly taskArtifactOwnerDeletionEvidence?: unknown;
+	readonly taskArtifactOwnerRetirementContinuation?: unknown;
+	readonly taskArtifactOwnerRetirementOutcome?: unknown;
+	readonly taskArtifactOwnerPayloadRetired?: unknown;
+	readonly taskArtifactOwnerNamespaceRetained?: unknown;
+	readonly taskArtifactOwnerRetired?: unknown;
+	readonly taskArtifactOwnerTranscriptDeleted?: unknown;
+	readonly taskArtifactOwnerCleanupError?: unknown;
+}
+
+/** Fully decoded owner-only cleanup state for an authorized session and phase. */
+export interface BrokerTaskArtifactOwnerCleanupValidation {
+	readonly deletionEvidence?: TaskArtifactOwnerDeletionEvidence;
+	readonly retirementContinuation?: TaskArtifactOwnerRetirementContinuation;
+	readonly retirementOutcome?: TaskArtifactOwnerRetirementOutcome;
+	readonly payloadRetired?: true;
+	readonly namespaceRetained?: true;
+	readonly retired?: true;
+	readonly transcriptDeleted?: true;
+	readonly cleanupDiagnostic?: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function hasExactKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
+	return Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
+}
+
+function invalidDisposition(): never {
+	throw new Error("task_artifact_owner_retirement_disposition_invalid");
+}
+
+/**
+ * Decode the owner-only wire disposition using its exact trusted evidence and continuation.
+ * A decoded `completed` value is historical DTO data, not proof of physical retirement or writer closure.
+ */
+export function parseBrokerTaskArtifactOwnerRetirementDisposition(
+	value: unknown,
+	context: TaskArtifactOwnerStorageContext,
+	evidence: TaskArtifactOwnerDeletionEvidence,
+	continuation: TaskArtifactOwnerRetirementContinuation | undefined,
+): TaskArtifactOwnerRetirementOutcome {
+	assertSessionRoot(context);
+	if (!isRecord(value)) return invalidDisposition();
+	const kind = value.kind;
+	let expectedKeys: readonly string[];
+	switch (kind) {
+		case "completed":
+		case "cleanup_pending":
+			expectedKeys = Object.hasOwn(value, "nativeOutcome") ? ["kind", "nativeOutcome"] : ["kind"];
+			break;
+		case "payload_retired":
+			expectedKeys = ["kind", "namespace", "nativeOutcome"];
+			break;
+		case "uncertain":
+			expectedKeys = Object.hasOwn(value, "nativeOutcome")
+				? ["kind", "reason", "nativeOutcome"]
+				: ["kind", "reason"];
+			break;
+		default:
+			return invalidDisposition();
+	}
+	if (!hasExactKeys(value, expectedKeys)) return invalidDisposition();
+	const reconstructed = {
+		...value,
+		evidence,
+		...(continuation !== undefined ? { continuation } : {}),
+	};
+	return parseTaskArtifactOwnerRetirementOutcome(context, evidence, reconstructed);
+}
+
+function serializeNativeOutcome(outcome: NativeExactUnlinkResult): NativeExactUnlinkResult {
+	return Object.freeze({
+		ok: outcome.ok,
+		...(outcome.code !== undefined ? { code: outcome.code } : {}),
+		...(outcome.detachedPath !== undefined ? { detachedPath: outcome.detachedPath } : {}),
+		...(outcome.retainedSuccessorPath !== undefined ? { retainedSuccessorPath: outcome.retainedSuccessorPath } : {}),
+		...(outcome.retainedPlaceholderPath !== undefined
+			? { retainedPlaceholderPath: outcome.retainedPlaceholderPath }
+			: {}),
+		...(outcome.retainedUnknownPath !== undefined ? { retainedUnknownPath: outcome.retainedUnknownPath } : {}),
+		...(outcome.payloadDurable !== undefined ? { payloadDurable: outcome.payloadDurable } : {}),
+		...(outcome.windowsErrorCode !== undefined ? { windowsErrorCode: outcome.windowsErrorCode } : {}),
+	}) as NativeExactUnlinkResult;
+}
+
+/** Project an already validated internal outcome to the exact broker wire disposition. */
+export function serializeBrokerTaskArtifactOwnerRetirementDisposition(
+	outcome: TaskArtifactOwnerRetirementOutcome,
+): BrokerTaskArtifactOwnerRetirementDisposition {
+	switch (outcome.kind) {
+		case "completed":
+			return Object.freeze({
+				kind: outcome.kind,
+				...(outcome.nativeOutcome ? { nativeOutcome: serializeNativeOutcome(outcome.nativeOutcome) } : {}),
+			});
+		case "payload_retired":
+			return Object.freeze({
+				kind: outcome.kind,
+				namespace: outcome.namespace,
+				nativeOutcome: serializeNativeOutcome(outcome.nativeOutcome),
+			});
+		case "cleanup_pending":
+			return Object.freeze({
+				kind: outcome.kind,
+				...(outcome.nativeOutcome ? { nativeOutcome: serializeNativeOutcome(outcome.nativeOutcome) } : {}),
+			});
+		case "uncertain":
+			return Object.freeze({
+				kind: outcome.kind,
+				reason: outcome.reason,
+				...(outcome.nativeOutcome ? { nativeOutcome: serializeNativeOutcome(outcome.nativeOutcome) } : {}),
+			});
+		default: {
+			const exhaustive: never = outcome;
+			throw new Error(`task_artifact_owner_retirement_outcome_unknown:${String(exhaustive)}`);
+		}
+	}
+}
+
+const OWNER_CLEANUP_KEYS = new Set([
+	"taskArtifactOwnerDeletionEvidence",
+	"taskArtifactOwnerRetirementContinuation",
+	"taskArtifactOwnerRetirementOutcome",
+	"taskArtifactOwnerPayloadRetired",
+	"taskArtifactOwnerNamespaceRetained",
+	"taskArtifactOwnerRetired",
+	"taskArtifactOwnerTranscriptDeleted",
+	"taskArtifactOwnerCleanupError",
+]);
+
+/**
+ * Strictly decode the owner-field projection of cleanup state against trusted session, scope context, phase,
+ * and artifact-removal state. Empty/legacy owner fields decode to an empty result. A decoded completion
+ * remains historical data: any later effect must separately verify current physical absence, fresh scrub
+ * proof, native success and current owner-parent/side-path authority before it mutates storage or transcripts.
+ */
+export function decodeBrokerTaskArtifactOwnerCleanupFields(
+	value: unknown,
+	context: TaskArtifactOwnerStorageContext,
+	expectedSessionId: string,
+	phase: BrokerCleanupPhase,
+	artifactsRemoved: boolean | undefined,
+): BrokerTaskArtifactOwnerCleanupValidation {
+	assertSessionRoot(context);
+	if (!isRecord(value) || Object.keys(value).some(key => !OWNER_CLEANUP_KEYS.has(key)))
+		throw new Error("task_artifact_owner_cleanup_fields_invalid");
+	if (expectedSessionId.length === 0 || (artifactsRemoved !== undefined && typeof artifactsRemoved !== "boolean"))
+		throw new Error("task_artifact_owner_cleanup_fields_invalid");
+
+	const has = (key: string) => Object.hasOwn(value, key);
+	const trueFlag = (key: string): true | undefined => {
+		if (!has(key)) return undefined;
+		if (value[key] !== true) throw new Error("task_artifact_owner_cleanup_flags_invalid");
+		return true;
+	};
+	let deletionEvidence: TaskArtifactOwnerDeletionEvidence | undefined;
+	if (has("taskArtifactOwnerDeletionEvidence")) {
+		deletionEvidence = parseTaskArtifactOwnerDeletionEvidence(value.taskArtifactOwnerDeletionEvidence);
+		if (deletionEvidence.sessionId !== expectedSessionId)
+			throw new Error("task_artifact_owner_cleanup_session_mismatch");
+	}
+	let retirementContinuation: TaskArtifactOwnerRetirementContinuation | undefined;
+	if (has("taskArtifactOwnerRetirementContinuation")) {
+		if (!deletionEvidence) throw new Error("task_artifact_owner_cleanup_evidence_missing");
+		retirementContinuation = parseTaskArtifactOwnerRetirementContinuation(
+			context,
+			deletionEvidence,
+			value.taskArtifactOwnerRetirementContinuation,
+		);
+	}
+	let retirementOutcome: TaskArtifactOwnerRetirementOutcome | undefined;
+	if (has("taskArtifactOwnerRetirementOutcome")) {
+		if (!deletionEvidence) throw new Error("task_artifact_owner_cleanup_evidence_missing");
+		retirementOutcome = parseBrokerTaskArtifactOwnerRetirementDisposition(
+			value.taskArtifactOwnerRetirementOutcome,
+			context,
+			deletionEvidence,
+			retirementContinuation,
+		);
+	}
+
+	const payloadRetired = trueFlag("taskArtifactOwnerPayloadRetired");
+	const namespaceRetained = trueFlag("taskArtifactOwnerNamespaceRetained");
+	const retired = trueFlag("taskArtifactOwnerRetired");
+	const transcriptDeleted = trueFlag("taskArtifactOwnerTranscriptDeleted");
+	let cleanupDiagnostic: string | undefined;
+	if (has("taskArtifactOwnerCleanupError")) {
+		const diagnostic = value.taskArtifactOwnerCleanupError;
+		if (typeof diagnostic !== "string" || diagnostic.length === 0 || diagnostic.length > 4096)
+			throw new Error("task_artifact_owner_cleanup_diagnostic_invalid");
+		cleanupDiagnostic = diagnostic;
+	}
+
+	if (
+		(retired !== undefined && (payloadRetired !== undefined || namespaceRetained !== undefined)) ||
+		(retired !== undefined && retirementOutcome?.kind !== "completed") ||
+		(payloadRetired !== undefined) !== (namespaceRetained !== undefined) ||
+		((retired !== undefined ||
+			payloadRetired !== undefined ||
+			namespaceRetained !== undefined ||
+			transcriptDeleted !== undefined) &&
+			(!deletionEvidence || !retirementOutcome)) ||
+		(transcriptDeleted !== undefined &&
+			(phase !== "artifacts" || artifactsRemoved !== true || retirementOutcome === undefined))
+	)
+		throw new Error("task_artifact_owner_cleanup_state_invalid");
+
+	if (retirementOutcome) {
+		if (
+			(retired !== undefined && retirementOutcome.kind !== "completed") ||
+			(retirementOutcome.kind === "completed" && retired === undefined) ||
+			(payloadRetired !== undefined &&
+				(retirementOutcome.kind !== "payload_retired" || retirementContinuation === undefined)) ||
+			(retirementOutcome.kind === "payload_retired" && payloadRetired === undefined)
+		)
+			throw new Error("task_artifact_owner_cleanup_disposition_mismatch");
+	}
+
+	return Object.freeze({
+		deletionEvidence,
+		retirementContinuation,
+		retirementOutcome,
+		payloadRetired,
+		namespaceRetained,
+		retired,
+		transcriptDeleted,
+		cleanupDiagnostic,
+	});
+}

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: 82,
-	slack: 89,
+	discord: 83,
+	slack: 90,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {

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

@@ -318,6 +318,9 @@ export class ChatDaemonRuntime {
 		this.#router = new SessionRouter({
 			agentDir: input.agentDir,
 			observer: true,
+			// A lean final answer carries no messageRef, so the raw native copy of a
+			// positioned frame has no identity to collapse onto and would post twice.
+			positionedNotificationEffects: true,
 			correlateFrame,
 			deps: {
 				...deps.routerDeps,

package/src/sdk/bus/index.ts

@@ -105,6 +105,7 @@ import {
 	canDeliverSdkEvent,
 	createSdkSurfaceFactory,
 	masterAttestationForEffectiveHost,
+	POSITIONED_NOTIFICATION_EFFECTS_CAPABILITY,
 	reattestMasterSessionIdentity,
 	SESSION_HOST_OBSERVER_CAPABILITY,
 	type SessionSdkHost,
@@ -204,7 +205,6 @@ import {
 	ASK_SELECTED_ACK_CAPABILITY,
 	type EnsureDaemonResult,
 	ensureTelegramDaemonRunningDetailed,
-	POSITIONED_NOTIFICATION_EFFECTS_CAPABILITY,
 } from "./telegram-daemon";
 
 export type {
@@ -3722,8 +3722,8 @@ function sdkControlSurface(
 				return unavailable("model.cycle", "no session model-cycle seam is installed")();
 			return { changed: (await ctx.cycleModel()) !== undefined };
 		},
-		setThinking: level => {
-			api.setThinkingLevel(level as ThinkingLevel);
+		setThinking: async level => {
+			await api.setThinkingLevelForControl(level as ThinkingLevel, false);
 			return { changed: true };
 		},
 		cycleThinking: () => {

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 = 199;
+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

@@ -71,6 +71,7 @@ export {
 	TELEGRAM_TRANSPORT_GENERATION,
 } from "./telegram-daemon-contract";
 
+import { POSITIONED_NOTIFICATION_EFFECTS_CAPABILITY } from "../host/host";
 import {
 	type AgentDirSessionLifecycleService,
 	createSessionLifecycleService,
@@ -303,8 +304,9 @@ export const ASK_CONTROLS_CAPABILITY = "ask_controls_v1";
 export const TOOL_ACTIVITY_CAPABILITY = "tool_activity_v2";
 /** Receive-only compatibility capability for pre-v2 hosts. */
 export const LEGACY_TOOL_ACTIVITY_CAPABILITY = "tool_activity_v1";
-/** Opts notification adapters into positioned-only delivery for matching live effects. */
-export const POSITIONED_NOTIFICATION_EFFECTS_CAPABILITY = "positioned_notification_effects_v1";
+/** Public `sdk/bus/telegram-daemon` path for the canonical `sdk/host` capability token. */
+export { POSITIONED_NOTIFICATION_EFFECTS_CAPABILITY };
+
 type ToolActivityCapability = "v1" | "v2";
 
 function negotiateToolActivityCapability(
@@ -362,6 +364,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 +4570,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 +12879,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 +12942,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 +13023,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 +13111,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();