agent-transport-system 0.7.98 → 0.7.99

package/dist/ats.js

@@ -32,7 +32,7 @@ import { ReadStream, WriteStream } from "node:tty";
 import { performance } from "node:perf_hooks";
 
 //#region package.json
-var version = "0.7.98";
+var version = "0.7.99";
 var package_default = {
 	$schema: "https://www.schemastore.org/package.json",
 	name: "agent-transport-system",
@@ -4386,7 +4386,7 @@ async function getDaemonRuntimeStatus(pathInput = {}) {
 		autoStart: state.autoStart,
 		reason: "invalid_pid"
 	};
-	if (!isPidAlive$5(state.pid)) return {
+	if (!isPidAlive$6(state.pid)) return {
 		status: "stale",
 		mode: state.mode,
 		pid: state.pid,
@@ -4624,7 +4624,7 @@ async function ensureDaemonControlPlaneToken(pathInput = {}) {
 async function readDaemonControlPlaneToken(pathInput = {}) {
 	return (await readDaemonTokenState(pathInput))?.token ?? null;
 }
-function isPidAlive$5(pid) {
+function isPidAlive$6(pid) {
 	try {
 		process.kill(pid, 0);
 		return true;
@@ -7486,7 +7486,7 @@ function resolveDefaultAuthBaseUrl(env) {
 
 //#endregion
 //#region ../../packages/utils/dist/index.js
-function sleep$1(ms) {
+function sleep(ms) {
 	return new Promise((resolve) => {
 		setTimeout(resolve, ms);
 	});
@@ -22805,7 +22805,6 @@ function nowIsoString() {
 	return (/* @__PURE__ */ new Date()).toISOString();
 }
 const toErrorMessage$30 = toErrorMessage$43;
-const sleep = sleep$1;
 function dirnamePath(path) {
 	const lastSlash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
 	if (lastSlash <= 0) return ".";
@@ -33779,7 +33778,7 @@ async function recoverStaleSkillsInstallLock(lockPath) {
 	});
 	if (!lockRaw) return true;
 	const pid = resolveLockPid(parseLockMeta(lockRaw));
-	if (pid && isPidAlive$4(pid)) return false;
+	if (pid && isPidAlive$5(pid)) return false;
 	const latestLockRaw = await readFile(lockPath, "utf8").catch((error) => {
 		if (getErrorCode$2(error) === "ENOENT") return "";
 		throw error;
@@ -33809,7 +33808,7 @@ function resolveLockPid(meta) {
 	const pid = meta.pid;
 	return typeof pid === "number" && Number.isInteger(pid) ? pid : null;
 }
-function isPidAlive$4(pid) {
+function isPidAlive$5(pid) {
 	try {
 		process$1.kill(pid, 0);
 		return true;
@@ -37584,7 +37583,7 @@ async function waitForCondition(input) {
 	const pollMs = input.pollMs ?? SYSTEM_SERVICE_POLL_MS;
 	while (Date.now() < deadline) {
 		if (await input.until()) return;
-		await sleep$1(pollMs);
+		await sleep(pollMs);
 	}
 	throw await input.onTimeout();
 }
@@ -38803,7 +38802,7 @@ function resolveObservedRuntimeCommandEntryPath(input) {
 function resolveRuntimeLeaseIssue(runtimeLease) {
 	if (!runtimeLease) return "runtime_lease_missing";
 	if (!Number.isInteger(runtimeLease.pid) || runtimeLease.pid <= 0) return "invalid_pid";
-	if (!isPidAlive$3(runtimeLease.pid)) return "process_not_alive";
+	if (!isPidAlive$4(runtimeLease.pid)) return "process_not_alive";
 	if (isRuntimeLeaseHeartbeatStale(runtimeLease)) return "heartbeat_stale";
 	return null;
 }
@@ -38831,7 +38830,7 @@ function resolveModePriority(mode) {
 		default: return 2;
 	}
 }
-function isPidAlive$3(pid) {
+function isPidAlive$4(pid) {
 	try {
 		process$1.kill(pid, 0);
 		return true;
@@ -38942,7 +38941,7 @@ async function waitForDaemonSystemServiceToStop(input) {
 		if (!(await input.manager.status().catch(() => null))?.running && currentRuntime?.status !== "running") return true;
 		if (currentRuntime?.status === "stale" && !currentRuntime.managedBySystemService) return true;
 		if (currentRuntime?.status === "not_running") return true;
-		await sleep$1(pollMs);
+		await sleep(pollMs);
 	}
 	const finalRuntime = await readCurrentObservedDaemonRuntimeStatus().catch(() => null);
 	if (finalRuntime?.status === "not_running") return true;
@@ -39848,7 +39847,7 @@ async function waitForSystemServiceStartup(input) {
 			state: "running",
 			runtimeStatus: inventory.runtimeStatus
 		};
-		await sleep$1(input.pollMs);
+		await sleep(input.pollMs);
 	}
 	const finalInventory = await inspectDaemonServiceInventory({
 		expectedVersion: input.expectedVersion,
@@ -48348,6 +48347,39 @@ function resolveLocalAgentEnabledErrorCode$1(error) {
 	return normalized?.includes(".") ? normalized : "agents.unexpected_error";
 }
 
+//#endregion
+//#region src/local-service/carrier/stop-aware-delay.ts
+function createStopAwareDelay() {
+	let interrupted = false;
+	const pendingInterruptNotifiers = /* @__PURE__ */ new Set();
+	return {
+		interrupt: () => {
+			if (interrupted) return;
+			interrupted = true;
+			for (const notifyInterrupted of pendingInterruptNotifiers) notifyInterrupted();
+			pendingInterruptNotifiers.clear();
+		},
+		wait: (delayMs) => {
+			if (interrupted) return Promise.resolve("interrupted");
+			return new Promise((resolve) => {
+				let timer = null;
+				const notifyInterrupted = () => {
+					if (timer) {
+						clearTimeout(timer);
+						timer = null;
+					}
+					resolve("interrupted");
+				};
+				pendingInterruptNotifiers.add(notifyInterrupted);
+				timer = setTimeout(() => {
+					pendingInterruptNotifiers.delete(notifyInterrupted);
+					resolve("elapsed");
+				}, delayMs);
+			});
+		}
+	};
+}
+
 //#endregion
 //#region src/local-service/carrier/service-runner.ts
 var DaemonStreamAuthenticationRequiredError = class extends Error {
@@ -48536,6 +48568,7 @@ const runDaemonServiceLoop = async (input) => {
 		})
 	});
 	let stopRequested = false;
+	const reconnectBackoffDelay = createStopAwareDelay();
 	let reconnectAttempt = 0;
 	let activeSocket = null;
 	const currentSocketRef = {
@@ -48599,6 +48632,7 @@ const runDaemonServiceLoop = async (input) => {
 		if (stopRequested) return;
 		stopRequested = true;
 		connectionState.set("stopping");
+		reconnectBackoffDelay.interrupt();
 		activeSocket?.close(1e3, "shutdown");
 	};
 	const onSigint = () => {
@@ -48651,6 +48685,10 @@ const runDaemonServiceLoop = async (input) => {
 				headers: authContext.headers,
 				openTimeoutMs: DAEMON_STREAM_CONNECT_TIMEOUT_MS
 			});
+			if (stopRequested) {
+				ws.close(1e3, "shutdown");
+				break;
+			}
 			activeSocket = ws;
 			emitRunLine({
 				presenter: input.presenter,
@@ -48709,59 +48747,14 @@ const runDaemonServiceLoop = async (input) => {
 			requestActiveRouteCatalogSync = null;
 			if (stopRequested) break;
 			reconnectAttempt += 1;
-			const errorMessage = toErrorMessage$30(error);
-			const failureReason = classifyConnectionFailureReason(errorMessage);
-			const authState = error instanceof DaemonStreamAuthenticationRequiredError ? error.authState : null;
-			const backoffMs = resolveServiceConnectionReconnectBackoffMs({
-				attempt: reconnectAttempt,
-				reason: failureReason
-			});
-			noteReconnectFailureState({
-				authState,
+			const backoffMs = noteRunLoopReconnectScheduled({
 				connectionState,
-				errorMessage,
-				failureReason,
-				reconnectAttempt
-			});
-			const reconcileDecision = resolveRouteRegistrationReconcileDecision({
-				driftDetected: true,
-				foregroundActive: mode === "foreground"
-			});
-			emitDriftDetectedEvidence({
-				action: reconcileDecision.action,
-				backoffMs,
-				driftClass: reconcileDecision.driftClass,
-				error: errorMessage,
-				foregroundActive: reconcileDecision.foregroundActive,
-				lifecycleLocked: reconcileDecision.lifecycleLocked,
-				owner: reconcileDecision.owner,
-				reconnectAttempt,
-				skipReason: reconcileDecision.skipReason
-			});
-			emitReconcileStartedEvidence({
-				action: reconcileDecision.action,
-				backoffMs,
-				driftClass: reconcileDecision.driftClass,
-				error: errorMessage,
-				foregroundActive: reconcileDecision.foregroundActive,
-				lifecycleLocked: reconcileDecision.lifecycleLocked,
-				owner: reconcileDecision.owner,
-				reconnectAttempt,
-				skipReason: reconcileDecision.skipReason
-			});
-			emitRunLine({
+				error,
+				foregroundActive: mode === "foreground",
 				presenter: input.presenter,
-				code: "daemon.run.reconnect",
-				text: `daemon stream reconnect scheduled in ${String(backoffMs)}ms (${errorMessage})`,
-				payload: {
-					attempt: reconnectAttempt,
-					authState,
-					backoffMs,
-					error: errorMessage,
-					reason: failureReason
-				}
+				reconnectAttempt
 			});
-			await sleep(backoffMs);
+			await reconnectBackoffDelay.wait(backoffMs);
 		}
 	} finally {
 		process.off("SIGINT", onSigint);
@@ -49072,6 +49065,61 @@ function createRunLoopConnectionStateTracker(presenter) {
 		}).catch(() => void 0);
 	} });
 }
+function noteRunLoopReconnectScheduled(input) {
+	const errorMessage = toErrorMessage$30(input.error);
+	const failureReason = classifyConnectionFailureReason(errorMessage);
+	const authState = input.error instanceof DaemonStreamAuthenticationRequiredError ? input.error.authState : null;
+	const backoffMs = resolveServiceConnectionReconnectBackoffMs({
+		attempt: input.reconnectAttempt,
+		reason: failureReason
+	});
+	noteReconnectFailureState({
+		authState,
+		connectionState: input.connectionState,
+		errorMessage,
+		failureReason,
+		reconnectAttempt: input.reconnectAttempt
+	});
+	const reconcileDecision = resolveRouteRegistrationReconcileDecision({
+		driftDetected: true,
+		foregroundActive: input.foregroundActive
+	});
+	emitDriftDetectedEvidence({
+		action: reconcileDecision.action,
+		backoffMs,
+		driftClass: reconcileDecision.driftClass,
+		error: errorMessage,
+		foregroundActive: reconcileDecision.foregroundActive,
+		lifecycleLocked: reconcileDecision.lifecycleLocked,
+		owner: reconcileDecision.owner,
+		reconnectAttempt: input.reconnectAttempt,
+		skipReason: reconcileDecision.skipReason
+	});
+	emitReconcileStartedEvidence({
+		action: reconcileDecision.action,
+		backoffMs,
+		driftClass: reconcileDecision.driftClass,
+		error: errorMessage,
+		foregroundActive: reconcileDecision.foregroundActive,
+		lifecycleLocked: reconcileDecision.lifecycleLocked,
+		owner: reconcileDecision.owner,
+		reconnectAttempt: input.reconnectAttempt,
+		skipReason: reconcileDecision.skipReason
+	});
+	emitRunLine({
+		presenter: input.presenter,
+		code: "daemon.run.reconnect",
+		text: `daemon stream reconnect scheduled in ${String(backoffMs)}ms (${errorMessage})`,
+		payload: {
+			attempt: input.reconnectAttempt,
+			authState,
+			backoffMs,
+			error: errorMessage,
+			reason: failureReason
+		}
+	});
+	return backoffMs;
+}
 function noteReconnectFailureState(input) {
 	if (input.failureReason === "auth_rejected") {
 		input.connectionState.set("authentication_required", {
@@ -52570,6 +52618,150 @@ async function cleanupStaleDaemonRuntimeDataBackups(input = {}) {
 	}
 }
 
+//#endregion
+//#region src/local-service/lifecycle/daemon-service-stalled-force-kill.ts
+const FORCE_KILL_MIN_HEARTBEAT_STALL_MS = 600 * 1e3;
+const FORCE_KILL_EXIT_WAIT_MS = 2e3;
+const FORCE_KILL_EXIT_POLL_MS = 100;
+function resolveStalledDaemonForceKillVerdict(input) {
+	const lease = input.runtimeLease;
+	if (!lease) return {
+		decision: "skip",
+		reason: "runtime_lease_missing",
+		pid: null,
+		heartbeatStalledMs: null
+	};
+	if (!Number.isInteger(lease.pid) || lease.pid <= 0) return {
+		decision: "skip",
+		reason: "lease_pid_invalid",
+		pid: null,
+		heartbeatStalledMs: null
+	};
+	const ownedProcess = input.ownedProcesses.find((candidate) => candidate.pid === lease.pid && candidate.ownership !== "unknown");
+	if (!ownedProcess) return {
+		decision: "skip",
+		reason: "lease_pid_not_owned",
+		pid: lease.pid,
+		heartbeatStalledMs: null
+	};
+	if (ownedProcess.mode === "foreground") return {
+		decision: "skip",
+		reason: "foreground_process",
+		pid: lease.pid,
+		heartbeatStalledMs: null
+	};
+	const freshnessTimestamp = lease.heartbeatAt ?? lease.updatedAt;
+	const heartbeatMs = Date.parse(freshnessTimestamp);
+	if (Number.isNaN(heartbeatMs)) return {
+		decision: "skip",
+		reason: "heartbeat_unparseable",
+		pid: lease.pid,
+		heartbeatStalledMs: null
+	};
+	const heartbeatStalledMs = input.nowMs - heartbeatMs;
+	if (heartbeatStalledMs < FORCE_KILL_MIN_HEARTBEAT_STALL_MS) return {
+		decision: "skip",
+		reason: "heartbeat_fresh",
+		pid: lease.pid,
+		heartbeatStalledMs
+	};
+	return {
+		decision: "force_kill",
+		pid: lease.pid,
+		heartbeatStalledMs
+	};
+}
+const defaultStalledDaemonForceKillDeps = {
+	emitLifecycleEvent: emitDaemonLifecycleEvent,
+	killProcess: (pid, signal) => process$1.kill(pid, signal),
+	listOwnedProcesses: async () => await listDaemonOwnedProcesses({ ignoreProcessIds: [process$1.pid, process$1.ppid].filter((pid) => Number.isInteger(pid) && pid > 0) }),
+	nowMs: () => Date.now(),
+	readRuntimeLease: async () => await readDaemonRuntimeLease(),
+	waitForProcessExit: async (pid) => {
+		const deadline = Date.now() + FORCE_KILL_EXIT_WAIT_MS;
+		while (Date.now() < deadline) {
+			if (!isPidAlive$3(pid)) return true;
+			await sleep(FORCE_KILL_EXIT_POLL_MS);
+		}
+		return !isPidAlive$3(pid);
+	}
+};
+async function forceKillStalledDaemonAfterStopTimeout(input, deps = defaultStalledDaemonForceKillDeps) {
+	const [runtimeLease, ownedProcesses] = await Promise.all([deps.readRuntimeLease().catch(() => null), deps.listOwnedProcesses().catch(() => [])]);
+	const verdict = resolveStalledDaemonForceKillVerdict({
+		nowMs: deps.nowMs(),
+		ownedProcesses,
+		runtimeLease
+	});
+	if (verdict.decision === "skip") {
+		await deps.emitLifecycleEvent({
+			type: "process_stop.action",
+			result: "force_kill_skipped",
+			metadata: {
+				heartbeatStalledMs: verdict.heartbeatStalledMs,
+				pid: verdict.pid,
+				reason: verdict.reason,
+				signal: "SIGKILL",
+				stage: input.stage
+			}
+		});
+		return {
+			killed: false,
+			verdict
+		};
+	}
+	try {
+		deps.killProcess(verdict.pid, "SIGKILL");
+	} catch (error) {
+		if (!isProcessGoneError(error)) {
+			await deps.emitLifecycleEvent({
+				type: "process_stop.action",
+				result: "force_kill_failed",
+				metadata: {
+					errorMessage: error instanceof Error ? error.message : String(error),
+					heartbeatStalledMs: verdict.heartbeatStalledMs,
+					pid: verdict.pid,
+					reason: "stalled_heartbeat_after_stop_timeout",
+					signal: "SIGKILL",
+					stage: input.stage
+				}
+			});
+			return {
+				killed: false,
+				verdict
+			};
+		}
+	}
+	const exited = await deps.waitForProcessExit(verdict.pid);
+	await deps.emitLifecycleEvent({
+		type: "process_stop.action",
+		result: "force_killed",
+		metadata: {
+			exitObserved: exited,
+			heartbeatStalledMs: verdict.heartbeatStalledMs,
+			pid: verdict.pid,
+			reason: "stalled_heartbeat_after_stop_timeout",
+			signal: "SIGKILL",
+			stage: input.stage
+		}
+	});
+	return {
+		killed: true,
+		verdict
+	};
+}
+function isProcessGoneError(error) {
+	return error instanceof Error && error.code === "ESRCH";
+}
+function isPidAlive$3(pid) {
+	try {
+		process$1.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return !(error instanceof Error && error.code === "ESRCH");
+	}
+}
+
 //#endregion
 //#region src/local-service/lifecycle/daemon-service-lifecycle.ts
 const STRICT_TEARDOWN_VERIFY_WAIT_MS$1 = 15e3;
@@ -53126,8 +53318,11 @@ async function stopLifecycleRuntime(input) {
 		stage: "stop_or_drain"
 	});
 	if (await stopDaemonProcessWithTimeout(runtimeStatus.pid, "SIGTERM", input.drainWaitMs)) return;
-	if (!input.forceKillAfterDrainTimeout) throw new DaemonServiceLifecycleDrainTimeoutError(input.drainWaitMs);
-	await stopDaemonProcess$1(runtimeStatus.pid, "SIGKILL");
+	if (input.forceKillAfterDrainTimeout) {
+		await stopDaemonProcess$1(runtimeStatus.pid, "SIGKILL");
+		return;
+	}
+	if (!(await forceKillStalledDaemonAfterStopTimeout({ stage: "stop_or_drain" })).killed) throw new DaemonServiceLifecycleDrainTimeoutError(input.drainWaitMs);
 }
 async function ensureLifecycleRuntimeStopped() {
 	const runtimeAfterStop = await readCurrentObservedDaemonRuntimeStatus();
@@ -53142,11 +53337,15 @@ async function ensureLifecycleRuntimeStopped() {
 }
 async function waitForLifecycleRuntimeStopped(input) {
 	if (input.inventory.runtimeStatus.managedBySystemService || input.inventory.serviceManagerStatus?.installed === true || input.inventory.serviceManagerStatus?.running === true) {
-		if (!await waitForDaemonSystemServiceToStop({
+		if (!(await waitForDaemonSystemServiceToStop({
 			manager: input.serviceManager,
 			waitMs: STRICT_TEARDOWN_VERIFY_WAIT_MS$1,
 			pollMs: STRICT_TEARDOWN_VERIFY_POLL_MS$1
-		})) {
+		}) || (await forceKillStalledDaemonAfterStopTimeout({ stage: "wait_stopped" })).killed && await waitForDaemonSystemServiceToStop({
+			manager: input.serviceManager,
+			waitMs: STRICT_TEARDOWN_VERIFY_WAIT_MS$1,
+			pollMs: STRICT_TEARDOWN_VERIFY_POLL_MS$1
+		}))) {
 			const runtimeAfterWait = await readCurrentObservedDaemonRuntimeStatus();
 			throw new DaemonServiceLifecycleStageError({
 				message: `ATS service is still running after stop phase (pid=${String(runtimeAfterWait.pid)}).`,
@@ -53167,7 +53366,7 @@ async function ensureNoOwnedProcessesRemain() {
 				return;
 			}
 		}
-		await sleep$1(STRICT_TEARDOWN_VERIFY_POLL_MS$1);
+		await sleep(STRICT_TEARDOWN_VERIFY_POLL_MS$1);
 	}
 	const [ownedProcesses, runtimeStatus] = await Promise.all([listDaemonOwnedProcesses({ ignoreProcessIds: [process$1.pid, process$1.ppid].filter((pid) => Number.isInteger(pid) && pid > 0) }), readCurrentObservedDaemonRuntimeStatus()]);
 	if (ownedProcesses.length > 0) throw new DaemonServiceLifecycleStageError({
@@ -53190,7 +53389,7 @@ async function waitForLegacySharedServiceCleanup(input) {
 		});
 		lastInventory = inventory;
 		if (!(inventory.legacySharedService?.present === true || inventory.anomalies.some((anomaly) => anomaly.code === "legacy_shared_service_present"))) return;
-		await sleep$1(STRICT_TEARDOWN_VERIFY_POLL_MS$1);
+		await sleep(STRICT_TEARDOWN_VERIFY_POLL_MS$1);
 	}
 	throw new DaemonServiceLifecycleStageError({
 		message: "ATS Service legacy shared registration is still present after cleanup. reason=legacy_shared_service_present",
@@ -53414,7 +53613,7 @@ async function waitForVerifiedLifecycleInventory(input) {
 		});
 		lastInventory = inventory;
 		lastError = verificationError;
-		await sleep$1(STRICT_TEARDOWN_VERIFY_POLL_MS$1);
+		await sleep(STRICT_TEARDOWN_VERIFY_POLL_MS$1);
 	}
 	throw new DaemonServiceLifecycleStageError({
 		message: lastError ?? "ATS could not verify the final local service inventory state.",
@@ -53553,7 +53752,7 @@ async function waitForProcessToExit$1(pid, timeoutMs) {
 	const deadline = Date.now() + timeoutMs;
 	while (Date.now() < deadline) {
 		if (!isPidAlive$2(pid)) return true;
-		await sleep$1(STRICT_TEARDOWN_VERIFY_POLL_MS$1);
+		await sleep(STRICT_TEARDOWN_VERIFY_POLL_MS$1);
 	}
 	return !isPidAlive$2(pid);
 }
@@ -54204,7 +54403,7 @@ async function terminateDaemonOwnedProcess(pid) {
 	const deadline = Date.now() + AUTO_HEAL_DUPLICATE_WAIT_MS;
 	while (Date.now() < deadline) {
 		if (!isPidAlive$1(pid)) return;
-		await sleep$1(AUTO_HEAL_DUPLICATE_POLL_MS);
+		await sleep(AUTO_HEAL_DUPLICATE_POLL_MS);
 	}
 	if (isPidAlive$1(pid)) process$1.kill(pid, "SIGKILL");
 }
@@ -54417,7 +54616,7 @@ async function waitForDaemonStartupAlignmentSettlement(input) {
 			cliScriptPath: input.cliScriptPath
 		}).catch(() => null);
 		if (!inventory) {
-			await sleep$1(input.pollMs);
+			await sleep(input.pollMs);
 			continue;
 		}
 		const decision = resolveDaemonServiceAlignmentDecision({
@@ -54438,7 +54637,7 @@ async function waitForDaemonStartupAlignmentSettlement(input) {
 			cooldownUntil: null,
 			backupDataPath: null
 		};
-		await sleep$1(input.pollMs);
+		await sleep(input.pollMs);
 	}
 	return null;
 }
@@ -56640,7 +56839,7 @@ async function verifySystemServiceRemovedAfterStrictTeardown(input) {
 			}
 		}
 		if (allRemoved) return;
-		await sleep$1(STRICT_TEARDOWN_VERIFY_POLL_MS);
+		await sleep(STRICT_TEARDOWN_VERIFY_POLL_MS);
 	}
 	for (const manager of managers) {
 		const finalManagerStatus = await manager.status().catch((error) => {
@@ -56677,7 +56876,7 @@ async function ensureRuntimeCleanAfterStrictTeardown(input) {
 				if ((await input.deps.readCurrentObservedDaemonRuntimeStatus()).status === "not_running") return;
 			}
 		}
-		await sleep$1(STRICT_TEARDOWN_VERIFY_POLL_MS);
+		await sleep(STRICT_TEARDOWN_VERIFY_POLL_MS);
 	}
 	const [ownedProcesses, finalRuntime] = await Promise.all([input.deps.listDaemonOwnedProcesses({ ignoreProcessIds: [process.pid] }), input.deps.readCurrentObservedDaemonRuntimeStatus()]);
 	if (finalRuntime.status === "running") throw createStrictTeardownError({
@@ -57284,7 +57483,7 @@ async function runDaemonAfterReinstallStartWithRetry(input) {
 			if (result.ok || isDaemonRunAlreadyRunningReason(result.reason) || normalizeDaemonRunReason(result.reason) === "cancelled") process.exitCode = previousExitCode;
 			if (normalizeDaemonRunReason(result.reason) === "start_failed" && attempt < REINSTALL_START_RETRY_ATTEMPTS) {
 				process.exitCode = previousExitCode;
-				await sleep$1(input.startRetryDelayMs);
+				await sleep(input.startRetryDelayMs);
 				continue;
 			}
 			return {
@@ -57294,7 +57493,7 @@ async function runDaemonAfterReinstallStartWithRetry(input) {
 		} catch (error) {
 			if (attempt < REINSTALL_START_RETRY_ATTEMPTS) {
 				process.exitCode = previousExitCode;
-				await sleep$1(input.startRetryDelayMs);
+				await sleep(input.startRetryDelayMs);
 				continue;
 			}
 			const startupDiagnostic = await readDaemonStartFailureLogDiagnostic({ cursor: startFailureLogCursor });
@@ -57390,7 +57589,7 @@ async function waitForDaemonHealthyAfterReinstall(input) {
 		}).catch(() => null);
 		if (inventory && isDaemonInventoryRunningAndAligned(inventory)) return inventory.runtimeStatus;
 		lastRuntime = inventory?.runtimeStatus ?? await readCurrentObservedDaemonRuntimeStatus();
-		await sleep$1(REINSTALL_VERIFY_POLL_MS);
+		await sleep(REINSTALL_VERIFY_POLL_MS);
 	}
 	const statusText = lastRuntime ? describeDaemonRuntimeStatus(lastRuntime) : "No runtime status available.";
 	throw new Error(`ATS Service repair verification timed out after ${String(input.verifyWaitMs)}ms. ${statusText}`);
@@ -59465,7 +59664,7 @@ async function waitForDetachedBackgroundProcessStartup(child, startupDelayMs, st
 			reason: startupLifecycle,
 			startupOutput: startupOutput.summary()
 		}));
-		await sleep$1(startupPollMs);
+		await sleep(startupPollMs);
 	}
 	const finalStatus = await readCurrentObservedDaemonRuntimeStatus().catch(() => null);
 	if (finalStatus?.status === "running" && finalStatus.pid === child.pid) return;
@@ -64860,7 +65059,7 @@ async function waitForExecutionReadinessAfterBinding(input) {
 			requestContext: input.requestContext
 		});
 		if (isAgentExecutionReadyOrConnecting(latest.agentExecutionReadiness)) return latest;
-		await sleep$1(EXECUTION_READINESS_AFTER_BINDING_RETRY_DELAY_MS);
+		await sleep(EXECUTION_READINESS_AFTER_BINDING_RETRY_DELAY_MS);
 	}
 	return latest;
 }
@@ -99705,7 +99904,7 @@ async function runPrepareSessionExecutor(input) {
 		if (error instanceof PrepareSessionConnectionInterruptedError && reconnectAttempts < PREPARE_SESSION_MAX_RECONNECT_ATTEMPTS) {
 			reconnectAttempts += 1;
 			emitHumanStatus(input, "Reconnecting", ["ATS Web connection was interrupted.", "Reconnecting to the setup session..."]);
-			await sleep$1(PREPARE_SESSION_RECONNECT_DELAY_MS);
+			await sleep(PREPARE_SESSION_RECONNECT_DELAY_MS);
 			initial = await resolvePrepareSessionToken({
 				gatewayUrl: input.gatewayUrl,
 				opaqueToken: input.startSession
@@ -100483,7 +100682,7 @@ async function connectSelectedLocalAgentsToAts(input) {
 	} catch (error) {
 		if (!isTransientSelectedAgentConnectionError(error) || attempt >= REPORT_RUNTIME_CONNECTION_MAX_ATTEMPTS) throw error;
 		lastTransientError = error;
-		await sleep$1(REPORT_RUNTIME_CONNECTION_RETRY_DELAY_MS);
+		await sleep(REPORT_RUNTIME_CONNECTION_RETRY_DELAY_MS);
 	}
 	throw lastTransientError ?? /* @__PURE__ */ new Error("ATS could not connect local agents.");
 }