stim 1.21.0 → 1.23.0

package/dist/{budget-Bs6SxxzO.mjs → budget-DnPX3DXj.mjs}

@@ -1,40 +1,38 @@
-import { _ as debugLog, f as ownership_claim_exports, l as isTermination, m as reportSignal, n as isTimeoutError, p as process_identity_exports, t as getExecutor, u as operationState } from "./exec-_UbtCQcG.mjs";
+import { a as workspaceProcessLockError, b as debugLog, g as process_identity_exports, i as withWorkspaceProcessLock, m as operationState, n as isTimeoutError, p as isTermination, r as WorkspaceProcessCleanupError, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
 import { d as workspaceDir, f as workspaceId$1, g as workspaceStateFile$1, i as sharedBuildCache, m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
-import { D as withConfigLock$1, F as isOnMountedVolume, K as projectDeviceSlots, L as measuredDirectorySize, M as directorySize, N as directorySizeAsync, O as withConfigLockAsync$1, P as formatBytes, R as measuredDirectorySizeAsync, U as deviceSlotPlatforms, _ as loadConfig$1, a as clearDevice, d as getConfigDir, o as clearSupervisor, p as getProject, z as volumeRootFor } from "./config-CYcBF478.mjs";
+import { D as withConfigLock$1, F as isOnMountedVolume, G as projectDeviceSlots, H as deviceSlotPlatforms, L as measuredDirectorySizeAsync, M as directorySize, N as directorySizeAsync, O as withConfigLockAsync$1, P as formatBytes, R as volumeRootFor, _ as loadConfig$1, a as clearDevice, d as getConfigDir, o as clearSupervisor, p as getProject } from "./config-DlrsduwG.mjs";
 import { n as stripAnsi } from "./process-output-Fpl8PYi8.mjs";
-import { a as formatElapsed, l as phaseLine, o as formatLongDuration, s as isAppLaunchError, u as plural } from "./command-output-B1UrjZHL.mjs";
-import { d as writeWorkspaceState, o as updateWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey } from "./workspace-state-Cjuigeeu.mjs";
-import { $t as cancelledError, Gt as childEnvironment, J as resolveProjectSettingsAsync, Qt as cancellableSleep, d as androidLayoutSetting, en as throwIfCancelled, lt as planMetroReach, qt as killOnAbort } from "./settings-CsJDEXgK.mjs";
-import { C as resolvePackageJson, M as readMetroTunnel, N as readPidFile, P as readRemoteSession, i as findProjectRoot$1, j as clearWorkspaceSupervisor, k as clearRemoteSession, s as ownedDeviceLabel, v as detectIsExpo } from "./project-BZNjmW_8.mjs";
+import { a as formatElapsed, l as phaseLine, o as formatLongDuration, s as isAppLaunchError, u as plural } from "./command-output-Db8BqzxH.mjs";
+import { a as killOnAbort, d as cancelledError, f as throwIfCancelled, n as runOperationFileQuiet, r as childEnvironment, t as runOperationFile, u as cancellableSleep } from "./operation-exec-BW0em61G.mjs";
+import { d as writeWorkspaceState, l as withWorkspaceStateLockAsync, o as updateWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey } from "./workspace-state-U08dEzhG.mjs";
+import { J as resolveProjectSettingsAsync, d as androidLayoutSetting, lt as planMetroReach } from "./settings-C7O8A6ZI.mjs";
+import { C as resolvePackageJson, M as readMetroTunnel, N as readPidFile, P as readRemoteSession, i as findProjectRoot$1, j as clearWorkspaceSupervisor, k as clearRemoteSession, s as ownedDeviceLabel, v as detectIsExpo } from "./project-CTLNHCfE.mjs";
 import { r as createNdjsonWriter, s as readNdjsonGenerations$1 } from "./ndjson-CgE_o3Dl.mjs";
-import { f as resolveProjectMetro, l as pidExists, r as killMetroTree } from "./metro-DEXpIhHC.mjs";
-import { C as environmentState, a as removeEasSessionClaim, d as parseWatchRoots, f as parseWatchmanClients, i as recordEasSessionClaim, l as parseSubscriberNames, n as easMachineStateRoot$1, o as removeEasSessionClaimAsync, p as parseWatchmanPid, r as readEasSessionLedger$1, s as compareStimVersions, t as assertEasMachineRootWritable, u as parseTriggerCount, w as formatSpace, y as capacity } from "./eas-session-ledger-op6A54yi.mjs";
-import { i as registeredCaches } from "./cache-manifest-DkkqguoK.mjs";
+import { a as listeningPidsAsync, c as pidExists, d as resolveProjectMetro, h as isMetroRunning, r as killMetroTreeAsync, u as processCwds } from "./metro-DiXtA3Ty.mjs";
+import { C as environmentState, a as removeEasSessionClaim, d as parseWatchRoots, f as parseWatchmanClients, i as recordEasSessionClaim, l as parseSubscriberNames, n as easMachineStateRoot$1, o as removeEasSessionClaimAsync, p as parseWatchmanPid, r as readEasSessionLedger$1, s as compareStimVersions, t as assertEasMachineRootWritable, u as parseTriggerCount, w as formatSpace, y as capacity } from "./eas-session-ledger-BzzsX97d.mjs";
+import { i as registeredCaches } from "./cache-manifest-DSeQjt-Q.mjs";
 import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { c as nativeRunWaitNotice, d as runCancellationSignal, m as claimForEmptying } from "./native-run-DY_RLx3C.mjs";
-import { A as teardownParkedIosSim, C as eraseParkedAvd, E as teardownOwnedAvd, I as listBuildSlots, M as canonical, N as measureDu, O as teardownOwnedIosSim, P as writeUsageCache, R as GC_OUTPUT, a as collectWorkspaceOutputs, f as withIdleWorkspace, j as probePublicHttp, k as teardownParkedAvd, m as resolveSupervisorTarget, r as clearWorkspaceOutputs, w as eraseParkedIosSim, z as recordGcResult } from "./workspaces-BccMFmGQ.mjs";
-import { N as listBuildLocks, a as createDeviceProcessTables, b as leaseIsExpired, g as workspaceActivity, i as createActivityReaderAsync, o as envDir, p as readHostProcessTableAsync, r as createActivityReader, s as idleForMs, x as listLeaseFiles } from "./activity-BzVfHSrY.mjs";
-import { G as parseAvdDeviceProfile, H as ownedAvdSerialResolver, K as parseAvdSystemImage, N as listAvdsAsync, P as listInstalledSystemImages, U as ownedAvdSerialResolverAsync, _ as avdStorageRoots, ct as isStimOwnedSim, d as androidToolPath, dt as dropParked, gt as readParked, o as androidHome, p as avdIniPaths, st as isStimOwnedAvd, z as ownedAvdDirectory } from "./android-DUYkNF4u.mjs";
-import { B as deviceHoldsBundle, D as sanitizeDeviceLabel, b as parseSimctlList, f as listAllIosSimsAsync, g as listUserApps, k as uninstallIosApp, p as listIosDeviceTypesAsync, u as iosSimulatorFailureAdvice, y as parseRuntimeVersion, z as deviceHoldsApk } from "./ios-CpByZy12.mjs";
-import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-1_1OoVW5.mjs";
+import { c as nativeRunWaitNotice, d as runCancellationSignal, m as claimForEmptying } from "./native-run-BUTu8T7A.mjs";
+import { A as teardownParkedAvd, D as teardownOwnedAvd, F as writeUsageCache, L as listBuildSlots, M as probePublicHttp, N as canonical, P as measureDu, T as eraseParkedIosSim, a as collectWorkspaceOutputs, f as withIdleWorkspace, h as resolveSupervisorTarget, j as teardownParkedIosSim, k as teardownOwnedIosSim, r as clearWorkspaceOutputs, w as eraseParkedAvd, z as GC_OUTPUT } from "./workspaces-BxzYlo3P.mjs";
+import { N as listBuildLocks, b as leaseIsExpired, g as workspaceActivity, i as createActivityReaderAsync, o as envDir, p as readHostProcessTableAsync, r as createActivityReader, s as idleForMs, x as listLeaseFiles } from "./activity-B5RtpFda.mjs";
+import { F as listAvdsAsync, G as ownedAvdSerialResolverAsync, I as listInstalledSystemImages, J as parseAvdSystemImage, V as ownedAvdDirectory, W as ownedAvdSerialResolver, d as androidToolPath, lt as isStimOwnedAvd, m as avdIniPaths, o as androidHome, pt as dropParked, q as parseAvdDeviceProfile, ut as isStimOwnedSim, v as avdStorageRoots, vt as readParked } from "./android-C7sVmyI9.mjs";
+import { B as deviceHoldsBundle, D as sanitizeDeviceLabel, b as parseSimctlList, f as listAllIosSimsAsync, g as listUserApps, k as uninstallIosApp, p as listIosDeviceTypesAsync, u as iosSimulatorFailureAdvice, y as parseRuntimeVersion, z as deviceHoldsApk } from "./ios-hcBpnEGk.mjs";
 import { n as supervisorError } from "./errors-ccaPc4ox.mjs";
-import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-DT_F_uVI.mjs";
-import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-CXGP1bsD.mjs";
+import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-D9lEz4aq.mjs";
+import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-BXZ0c7Kb.mjs";
 import { createRequire } from "node:module";
 import { randomUUID } from "node:crypto";
 import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, statfsSync, writeFileSync } from "node:fs";
-import { format } from "node:util";
 import { homedir, platform, totalmem } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, ambientContext, cacheDirRefusal, compiledHelper, configDir, withAmbientContext } from "@stim-cli/core";
 import { BUILD_HISTORY_KEY, BUILD_HISTORY_LIMIT, BUILD_PHASES, DEV_SERVER_STOP_REQUEST_KEY, LAST_BUILD_KEYS, MACHINE_OWNER_KINDS, STATS_VERSION, buildWorkerRoot, decodeStats, isJsonObject, loadConfig, machineCacheUsageFile, parseMissReason, readDevServerStop, readDevServerStopRequest, readJsonObject, readMachineCacheUsage, readRunEstimates, readStats as readStats$1, runId, settingDefinition, settingValueError, statsFile, statsProjectKey as statsProjectKey$1, trimCapacityRefusals, trimCapacityWaits, trimSamples, wholePhases, workspaceBuildDetailFile } from "@stim-cli/core/state";
 import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 import chalk from "chalk";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
-import { access, lstat, readFile, readdir, stat, statfs } from "node:fs/promises";
+import { access, lstat, readFile, readdir, rm, stat, statfs } from "node:fs/promises";
 import { homedir as homedir$1, tmpdir as tmpdir$1 } from "os";
-import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/cache/caches.ts
 function xcodeDerivedDataRoot(env) {
 	return join$1(env.HOME || env.USERPROFILE || homedir$1(), "Library", "Developer", "Xcode", "DerivedData");
@@ -204,10 +202,15 @@ function canonicalCacheDir(dir) {
 	}
 }
 const CACHE_SIZE_TIMEOUT_MS = 6e4;
-async function sizeCaches(caches) {
+async function sizeCaches(caches, operation) {
 	const sized = [];
 	for (const cache of caches) {
-		const bytes = cache.bytes ?? await measuredDirectorySizeAsync(cache.dir, { timeoutMs: CACHE_SIZE_TIMEOUT_MS });
+		operation?.signal.throwIfAborted();
+		const bytes = cache.bytes ?? await measuredDirectorySizeAsync(cache.dir, {
+			timeoutMs: CACHE_SIZE_TIMEOUT_MS,
+			operation,
+			signal: operation?.signal
+		});
 		sized.push(Object.assign({}, cache, bytes === null ? { sizeError: "Size unavailable: measurement failed or exceeded 60 seconds." } : { bytes }));
 	}
 	return sized;
@@ -274,6 +277,69 @@ function pruneCache(cache, { olderThanDays, now = Date.now(), protect, evictByte
 		protectedEntries
 	};
 }
+async function pruneCacheAsync(cache, { olderThanDays, now = Date.now(), signal, operation }) {
+	if (cache.prune === "report-only") return {
+		removed: 0,
+		bytes: 0,
+		skipped: "report-only shared cache; Stim never deletes it"
+	};
+	if (cache.prune === "atomic") return {
+		removed: 0,
+		bytes: 0,
+		skipped: "index-backed; empty it whole or not at all"
+	};
+	if (!cache.files && cacheDirRefusal(cache.dir)) return {
+		removed: 0,
+		bytes: 0,
+		skipped: `${cache.dir} is not a directory this cache owns`
+	};
+	const cutoff = now - olderThanDays * 24 * 60 * 60 * 1e3;
+	let entries = cache.files ?? [cache.dir];
+	for (let depth = 0; !cache.files && depth < (cache.entriesDepth ?? 1); depth++) {
+		const next = [];
+		for (const parent of entries) {
+			signal?.throwIfAborted();
+			const names = await readdir(parent).catch(() => []);
+			next.push(...names.map((name) => join$1(parent, name)));
+		}
+		entries = next;
+	}
+	let removed = 0;
+	let bytes = 0;
+	let failed = 0;
+	for (const entry of entries) {
+		signal?.throwIfAborted();
+		try {
+			const st = await stat(entry);
+			if (Math.max(st.atimeMs, st.mtimeMs) >= cutoff) continue;
+			const size = st.isDirectory() ? await measuredDirectorySizeAsync(entry, {
+				timeoutMs: CACHE_SIZE_TIMEOUT_MS,
+				signal,
+				operation
+			}) : st.size;
+			signal?.throwIfAborted();
+			if ((await stat(entry)).mtimeMs >= cutoff) continue;
+			signal?.throwIfAborted();
+			await rm(entry, {
+				recursive: true,
+				force: true
+			});
+			removed++;
+			bytes += size ?? 0;
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			signal?.throwIfAborted();
+			if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) failed++;
+		}
+	}
+	signal?.throwIfAborted();
+	return {
+		removed,
+		bytes,
+		failed,
+		skipped: null
+	};
+}
 function entriesAtDepth(dir, depth) {
 	let level = [dir];
 	for (let i = 0; i < depth; i++) {
@@ -303,7 +369,10 @@ function helperSource() {
 }
 async function buildHelper(operation) {
 	const exec = getExecutor();
-	if (!(operation ? await exec.runFileQuietAsync("xcode-select", ["-p"], { timeoutMs: READ_TIMEOUT_MS }) : exec.runFileQuiet("xcode-select", ["-p"], { timeoutMs: READ_TIMEOUT_MS }))) return null;
+	if (!(operation ? await runOperationFileQuiet(operation, exec, "xcode-select", ["-p"], {
+		timeoutMs: READ_TIMEOUT_MS,
+		cwd: operation.cwd
+	}) : exec.runFileQuiet("xcode-select", ["-p"], { timeoutMs: READ_TIMEOUT_MS }))) return null;
 	const source = helperSource();
 	try {
 		return await compiledHelper({
@@ -313,7 +382,7 @@ async function buildHelper(operation) {
 			version: "",
 			prune: !operation,
 			compile: async (output) => {
-				await exec.runFileAsync("xcrun", [
+				await runOperationFile(operation, exec, "xcrun", [
 					"swiftc",
 					"-O",
 					"-swift-version",
@@ -321,10 +390,15 @@ async function buildHelper(operation) {
 					"-o",
 					output,
 					source
-				], { timeoutMs: COMPILE_TIMEOUT_MS });
+				], {
+					timeoutMs: COMPILE_TIMEOUT_MS,
+					cwd: operation?.cwd
+				});
 			}
 		});
-	} catch {
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		return null;
 	}
 }
@@ -334,6 +408,7 @@ let built = null;
 let failure = null;
 /** The `stim-footprint` helper, compiled on first use. A success is kept for the process's life; a failure retries after a doubling backoff instead of being pinned forever. */
 function footprintHelper(operation) {
+	if (operation) return buildHelper(operation);
 	const home = configDir();
 	if (built?.home === home) return built.promise;
 	if (failure?.home === home && Date.now() < failure.nextRetryAt) return Promise.resolve(null);
@@ -368,7 +443,10 @@ function parseFootprints(output) {
 /** Every readable process's physical footprint in bytes, or null when the helper is unavailable or fails. */
 async function readFootprints(operation) {
 	const helper = await footprintHelper(operation);
-	const output = helper ? operation ? await getExecutor().runFileQuietAsync(helper, [], { timeoutMs: READ_TIMEOUT_MS }) : getExecutor().runFileQuiet(helper, [], { timeoutMs: READ_TIMEOUT_MS }) : null;
+	const output = helper ? operation ? await runOperationFileQuiet(operation, getExecutor(), helper, [], {
+		timeoutMs: READ_TIMEOUT_MS,
+		cwd: operation.cwd
+	}) : getExecutor().runFileQuiet(helper, [], { timeoutMs: READ_TIMEOUT_MS }) : null;
 	return output === null ? null : parseFootprints(output);
 }
 //#endregion
@@ -890,16 +968,23 @@ function stimWorkspaceOf(pid, parentOf, supervisors) {
 function reclaimableBytes(report, kind) {
 	return report.processes.filter((entry) => entry.reclaimable && (kind === void 0 || entry.cacheKind === kind)).reduce((sum, entry) => sum + entry.bytes, 0);
 }
-const boundWatchman = async (args) => {
-	const answer = JSON.parse(await getExecutor().runFileAsync("watchman", ["--no-spawn", ...args], { timeoutMs: WATCHMAN_TIMEOUT_MS }));
+const boundWatchman = async (args, operation) => {
+	const options = {
+		timeoutMs: WATCHMAN_TIMEOUT_MS,
+		cwd: operation?.cwd
+	};
+	const output = await runOperationFile(operation, getExecutor(), "watchman", ["--no-spawn", ...args], options);
+	const answer = JSON.parse(output);
 	const error = answer?.error;
 	if (error !== void 0) throw new Error(String(error));
 	return answer;
 };
-async function quietly(fn) {
+async function quietly(fn, operation) {
 	try {
 		return await fn();
-	} catch {
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		return null;
 	}
 }
@@ -908,10 +993,11 @@ async function quietly(fn) {
 * known: debug-status lists the asking CLI as a client too.
 */
 async function watchmanClients(operation) {
-	if (reportSignal(operation)) {
+	if (operation) {
 		let self;
-		const output = await getExecutor().runFileQuietAsync("watchman", ["--no-spawn", "debug-status"], {
+		const output = await runOperationFileQuiet(operation, getExecutor(), "watchman", ["--no-spawn", "debug-status"], {
 			timeoutMs: WATCHMAN_TIMEOUT_MS,
+			cwd: operation.cwd,
 			onSpawn: (child) => {
 				self = child.pid;
 			}
@@ -955,25 +1041,29 @@ async function watchmanClients(operation) {
 }
 async function collectWatchmanRoots(pid, progress, operation) {
 	const watchman = boundWatchman;
-	const paths = parseWatchRoots(await quietly(() => watchman(["watch-list"])));
+	const paths = parseWatchRoots(await quietly(() => watchman(["watch-list"], operation), operation));
 	if (!paths) return null;
 	if (progress) phase("daemons", `watchman pid ${pid}: checking ${plural(paths.length, "root")}`, operation);
 	const roots = [];
 	let next = 0;
 	const probe = async () => {
 		while (next < paths.length) {
+			operation?.signal.throwIfAborted();
 			const index = next++;
 			const path = paths[index];
-			const [subscriptions, triggers] = await Promise.all([quietly(() => watchman(["debug-get-subscriptions", path])), quietly(() => watchman(["trigger-list", path]))]);
+			const subscriptions = () => quietly(() => watchman(["debug-get-subscriptions", path], operation), operation);
+			const triggers = () => quietly(() => watchman(["trigger-list", path], operation), operation);
+			const [subscribers, triggered] = operation ? [await subscriptions(), await triggers()] : await Promise.all([subscriptions(), triggers()]);
 			roots[index] = {
 				path,
 				stale: watchmanRootStaleness(path),
-				subscribers: parseSubscriberNames(subscriptions),
-				triggers: parseTriggerCount(triggers)
+				subscribers: parseSubscriberNames(subscribers),
+				triggers: parseTriggerCount(triggered)
 			};
 		}
 	};
-	await Promise.all(Array.from({ length: Math.min(ROOT_PROBES_AT_ONCE, paths.length) }, probe));
+	if (operation) await probe();
+	else await Promise.all(Array.from({ length: Math.min(ROOT_PROBES_AT_ONCE, paths.length) }, probe));
 	return roots;
 }
 function measureOf(pid, rows, footprints) {
@@ -995,39 +1085,60 @@ function supervisorPids() {
 	}
 	return supervisors;
 }
-async function readLsof(pids) {
+async function readLsof(pids, operation) {
 	if (pids.length === 0) return /* @__PURE__ */ new Map();
 	try {
-		return parseLsof(await getExecutor().runFileAsync("lsof", [
+		return parseLsof(await runOperationFile(operation, getExecutor(), "lsof", [
 			"-n",
 			"-P",
 			"-F",
 			"pnT",
 			"-p",
 			pids.join(",")
-		], { timeoutMs: LSOF_TIMEOUT_MS }));
+		], {
+			timeoutMs: LSOF_TIMEOUT_MS,
+			cwd: operation?.cwd,
+			signal: operation?.signal
+		}));
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		const { status, signal: killed, stdout } = error;
 		return status === 1 && !killed && typeof stdout === "string" && stdout ? parseLsof(stdout) : null;
 	}
 }
-async function gradleStatus(command, home) {
+async function gradleStatus(command, home, operation) {
 	if (!command.distribution) return { unknown: "could not find its Gradle distribution on its classpath" };
 	const launcher = join(command.distribution, "bin", "gradle");
 	if (!existsSync(launcher)) return { unknown: `its distribution has no ${launcher}` };
 	try {
-		return parseGradleStatus(await getExecutor().runFileAsync(launcher, [
+		const environment = operation ? childEnvironment(operation.env) : {
+			env: {},
+			omitEnv: []
+		};
+		return parseGradleStatus(await runOperationFile(operation, getExecutor(), launcher, [
 			"--status",
 			"-q",
 			"-g",
 			home
 		], {
+			...environment,
 			cwd: home,
-			env: { JAVA_HOME: command.javaHome },
-			omitEnv: ["GRADLE_OPTS", "JAVA_OPTS"],
+			env: {
+				...environment.env,
+				JAVA_HOME: command.javaHome
+			},
+			omitEnv: [
+				...environment.omitEnv,
+				"GRADLE_OPTS",
+				"JAVA_OPTS"
+			],
+			signal: operation?.signal,
 			timeoutMs: GRADLE_STATUS_TIMEOUT_MS
 		}));
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		return { unknown: `gradle --status failed: ${error.message.split("\n")[0]}` };
 	}
 }
@@ -1053,7 +1164,7 @@ async function collectGradleFacts(rows, byPid, footprints, stimServerRunning, pr
 		kotlin: []
 	};
 	if (progress) phase("daemons", `checking ${plural(gradleRows.length, "Gradle daemon")} and ${plural(kotlinRows.length, "Kotlin daemon")}`, operation);
-	const lsof = await readLsof([...gradleRows.map(({ row }) => row.pid), ...kotlinRows.map((row) => row.pid)]);
+	const lsof = await readLsof([...gradleRows.map(({ row }) => row.pid), ...kotlinRows.map((row) => row.pid)], operation);
 	const workerRoot = buildWorkerRoot();
 	const homes = gradleRows.map(({ row, command }) => {
 		const files = lsof?.get(row.pid)?.files;
@@ -1061,14 +1172,16 @@ async function collectGradleFacts(rows, byPid, footprints, stimServerRunning, pr
 	});
 	const offload = gradleRows.map(({ row }, index) => offloadClientOf(row.command, workerRoot, homes[index] ?? null));
 	const statuses = /* @__PURE__ */ new Map();
-	gradleRows.forEach(({ command }, index) => {
+	for (const [index, { command }] of gradleRows.entries()) {
 		const home = homes[index];
-		if (offload[index] !== null && stimServerRunning) return;
+		if (offload[index] !== null && stimServerRunning) continue;
 		if (home && !statuses.has(groupKey(command, home))) {
 			if (progress) phase("daemons", `gradle --status for Gradle ${command.version} in ${home}`, operation);
-			statuses.set(groupKey(command, home), gradleStatus(command, home));
+			const status = gradleStatus(command, home, operation);
+			statuses.set(groupKey(command, home), status);
+			if (operation) await status;
 		}
-	});
+	}
 	const gradle = [];
 	for (const [index, { row, command }] of gradleRows.entries()) {
 		const home = homes[index] ?? null;
@@ -1102,7 +1215,7 @@ async function collectGradleFacts(rows, byPid, footprints, stimServerRunning, pr
 	};
 }
 async function collectWatchmanFacts(byPid, footprints, progress, operation) {
-	const pid = parseWatchmanPid(await quietly(() => boundWatchman(["get-pid"])));
+	const pid = parseWatchmanPid(await quietly(() => boundWatchman(["get-pid"], operation), operation));
 	if (pid === null) return null;
 	const roots = await collectWatchmanRoots(pid, progress, operation);
 	const clients = (await watchmanClients(operation))?.filter((client) => client.pid !== pid) ?? null;
@@ -1140,7 +1253,8 @@ async function collectMemoryReport(scope, progress = false, operation) {
 		notices: []
 	};
 	if (process.platform === "win32") return report;
-	const rows = await readHostProcessTableAsync();
+	const rows = await readHostProcessTableAsync(operation?.signal, operation);
+	operation?.signal.throwIfAborted();
 	if (rows === null) {
 		report.notices.push("memory sweep skipped: ps did not answer");
 		return report;
@@ -1206,7 +1320,8 @@ function sameProcess(entry, rows) {
 	const row = rows?.get(entry.pid);
 	return Boolean(row && entry.startedAt !== null && row.startedAt === entry.startedAt);
 }
-function signal(pid) {
+function signal(pid, abort) {
+	abort?.throwIfAborted();
 	try {
 		process.kill(pid, "SIGTERM");
 		return null;
@@ -1214,64 +1329,69 @@ function signal(pid) {
 		return error.code === "ESRCH" ? null : error.message;
 	}
 }
-function keep(entry, kind, detail) {
-	console.log(chalk.yellow(`Kept ${processLabel(entry)}: ${detail}`));
-	recordGcResult(kind, "kept", processLabel(entry), {
+function keep(output, entry, kind, detail) {
+	output.log(chalk.yellow(`Kept ${processLabel(entry)}: ${detail}`));
+	output.record(kind, "kept", processLabel(entry), {
 		id: String(entry.pid),
 		bytes: entry.bytes,
 		detail
 	});
 }
-async function reclaimWatchman(before) {
+async function reclaimWatchman(before, output, operation) {
 	let failures = 0;
 	const fresh = await collectMemoryReport({
 		watchman: true,
 		gradle: false
-	}, true);
+	}, true, operation);
 	const daemon = fresh.processes.find((entry) => entry.kind === "watchman");
 	const planned = before.processes.find((entry) => entry.kind === "watchman");
 	if (!daemon || !planned || daemon.pid !== planned.pid) {
-		if (planned) keep(planned, "watchman", "the daemon changed or stopped since the report");
+		if (planned) keep(output, planned, "watchman", "the daemon changed or stopped since the report");
 		return 0;
 	}
 	for (const root of fresh.watchmanRoots.filter((r) => r.stale !== null)) {
+		operation?.signal.throwIfAborted();
 		if (!root.removable) {
-			console.log(chalk.yellow(`Kept the watchman root ${root.path}: ${root.detail}`));
-			recordGcResult("watchmanRoot", "kept", root.path, { detail: root.detail });
+			output.log(chalk.yellow(`Kept the watchman root ${root.path}: ${root.detail}`));
+			output.record("watchmanRoot", "kept", root.path, { detail: root.detail });
 			continue;
 		}
 		try {
-			phase("daemons", `removing stale watchman root ${root.path}`);
-			await boundWatchman(["watch-del", root.path]);
-			console.log(chalk.green(`Removed the stale watchman root ${root.path} (${root.detail})`));
-			recordGcResult("watchmanRoot", "done", root.path, { detail: root.detail });
+			phase("daemons", `removing stale watchman root ${root.path}`, operation);
+			await boundWatchman(["watch-del", root.path], operation);
+			output.log(chalk.green(`Removed the stale watchman root ${root.path} (${root.detail})`));
+			output.record("watchmanRoot", "done", root.path, { detail: root.detail });
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			operation?.signal.throwIfAborted();
 			failures++;
-			console.log(chalk.red(`Could not remove the watchman root ${root.path}: ${error.message}`));
-			recordGcResult("watchmanRoot", "failed", root.path, { detail: error.message });
+			output.log(chalk.red(`Could not remove the watchman root ${root.path}: ${error.message}`));
+			output.record("watchmanRoot", "failed", root.path, { detail: error.message });
 		}
 	}
 	const current = (await collectMemoryReport({
 		watchman: true,
 		gradle: false
-	}, true)).processes.find((entry) => entry.kind === "watchman");
+	}, true, operation)).processes.find((entry) => entry.kind === "watchman");
 	if (!current || current.pid !== daemon.pid) return failures;
 	if (!current.reclaimable) {
-		keep(current, "watchman", current.detail ?? "it could not be proven unused");
+		keep(output, current, "watchman", current.detail ?? "it could not be proven unused");
 		return failures;
 	}
 	try {
-		phase("daemons", `shutting down watchman pid ${current.pid}: no client uses it`);
-		await boundWatchman(["shutdown-server"]);
-		console.log(chalk.green(`Shut down watchman pid ${current.pid}, freeing ${formatBytes(current.bytes)}; the next client that needs it starts it again`));
-		recordGcResult("watchman", "done", processLabel(current), {
+		phase("daemons", `shutting down watchman pid ${current.pid}: no client uses it`, operation);
+		await boundWatchman(["shutdown-server"], operation);
+		output.log(chalk.green(`Shut down watchman pid ${current.pid}, freeing ${formatBytes(current.bytes)}; the next client that needs it starts it again`));
+		output.record("watchman", "done", processLabel(current), {
 			id: String(current.pid),
 			bytes: current.bytes
 		});
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		failures++;
-		console.log(chalk.red(`Could not shut down watchman pid ${current.pid}: ${error.message}`));
-		recordGcResult("watchman", "failed", processLabel(current), {
+		output.log(chalk.red(`Could not shut down watchman pid ${current.pid}: ${error.message}`));
+		output.record("watchman", "failed", processLabel(current), {
 			id: String(current.pid),
 			bytes: current.bytes,
 			detail: error.message
@@ -1279,23 +1399,23 @@ async function reclaimWatchman(before) {
 	}
 	return failures;
 }
-function stopKotlin(entry, rows) {
+function stopKotlin(entry, rows, output, operation) {
 	if (!sameProcess(entry, rows)) {
-		keep(entry, "kotlinDaemon", "the process changed or exited since the check");
+		keep(output, entry, "kotlinDaemon", "the process changed or exited since the check");
 		return 0;
 	}
-	const error = signal(entry.pid);
+	const error = signal(entry.pid, operation?.signal);
 	if (error) {
-		console.log(chalk.red(`Could not stop ${processLabel(entry)}: ${error}`));
-		recordGcResult("kotlinDaemon", "failed", processLabel(entry), {
+		output.log(chalk.red(`Could not stop ${processLabel(entry)}: ${error}`));
+		output.record("kotlinDaemon", "failed", processLabel(entry), {
 			id: String(entry.pid),
 			bytes: entry.bytes,
 			detail: error
 		});
 		return 1;
 	}
-	console.log(chalk.green(`Stopped ${processLabel(entry)}, freeing ${formatBytes(entry.bytes)}`));
-	recordGcResult("kotlinDaemon", "done", processLabel(entry), {
+	output.log(chalk.green(`Stopped ${processLabel(entry)}, freeing ${formatBytes(entry.bytes)}`));
+	output.record("kotlinDaemon", "done", processLabel(entry), {
 		id: String(entry.pid),
 		bytes: entry.bytes
 	});
@@ -1306,33 +1426,34 @@ function stopKotlin(entry, rows) {
 * version is one of them, the daemon's own `gradle --stop` runs for that home; otherwise each idle one gets SIGTERM,
 * because `--stop` also stops the busy daemons of that home and version.
 */
-async function stopGradle(idle, rows) {
+async function stopGradle(idle, rows, output, operation) {
 	let failures = 0;
 	const groups = /* @__PURE__ */ new Map();
 	for (const entry of idle) {
 		const command = parseGradleDaemonCommand(rows?.get(entry.pid)?.command ?? "");
 		if (!command || !entry.gradleHome || !sameProcess(entry, rows)) {
-			keep(entry, "gradleDaemon", "the process changed or exited since the check");
+			keep(output, entry, "gradleDaemon", "the process changed or exited since the check");
 			continue;
 		}
 		const key = groupKey(command, entry.gradleHome);
 		groups.set(key, [...groups.get(key) ?? [], entry]);
 	}
 	for (const [key, entries] of groups) {
+		operation?.signal.throwIfAborted();
 		const [home, , distribution, javaHome] = JSON.parse(key);
 		const command = parseGradleDaemonCommand(rows.get(entries[0].pid).command);
 		const building = runningBuild(listBuildLocks(), listBuildSlots());
 		if (building) {
-			for (const entry of entries) keep(entry, "gradleDaemon", building);
+			for (const entry of entries) keep(output, entry, "gradleDaemon", building);
 			continue;
 		}
-		phase("daemons", `gradle --status for Gradle ${command.version} in ${home}`);
-		let states = await gradleStatus(command, home);
-		let current = hostRows();
+		phase("daemons", `gradle --status for Gradle ${command.version} in ${home}`, operation);
+		let states = await gradleStatus(command, home, operation);
+		let current = await hostRows(operation);
 		const listed = states instanceof Map ? [...states].filter(([, state]) => state !== "stopped") : [];
 		if (distribution !== null && listed.length > 0 && listed.every(([pid, state]) => state === "idle" && entries.some((entry) => entry.pid === pid))) try {
-			phase("daemons", `gradle --stop for Gradle ${command.version} in ${home}`);
-			await getExecutor().runFileAsync(join(distribution, "bin", "gradle"), [
+			phase("daemons", `gradle --stop for Gradle ${command.version} in ${home}`, operation);
+			await runOperationFile(operation, getExecutor(), join(distribution, "bin", "gradle"), [
 				"--stop",
 				"-q",
 				"-g",
@@ -1344,41 +1465,43 @@ async function stopGradle(idle, rows) {
 				timeoutMs: GRADLE_STOP_TIMEOUT_MS
 			});
 			for (const entry of entries) {
-				console.log(chalk.green(`Stopped ${processLabel(entry)} with gradle --stop, freeing ${formatBytes(entry.bytes)}`));
-				recordGcResult("gradleDaemon", "done", processLabel(entry), {
+				output.log(chalk.green(`Stopped ${processLabel(entry)} with gradle --stop, freeing ${formatBytes(entry.bytes)}`));
+				output.record("gradleDaemon", "done", processLabel(entry), {
 					id: String(entry.pid),
 					bytes: entry.bytes
 				});
 			}
 			continue;
 		} catch (error) {
-			console.log(chalk.dim(`gradle --stop failed for ${home}; signalling each idle daemon: ${error.message.split("\n")[0]}`));
-			states = await gradleStatus(command, home);
-			current = hostRows();
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			operation?.signal.throwIfAborted();
+			output.log(chalk.dim(`gradle --stop failed for ${home}; signalling each idle daemon: ${error.message.split("\n")[0]}`));
+			states = await gradleStatus(command, home, operation);
+			current = await hostRows(operation);
 		}
 		for (const entry of entries) {
 			const state = states instanceof Map ? states.get(entry.pid) : void 0;
 			if (!sameProcess(entry, current)) {
-				keep(entry, "gradleDaemon", "the process changed or exited since the check");
+				keep(output, entry, "gradleDaemon", "the process changed or exited since the check");
 				continue;
 			}
 			if (state !== "idle") {
-				keep(entry, "gradleDaemon", state ? `gradle --status now reports it ${state}` : "gradle --status no longer lists it idle");
+				keep(output, entry, "gradleDaemon", state ? `gradle --status now reports it ${state}` : "gradle --status no longer lists it idle");
 				continue;
 			}
-			const error = signal(entry.pid);
+			const error = signal(entry.pid, operation?.signal);
 			if (error) {
 				failures++;
-				console.log(chalk.red(`Could not stop ${processLabel(entry)}: ${error}`));
-				recordGcResult("gradleDaemon", "failed", processLabel(entry), {
+				output.log(chalk.red(`Could not stop ${processLabel(entry)}: ${error}`));
+				output.record("gradleDaemon", "failed", processLabel(entry), {
 					id: String(entry.pid),
 					bytes: entry.bytes,
 					detail: error
 				});
 				continue;
 			}
-			console.log(chalk.green(`Stopped ${processLabel(entry)}, freeing ${formatBytes(entry.bytes)}`));
-			recordGcResult("gradleDaemon", "done", processLabel(entry), {
+			output.log(chalk.green(`Stopped ${processLabel(entry)}, freeing ${formatBytes(entry.bytes)}`));
+			output.record("gradleDaemon", "done", processLabel(entry), {
 				id: String(entry.pid),
 				bytes: entry.bytes
 			});
@@ -1390,8 +1513,9 @@ function stillPlanned(fresh, before, kind) {
 	const planned = new Map(before.processes.filter((entry) => entry.kind === kind).map((entry) => [entry.pid, entry]));
 	return fresh.processes.filter((entry) => entry.kind === kind && planned.get(entry.pid)?.startedAt === entry.startedAt);
 }
-function hostRows() {
-	const rows = createDeviceProcessTables().host();
+async function hostRows(operation) {
+	const rows = await readHostProcessTableAsync(operation?.signal, operation);
+	operation?.signal.throwIfAborted();
 	return rows ? new Map(rows.map((row) => [row.pid, row])) : null;
 }
 const EXIT_WAIT_MS = 1e4;
@@ -1403,37 +1527,40 @@ function alive(pid) {
 		return error.code !== "ESRCH";
 	}
 }
-async function waitForExit(pids) {
+async function waitForExit(pids, operation) {
 	const running = pids.filter(alive);
 	if (running.length === 0) return;
-	phase("daemons", `waiting up to ${EXIT_WAIT_MS / 1e3}s for ${plural(running.length, "Gradle daemon")} to exit: pid ${running.join(", ")}`);
+	phase("daemons", `waiting up to ${EXIT_WAIT_MS / 1e3}s for ${plural(running.length, "Gradle daemon")} to exit: pid ${running.join(", ")}`, operation);
 	const deadline = Date.now() + EXIT_WAIT_MS;
-	while (running.some(alive) && Date.now() < deadline) await new Promise((done) => setTimeout(done, 200));
+	while (running.some(alive) && Date.now() < deadline) await cancellableSleep(200, {
+		signal: operation?.signal,
+		what: "GC daemon shutdown"
+	});
 }
 /** Stops the Gradle daemons first, then re-checks the Kotlin daemons, whose clients those Gradle daemons were. */
-async function reclaimDaemons(before) {
+async function reclaimDaemons(before, output, operation) {
 	const scope = {
 		watchman: false,
 		gradle: true
 	};
-	const gradle = stillPlanned(await collectMemoryReport(scope, true), before, "gradleDaemon");
-	for (const entry of gradle.filter((e) => !e.reclaimable)) keep(entry, "gradleDaemon", entry.detail ?? "it could not be proven idle");
+	const gradle = stillPlanned(await collectMemoryReport(scope, true, operation), before, "gradleDaemon");
+	for (const entry of gradle.filter((e) => !e.reclaimable)) keep(output, entry, "gradleDaemon", entry.detail ?? "it could not be proven idle");
 	const stopping = gradle.filter((entry) => entry.reclaimable);
-	let failures = await stopGradle(stopping, hostRows());
+	let failures = await stopGradle(stopping, await hostRows(operation), output, operation);
 	if (!before.processes.some((entry) => entry.kind === "kotlinDaemon")) return failures;
-	await waitForExit(stopping.map((entry) => entry.pid));
-	const kotlin = stillPlanned(await collectMemoryReport(scope, true), before, "kotlinDaemon");
+	await waitForExit(stopping.map((entry) => entry.pid), operation);
+	const kotlin = stillPlanned(await collectMemoryReport(scope, true, operation), before, "kotlinDaemon");
 	for (const entry of before.processes.filter((e) => e.kind === "kotlinDaemon" && e.reclaimable)) {
 		if (kotlin.some((current) => current.pid === entry.pid) || alive(entry.pid)) continue;
-		console.log(chalk.green(`${processLabel(entry)} exited with its Gradle daemon, freeing ${formatBytes(entry.bytes)}`));
-		recordGcResult("kotlinDaemon", "done", processLabel(entry), {
+		output.log(chalk.green(`${processLabel(entry)} exited with its Gradle daemon, freeing ${formatBytes(entry.bytes)}`));
+		output.record("kotlinDaemon", "done", processLabel(entry), {
 			id: String(entry.pid),
 			bytes: entry.bytes
 		});
 	}
-	const rows = hostRows();
-	for (const entry of kotlin) if (entry.reclaimable) failures += stopKotlin(entry, rows);
-	else keep(entry, "kotlinDaemon", entry.detail ?? "it could not be proven idle");
+	const rows = await hostRows(operation);
+	for (const entry of kotlin) if (entry.reclaimable) failures += stopKotlin(entry, rows, output, operation);
+	else keep(output, entry, "kotlinDaemon", entry.detail ?? "it could not be proven idle");
 	return failures;
 }
 /**
@@ -1442,7 +1569,7 @@ async function reclaimDaemons(before) {
 * Gradle daemon is in `pids` too, since one left running may still be its client. Nothing stops while STIM_HOME scopes
 * the config.
 */
-async function stopIdleGradleDaemons(pids) {
+async function stopIdleGradleDaemons(pids, output = GC_OUTPUT) {
 	if (memorySweepIsScoped()) return 0;
 	const report = await collectMemoryReport({
 		watchman: false,
@@ -1454,7 +1581,7 @@ async function stopIdleGradleDaemons(pids) {
 	return processes.length ? reclaimDaemons({
 		...report,
 		processes
-	}) : 0;
+	}, output) : 0;
 }
 /** Whether `gc --delete --cache <cache>` would act on a memory kind: stop a process or remove a watchman root. */
 function memoryWorkPending(cache, report) {
@@ -1462,10 +1589,11 @@ function memoryWorkPending(cache, report) {
 	return reclaimableBytes(report) > 0 || report.watchmanRoots.some((root) => root.removable);
 }
 /** Acts on the one memory kind `--cache` names: never on an unscoped run or `--cache all`. */
-async function reclaimMemory(cache, report) {
+async function reclaimMemory(cache, report, output = GC_OUTPUT, operation) {
+	operation?.signal.throwIfAborted();
 	const kind = memoryCacheKind(cache);
 	if (!kind || !report || report.processes.length === 0) return 0;
-	return kind === "watchman" ? reclaimWatchman(report) : reclaimDaemons(report);
+	return kind === "watchman" ? reclaimWatchman(report, output, operation) : reclaimDaemons(report, output, operation);
 }
 /** A doctor note when watchman's footprint is over 2 GiB: only a restart shrinks it, and gc says when one is safe. */
 function watchmanFinding(report) {
@@ -2024,7 +2152,6 @@ const DYNAMIC_CONFIG_FILES = [
 	"app.config.mjs",
 	"app.config.cjs"
 ];
-const TIMED_OUT = Symbol("timed-out");
 function dynamicConfigFile(root) {
 	for (const name of DYNAMIC_CONFIG_FILES) if (existsSync(join(root, name))) return name;
 	return null;
@@ -2045,8 +2172,7 @@ function normalizeProvider(raw) {
 	if (raw === null || raw === void 0 || raw === "") return null;
 	if (raw === "eas") return {
 		name: "eas",
-		reference: EAS_PROVIDER_PACKAGE,
-		options: {}
+		reference: EAS_PROVIDER_PACKAGE
 	};
 	if (typeof raw === "object") {
 		const obj = raw;
@@ -2054,8 +2180,7 @@ function normalizeProvider(raw) {
 			const reference = obj.plugin.trim();
 			return {
 				name: reference,
-				reference,
-				options: obj.options && typeof obj.options === "object" ? obj.options : {}
+				reference
 			};
 		}
 	}
@@ -2064,13 +2189,6 @@ function normalizeProvider(raw) {
 function runOptionsFor(platform) {
 	return platform === "android" ? { variant: "debug" } : { configuration: "Debug" };
 }
-function isProviderPlugin(plugin) {
-	if (!plugin || typeof plugin !== "object") return false;
-	const p = plugin;
-	const resolves = typeof p.resolveBuildCache === "function" || typeof p.resolveRemoteBuildCache === "function";
-	const uploads = typeof p.uploadBuildCache === "function" || typeof p.uploadRemoteBuildCache === "function";
-	return resolves && uploads;
-}
 function cacheLevel(value) {
 	return value === "local" || value === "remote" ? value : false;
 }
@@ -2108,6 +2226,8 @@ async function readProjectConfig(root, { context, run = null, timeoutMs = CONFIG
 			root
 		], { timeoutMs });
 	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "STIM_CLAIM_UNAVAILABLE") throw err;
+		context?.signal.throwIfAborted();
 		return { unavailable: `\`expo config --json\` failed: ${firstLine(err)}` };
 	}
 	try {
@@ -2119,20 +2239,6 @@ async function readProjectConfig(root, { context, run = null, timeoutMs = CONFIG
 		return { unavailable: `\`expo config --json\` did not print JSON: ${firstLine(err)}` };
 	}
 }
-async function loadPlugin(projectRoot, reference, { requireFrom = null } = {}) {
-	const localRequire = requireFrom ? requireFrom(projectRoot) : createRequire(join(projectRoot, "package.json"));
-	const file = localRequire.resolve(reference);
-	let mod;
-	try {
-		mod = localRequire(file);
-	} catch (err) {
-		if (err?.code !== "ERR_REQUIRE_ESM") throw err;
-		mod = await import(pathToFileURL(file).href);
-	}
-	const plugin = mod?.default ?? mod;
-	if (!isProviderPlugin(plugin)) throw new Error(`"${reference}" does not export resolveBuildCache and uploadBuildCache functions`);
-	return plugin;
-}
 async function loadProjectProvider(projectRoot, { context, isExpo = true, run = null, requireFrom = null, timeoutMs = CONFIG_TIMEOUT_MS } = {}) {
 	if (!isExpo) return { none: true };
 	const read = await readProjectConfig(projectRoot, {
@@ -2145,41 +2251,33 @@ async function loadProjectProvider(projectRoot, { context, isExpo = true, run =
 	if (!normalized) return { none: true };
 	if (normalized.invalid) return { unavailable: `buildCacheProvider is ${normalized.invalid}, which is not "eas" or { plugin: <module> }` };
 	if (normalized.reference === "@stim-cli/expo-build-cache") return { none: true };
-	let plugin;
+	if (normalized.reference !== "eas-build-cache-provider") return { unavailable: "Custom Expo buildCacheProvider plugins are not supported. Use EAS or a Stim cache provider." };
 	try {
-		if (normalized.reference === "eas-build-cache-provider") {
-			(requireFrom ? requireFrom(projectRoot) : createRequire(join(projectRoot, "package.json"))).resolve(EAS_PROVIDER_PACKAGE);
-			const bin = resolveEasCliBin(projectRoot);
-			if (!bin) return { unavailable: "the EAS build cache needs an installed eas-cli executable" };
-			const entry = expoBinFromPackage(resolvePackageJson(projectRoot, "eas-cli"), "eas") ?? expoBinFromPackage(resolvePackageJson(dirname(realpathSync(bin.file)), "eas-cli"), "eas");
-			if (entry && !/\.(cmd|bat)$/i.test(entry)) return {
-				provider: {
-					easCli: entry,
-					nodeEntry: true
-				},
-				name: normalized.name,
-				owner: ownerFromConfig(read.config)
-			};
-			if (process.platform === "win32") return { unavailable: "the EAS build cache needs an installed eas-cli package to cancel its Node process" };
-			return {
-				provider: { easCli: bin.file },
-				name: normalized.name,
-				owner: ownerFromConfig(read.config)
-			};
-		}
-		plugin = await loadPlugin(projectRoot, normalized.reference, { requireFrom });
+		(requireFrom ? requireFrom(projectRoot) : createRequire(join(projectRoot, "package.json"))).resolve(EAS_PROVIDER_PACKAGE);
+		const bin = resolveEasCliBin(projectRoot);
+		if (!bin) return { unavailable: "the EAS build cache needs an installed eas-cli executable" };
+		const entry = expoBinFromPackage(resolvePackageJson(projectRoot, "eas-cli"), "eas") ?? expoBinFromPackage(resolvePackageJson(dirname(realpathSync(bin.file)), "eas-cli"), "eas");
+		if (entry && !/\.(cmd|bat)$/i.test(entry)) return {
+			provider: {
+				easCli: entry,
+				nodeEntry: true
+			},
+			name: normalized.name,
+			owner: ownerFromConfig(read.config)
+		};
+		if (process.platform === "win32") return { unavailable: "the EAS build cache needs an installed eas-cli package to cancel its Node process" };
+		return {
+			provider: { easCli: bin.file },
+			name: normalized.name,
+			owner: ownerFromConfig(read.config)
+		};
 	} catch (err) {
+		if (err instanceof WorkspaceProcessCleanupError || err instanceof Error && "reportCleanup" in err) throw err;
+		context?.signal.throwIfAborted();
+		operationState(context).runSignal?.throwIfAborted();
 		const missing = err?.code === "MODULE_NOT_FOUND";
 		return { unavailable: normalized.name === "eas" && missing ? `the EAS build cache needs the \`${EAS_PROVIDER_PACKAGE}\` package, which is not installed in this project` : `${normalized.name} could not be loaded: ${firstLine(err)}` };
 	}
-	return {
-		provider: {
-			plugin,
-			options: normalized.options ?? {}
-		},
-		name: normalized.name,
-		owner: ownerFromConfig(read.config)
-	};
 }
 const WHOAMI_TIMEOUT_MS = 15e3;
 const EAS_CLI_PACKAGE = "eas-cli";
@@ -2318,275 +2416,39 @@ async function probeEasAuth({ context, projectRoot, owner, run, resolveBin, time
 		source: bin.source
 	};
 }
-const capturing = [];
-const abandoned = /* @__PURE__ */ new Set();
-let patched = null;
-const PROVIDER_CONTEXT = new AsyncLocalStorage();
-function uploadDestination(lines) {
-	const text = (lines || []).map(stripAnsi);
-	for (const line of text) {
-		const url = /(https?:\/\/[^\s'"]+)/.exec(line)?.[1];
-		if (url !== void 0) return url.replace(/[.,)\]]+$/, "");
-	}
-	for (const line of text) {
-		const slug = /\bto\s+(@?[\w.-]+\/[\w.-]+)/i.exec(line)?.[1];
-		if (slug !== void 0) return slug.replace(/[.,)\]]+$/, "");
-	}
-	return null;
-}
-function providerNote(text) {
-	return `${"cache".padEnd(11)} ${text}`;
-}
-function currentFrame() {
-	const store = PROVIDER_CONTEXT.getStore();
-	return store && (capturing.includes(store) || abandoned.has(store)) ? store : null;
-}
-function install() {
-	if (patched && process.stdout.write === patched.patchedWrite) return;
-	const stdout = process.stdout;
-	const write = stdout.write.bind(stdout);
-	const log = console.log;
-	const passthrough = write;
-	const patchedWrite = ((chunk, encoding, callback) => {
-		const frame = currentFrame();
-		if (!frame) return passthrough(chunk, encoding, callback);
-		const cb = typeof encoding === "function" ? encoding : callback;
-		absorb(frame, typeof chunk === "string" ? chunk : String(chunk));
-		if (typeof cb === "function") cb();
-		return true;
-	});
-	const patchedLog = (...args) => {
-		const frame = currentFrame();
-		if (!frame) return log(...args);
-		absorb(frame, `${format(...args)}\n`);
-	};
-	stdout.write = patchedWrite;
-	console.log = patchedLog;
-	patched = {
-		stdout,
-		write,
-		log,
-		patchedWrite,
-		patchedLog
-	};
-}
-function uninstall() {
-	if (!patched || capturing.length || abandoned.size) return;
-	if (patched.stdout.write === patched.patchedWrite) patched.stdout.write = patched.write;
-	if (console.log === patched.patchedLog) console.log = patched.log;
-	patched = null;
-}
-function absorb(frame, chunk) {
-	try {
-		process.stderr.write(chunk);
-	} catch {}
-	frame.pending += chunk;
-	let index = frame.pending.indexOf("\n");
-	while (index !== -1) {
-		emitLine(frame, frame.pending.slice(0, index));
-		frame.pending = frame.pending.slice(index + 1);
-		index = frame.pending.indexOf("\n");
-	}
-}
-function emitLine(frame, raw) {
-	const line = stripAnsi(raw).trim();
-	if (line === "") return;
-	frame.lines.push(line);
-	const writer = frame.writer();
-	try {
-		writer?.write({
-			src: "build",
-			level: "debug",
-			event: "provider",
-			msg: line
-		});
-	} catch {}
-	frame.onLine?.(line);
-}
-function beginCapture({ logWriter = null, projectRoot = null, platform = null, onLine = null } = {}) {
-	let own = null;
-	const frame = {
-		lines: [],
-		pending: "",
-		onLine,
-		writer: () => {
-			if (logWriter) return logWriter;
-			if (own) return own;
-			if (!projectRoot || !platform) return null;
-			own = createNdjsonWriter(join(workspaceLogsDir$1(projectRoot), `build-${platform}.ndjson`));
-			return own;
-		},
-		close: () => {
-			own?.close?.();
-			own = null;
-		}
-	};
-	capturing.push(frame);
-	install();
-	return frame;
-}
-function endCapture(frame) {
-	if (!frame) return;
-	const at = capturing.lastIndexOf(frame);
-	if (at !== -1) capturing.splice(at, 1);
-	abandoned.delete(frame);
-	if (frame.pending !== "") {
-		const rest = frame.pending;
-		frame.pending = "";
-		emitLine(frame, rest);
-	}
-	frame.close();
-	uninstall();
-}
-function abandonCapture(frame, work) {
-	if (!frame) return;
-	const at = capturing.lastIndexOf(frame);
-	if (at !== -1) capturing.splice(at, 1);
-	abandoned.add(frame);
-	Promise.resolve(work).then(() => endCapture(frame), () => endCapture(frame));
-}
 async function resolveRemote({ context, provider, platform, projectRoot, fingerprintHash, runOptions = null, timeoutMs = RESOLVE_TIMEOUT_MS, logWriter = null } = {}) {
 	if (!provider || !fingerprintHash) return null;
 	const opts = runOptions || runOptionsFor(platform);
-	if ("easCli" in provider) {
-		if (!projectRoot) return null;
-		return easCache("resolve", {
-			file: provider.easCli,
-			nodeEntry: provider.nodeEntry,
-			projectRoot,
-			platform,
-			fingerprintHash,
-			runOptions: opts,
-			timeoutMs,
-			context,
-			logWriter
-		});
-	}
-	const outcome = await withBudget(async () => {
-		const props = {
-			fingerprintHash: await providerFingerprint({
-				provider,
-				platform,
-				projectRoot,
-				runOptions: opts
-			}) ?? fingerprintHash,
-			platform,
-			runOptions: opts,
-			projectRoot
-		};
-		return typeof provider.plugin.resolveBuildCache === "function" ? provider.plugin.resolveBuildCache(props, provider.options) : provider.plugin.resolveRemoteBuildCache(props, provider.options);
-	}, timeoutMs, {
-		logWriter,
+	if (!projectRoot) return null;
+	return easCache("resolve", {
+		file: provider.easCli,
+		nodeEntry: provider.nodeEntry,
 		projectRoot,
-		platform
+		platform,
+		fingerprintHash,
+		runOptions: opts,
+		timeoutMs,
+		context,
+		logWriter
 	});
-	if (outcome.timedOut) return { timedOut: true };
-	if (outcome.error) return { failed: firstLine(outcome.error) };
-	const appPath = typeof outcome.value === "string" ? outcome.value.trim() : "";
-	if (!appPath) return null;
-	if (!existsSync(appPath)) return { failed: `returned ${appPath}, which does not exist` };
-	return { appPath };
 }
 async function uploadRemote({ context, provider, platform, projectRoot, fingerprintHash, buildPath, runOptions = null, timeoutMs = UPLOAD_TIMEOUT_MS, logWriter = null, note = (line) => context ? context.output("stderr", `${line}\n`) : console.error(line) } = {}) {
 	if (!provider || !fingerprintHash || !buildPath) return { skipped: true };
 	const opts = runOptions || runOptionsFor(platform);
-	if ("easCli" in provider) {
-		if (!projectRoot) return { skipped: true };
-		return await easCache("upload", {
-			file: provider.easCli,
-			nodeEntry: provider.nodeEntry,
-			projectRoot,
-			platform,
-			fingerprintHash,
-			runOptions: opts,
-			buildPath,
-			timeoutMs,
-			context,
-			logWriter,
-			note
-		}) ?? { skipped: true };
-	}
-	let announced = false;
-	const onLine = (line) => {
-		if (announced) return;
-		const dest = uploadDestination([line]);
-		if (!dest) return;
-		announced = true;
-		note(providerNote(`uploading to ${dest}`));
-	};
-	const outcome = await withBudget(async () => {
-		const props = {
-			projectRoot,
-			platform,
-			fingerprintHash: await providerFingerprint({
-				provider,
-				platform,
-				projectRoot,
-				runOptions: opts
-			}) ?? fingerprintHash,
-			buildPath,
-			runOptions: opts
-		};
-		return typeof provider.plugin.uploadBuildCache === "function" ? provider.plugin.uploadBuildCache(props, provider.options) : provider.plugin.uploadRemoteBuildCache(props, provider.options);
-	}, timeoutMs, {
-		logWriter,
+	if (!projectRoot) return { skipped: true };
+	return await easCache("upload", {
+		file: provider.easCli,
+		nodeEntry: provider.nodeEntry,
 		projectRoot,
 		platform,
-		onLine
-	});
-	if (outcome.timedOut) return { timedOut: true };
-	if (outcome.error) return { failed: firstLine(outcome.error) };
-	if (typeof outcome.value !== "string" || outcome.value.trim() === "") {
-		const authLine = outcome.lines.find((line) => isEasAuthFailureText(line));
-		return { failed: authLine ? firstLine(authLine) : "the provider returned no upload destination" };
-	}
-	const destination = uploadDestination(outcome.lines);
-	return destination ? {
-		uploaded: true,
-		destination
-	} : { uploaded: true };
-}
-async function providerFingerprint({ provider, platform, projectRoot, runOptions }) {
-	if (typeof provider.plugin.calculateFingerprintHash !== "function") return null;
-	try {
-		const hash = await provider.plugin.calculateFingerprintHash({
-			projectRoot,
-			platform,
-			runOptions
-		}, provider.options);
-		return typeof hash === "string" && hash.trim() !== "" ? hash.trim() : null;
-	} catch {
-		return null;
-	}
-}
-async function withBudget(factory, ms, capture) {
-	let timer = null;
-	const timeout = new Promise((resolve) => {
-		timer = setTimeout(() => resolve(TIMED_OUT), ms);
-		timer?.unref?.();
-	});
-	const frame = beginCapture(capture || {});
-	const work = Promise.resolve().then(() => PROVIDER_CONTEXT.run(frame, factory)).then((value) => ({ value }), (error) => ({ error }));
-	try {
-		const settled = await Promise.race([work, timeout]);
-		if (settled === TIMED_OUT) {
-			abandonCapture(frame, work);
-			return {
-				timedOut: true,
-				lines: frame.lines
-			};
-		}
-		endCapture(frame);
-		return {
-			...settled,
-			lines: frame.lines
-		};
-	} catch (err) {
-		endCapture(frame);
-		throw err;
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
+		fingerprintHash,
+		runOptions: opts,
+		buildPath,
+		timeoutMs,
+		context,
+		logWriter,
+		note
+	}) ?? { skipped: true };
 }
 function firstLine(err) {
 	const line = (String(err?.message || err || "unknown error").trim().split("\n")[0] ?? "").trim();
@@ -5111,7 +4973,7 @@ async function collectEasSessionSweep(config, deps) {
 	const recorded = readRecordedRemoteSessionIds([...Object.keys(config?.projects ?? {}), projectRoot]);
 	const ledgerRoot = deps.easLedgerRoot ?? easMachineStateRoot$1();
 	const ledger = readEasSessionLedger$1(ledgerRoot);
-	const run = deps.runEasFile ?? ((file, args, options) => getExecutor().runFileAsync(file, args, {
+	const run = deps.runEasFile ?? ((file, args, options) => runOperationFile(deps.operation, getExecutor(), file, args, {
 		...options,
 		killSignal: "SIGKILL"
 	}));
@@ -5124,6 +4986,7 @@ async function collectEasSessionSweep(config, deps) {
 	let pageCount = 0;
 	let after = null;
 	while (true) {
+		deps.operation?.signal.throwIfAborted();
 		if (pageCount >= maxPages) return empty([...recorded.notices, `EAS session list exceeded the maximum page limit of ${maxPages} for ${projectRoot}.`]);
 		const remainingMs = deadline - now();
 		if (remainingMs <= 0) return empty([...recorded.notices, `EAS session list exceeded its total time limit for ${projectRoot}.`]);
@@ -5135,6 +4998,8 @@ async function collectEasSessionSweep(config, deps) {
 				omitEnv: PROXY_CREDENTIAL_ENV
 			});
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			deps.operation?.signal.throwIfAborted();
 			return empty([...recorded.notices, `EAS session list failed for ${projectRoot}: ${describeError(error)}`]);
 		}
 		pageCount++;
@@ -5207,6 +5072,7 @@ async function withRemoteSessionGcLocks(projectRoot, deps, fn) {
 	const waitMs = deps.easLockWaitMs ?? EAS_LOCK_WAIT_MS;
 	const maxSnapshots = deps.easLockSnapshotRetries ?? EAS_LOCK_SNAPSHOT_RETRIES;
 	for (let attempt = 0; attempt < maxSnapshots; attempt++) {
+		deps.operation?.signal.throwIfAborted();
 		const roots = easLockRoots(projectRoot, loadConfig$1());
 		const unavailable = unavailableLockRootNotice(roots);
 		if (unavailable) return fn({
@@ -5231,11 +5097,19 @@ async function withRemoteSessionGcLocks(projectRoot, deps, fn) {
 				easSweepBlockedNotice: void 0,
 				easLockedRoots: roots
 			});
-		})() : withLock(roots[index], () => acquire(index + 1), { waitMs });
+		})() : withLock(roots[index], () => acquire(index + 1), {
+			waitMs,
+			...deps.operation ? {
+				signal: deps.operation.signal,
+				declareSpawnsFor: deps.operation
+			} : {}
+		});
 		try {
 			const result = await acquire(0);
 			if (!expanded) return result;
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			deps.operation?.signal.throwIfAborted();
 			if (coreStarted) throw error;
 			return fn({
 				...deps,
@@ -5248,11 +5122,12 @@ async function withRemoteSessionGcLocks(projectRoot, deps, fn) {
 		easSweepBlockedNotice: `EAS session sweep skipped: registered workspace roots kept changing during remote-session lock acquisition.`
 	});
 }
-async function deleteEasSessions(easSessionSweep, deps) {
+async function deleteEasSessions(easSessionSweep, deps, output = GC_OUTPUT) {
+	deps.operation?.signal.throwIfAborted();
 	let deleteFailures = 0;
 	const refuseAll = (detail) => {
 		deleteFailures += easSessionSweep.orphaned.length;
-		for (const session of easSessionSweep.orphaned) recordGcResult("easSession", "failed", session.name, {
+		for (const session of easSessionSweep.orphaned) output.record("easSession", "failed", session.name, {
 			id: session.id,
 			detail
 		});
@@ -5267,7 +5142,7 @@ async function deleteEasSessions(easSessionSweep, deps) {
 				return withRemoteSessionGcLocks(projectScope, deps, async (lockedDeps) => {
 					if (lockedDeps.easSweepBlockedNotice) {
 						refuseAll(`EAS session deletion refused: ${lockedDeps.easSweepBlockedNotice}`);
-						console.log(chalk.red(`EAS session deletion refused: ${lockedDeps.easSweepBlockedNotice}`));
+						output.log(chalk.red(`EAS session deletion refused: ${lockedDeps.easSweepBlockedNotice}`));
 						return;
 					}
 					const coordinatedDeps = lockedDeps;
@@ -5279,29 +5154,35 @@ async function deleteEasSessions(easSessionSweep, deps) {
 					const ledger = readEasSessionLedger$1(ledgerRoot);
 					const removeClaim = coordinatedDeps.removeEasSessionClaim ?? removeEasSessionClaim;
 					const reconcileClaim = (sessionId) => {
+						deps.operation?.signal.throwIfAborted();
 						let detail = "the claim store did not remove it";
 						try {
 							if (removeClaim(sessionId, ledgerRoot)) return;
 						} catch (error) {
+							deps.operation?.signal.throwIfAborted();
 							detail = describeError(error);
 						}
 						deleteFailures++;
-						console.log(chalk.red(`EAS session ${sessionId} is resolved, but its ownership claim could not be removed: ${detail}. The claim was retained for reconciliation.`));
+						output.log(chalk.red(`EAS session ${sessionId} is resolved, but its ownership claim could not be removed: ${detail}. The claim was retained for reconciliation.`));
 					};
 					if (registryExpanded) {
 						refuseAll("EAS session deletion refused: registered workspace roots changed after classification.");
-						console.log(chalk.red("EAS session deletion refused: registered workspace roots changed after classification."));
+						output.log(chalk.red("EAS session deletion refused: registered workspace roots changed after classification."));
 					} else if (!currentRecords?.safe || !ledger.safe) {
 						refuseAll("EAS session deletion refused: the session records could not be read safely.");
-						for (const notice of [...currentRecords?.notices ?? [], ...ledger.notice ? [ledger.notice] : []]) console.log(chalk.red(`EAS session deletion refused: ${notice}`));
+						for (const notice of [...currentRecords?.notices ?? [], ...ledger.notice ? [ledger.notice] : []]) output.log(chalk.red(`EAS session deletion refused: ${notice}`));
 					} else {
 						const recorded = new Set(currentRecords.ids);
 						const eas = (coordinatedDeps.resolveEasCliBin ?? resolveEasCliBin)(projectScope);
-						const run = coordinatedDeps.runEasFile ?? ((file, args, options) => getExecutor().runFile(file, args, options));
+						const run = coordinatedDeps.runEasFile ?? ((file, args, options) => runOperationFile(coordinatedDeps.operation, getExecutor(), file, args, {
+							...options,
+							killSignal: "SIGKILL"
+						}));
 						for (const session of easSessionSweep.orphaned) {
+							deps.operation?.signal.throwIfAborted();
 							if (recorded.has(session.id)) {
-								console.log(chalk.dim(`EAS session ${session.id} has a workspace record and was left running.`));
-								recordGcResult("easSession", "kept", session.name, {
+								output.log(chalk.dim(`EAS session ${session.id} has a workspace record and was left running.`));
+								output.record("easSession", "kept", session.name, {
 									id: session.id,
 									detail: "it has a workspace record and was left running"
 								});
@@ -5311,8 +5192,8 @@ async function deleteEasSessions(easSessionSweep, deps) {
 							const claimState = claim ? claimStateAbsence(claim) : null;
 							if (!claim || claim.name !== session.name || claim.platform !== session.platform || !claimState?.absent || claimState.notice) {
 								deleteFailures++;
-								console.log(chalk.red(`Could not verify fixed ownership for EAS session ${session.id}: ${claimState?.notice ?? "the claim is missing, mismatched, or still recorded in workspace state"}.`));
-								recordGcResult("easSession", "failed", session.name, {
+								output.log(chalk.red(`Could not verify fixed ownership for EAS session ${session.id}: ${claimState?.notice ?? "the claim is missing, mismatched, or still recorded in workspace state"}.`));
+								output.record("easSession", "failed", session.name, {
 									id: session.id,
 									detail: `Could not verify fixed ownership for EAS session ${session.id}: ${claimState?.notice ?? "the claim is missing, mismatched, or still recorded in workspace state"}.`
 								});
@@ -5320,8 +5201,8 @@ async function deleteEasSessions(easSessionSweep, deps) {
 							}
 							if (!eas) {
 								deleteFailures++;
-								console.log(chalk.red(`Could not verify EAS session ${session.id}: eas-cli is not available.`));
-								recordGcResult("easSession", "failed", session.name, {
+								output.log(chalk.red(`Could not verify EAS session ${session.id}: eas-cli is not available.`));
+								output.record("easSession", "failed", session.name, {
 									id: session.id,
 									detail: `Could not verify EAS session ${session.id}: eas-cli is not available.`
 								});
@@ -5335,14 +5216,17 @@ async function deleteEasSessions(easSessionSweep, deps) {
 							let live;
 							try {
 								live = await run(eas.file, getSessionArgs(session.id), options);
+								deps.operation?.signal.throwIfAborted();
 							} catch (error) {
+								if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+								deps.operation?.signal.throwIfAborted();
 								if (isDefinitiveMissingSessionError(error, session.id)) {
-									console.log(chalk.dim(`EAS session ${session.id} is already gone.`));
+									output.log(chalk.dim(`EAS session ${session.id} is already gone.`));
 									reconcileClaim(session.id);
 								} else {
 									deleteFailures++;
-									console.log(chalk.red(`Could not verify EAS session ${session.id}: ${describeError(error)}`));
-									recordGcResult("easSession", "failed", session.name, {
+									output.log(chalk.red(`Could not verify EAS session ${session.id}: ${describeError(error)}`));
+									output.record("easSession", "failed", session.name, {
 										id: session.id,
 										detail: `Could not verify EAS session ${session.id}: ${describeError(error)}`
 									});
@@ -5351,14 +5235,14 @@ async function deleteEasSessions(easSessionSweep, deps) {
 							}
 							const inspection = inspectSessionForTeardown(live, session.id);
 							if (inspection.action === "already-stopped") {
-								console.log(chalk.dim(`EAS session ${session.id} is already stopped (${inspection.status}).`));
+								output.log(chalk.dim(`EAS session ${session.id} is already stopped (${inspection.status}).`));
 								reconcileClaim(session.id);
 								continue;
 							}
 							if (inspection.action === "refused") {
 								deleteFailures++;
-								console.log(chalk.red(`Could not stop EAS session ${session.id}: ${inspection.reason}`));
-								recordGcResult("easSession", "failed", session.name, {
+								output.log(chalk.red(`Could not stop EAS session ${session.id}: ${inspection.reason}`));
+								output.record("easSession", "failed", session.name, {
 									id: session.id,
 									detail: `Could not stop EAS session ${session.id}: ${inspection.reason}`
 								});
@@ -5366,11 +5250,15 @@ async function deleteEasSessions(easSessionSweep, deps) {
 							}
 							let stopped;
 							try {
+								deps.operation?.signal.throwIfAborted();
 								stopped = await run(eas.file, stopSessionArgs(session.id), options);
+								deps.operation?.signal.throwIfAborted();
 							} catch (error) {
+								if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+								deps.operation?.signal.throwIfAborted();
 								deleteFailures++;
-								console.log(chalk.red(`Could not stop EAS session ${session.id}: ${describeError(error)}`));
-								recordGcResult("easSession", "failed", session.name, {
+								output.log(chalk.red(`Could not stop EAS session ${session.id}: ${describeError(error)}`));
+								output.record("easSession", "failed", session.name, {
 									id: session.id,
 									detail: `Could not stop EAS session ${session.id}: ${describeError(error)}`
 								});
@@ -5379,15 +5267,15 @@ async function deleteEasSessions(easSessionSweep, deps) {
 							const verified = verifyStoppedSession(stopped, session.id);
 							if (!verified.ok) {
 								deleteFailures++;
-								console.log(chalk.red(`Could not verify EAS session ${session.id} stopped: ${verified.reason}`));
-								recordGcResult("easSession", "failed", session.name, {
+								output.log(chalk.red(`Could not verify EAS session ${session.id} stopped: ${verified.reason}`));
+								output.record("easSession", "failed", session.name, {
 									id: session.id,
 									detail: `Could not verify EAS session ${session.id} stopped: ${verified.reason}`
 								});
 								continue;
 							}
-							console.log(chalk.green(`Stopped EAS session ${session.id} (${session.name})`));
-							recordGcResult("easSession", "done", session.name, { id: session.id });
+							output.log(chalk.green(`Stopped EAS session ${session.id} (${session.name})`));
+							output.record("easSession", "done", session.name, { id: session.id });
 							reconcileClaim(session.id);
 						}
 					}
@@ -5395,12 +5283,18 @@ async function deleteEasSessions(easSessionSweep, deps) {
 			}, {
 				waitMs: 0,
 				ownerPurpose: "EAS orphan deletion",
-				machineRoot: deps.easLedgerRoot
+				machineRoot: deps.easLedgerRoot,
+				...deps.operation ? {
+					signal: deps.operation.signal,
+					declareSpawnsFor: deps.operation
+				} : {}
 			});
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			deps.operation?.signal.throwIfAborted();
 			const phase = finalSweepStarted ? "failed" : "lock acquisition failed";
 			refuseAll(`EAS session deletion ${phase}: ${describeError(error)}`);
-			console.log(chalk.red(`EAS session deletion ${phase}: ${describeError(error)}`));
+			output.log(chalk.red(`EAS session deletion ${phase}: ${describeError(error)}`));
 		}
 	}
 	return deleteFailures;
@@ -5569,9 +5463,10 @@ function describeUnverifiableDevices(simNames = [], avdNames = [], { reason = "n
 	if (ours.length === 0) return [`${reason}; device sweep skipped`];
 	return [`${reason}, so ${ours.length} stim-created device(s) cannot be verified as orphaned: ${ours.join(", ")}`, "they were NOT touched. If they are stale, delete them with `xcrun simctl delete <udid>` or `avdmanager delete avd -n <name>`"];
 }
-async function withAndroidAvdSizes(devices, { avdDirectory = ownedAvdDirectory, size = directorySizeAsync } = {}) {
+async function withAndroidAvdSizes(devices, { avdDirectory = ownedAvdDirectory, size = directorySizeAsync, operation } = {}) {
 	const sized = [];
 	for (const device of devices) {
+		operation?.signal.throwIfAborted();
 		if (device.kind !== "android") {
 			sized.push(device);
 			continue;
@@ -5582,12 +5477,18 @@ async function withAndroidAvdSizes(devices, { avdDirectory = ownedAvdDirectory,
 			continue;
 		}
 		try {
-			const bytes = await size(dir, { timeoutMs: AVD_SIZE_TIMEOUT_MS });
+			const bytes = await size(dir, {
+				timeoutMs: AVD_SIZE_TIMEOUT_MS,
+				operation,
+				signal: operation?.signal
+			});
 			sized.push(bytes > 0 ? {
 				...device,
 				bytes
 			} : device);
-		} catch {
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
 			sized.push(device);
 		}
 	}
@@ -5615,6 +5516,8 @@ function parkedAtLeast(records, { olderThanDays = null, now = Date.now() }) {
 	return records.filter((record) => Date.parse(record.parkedAt) <= cutoff);
 }
 async function collectParkedSims(deps, age = {}) {
+	const operation = deps.operation;
+	operation?.signal.throwIfAborted();
 	const records = parkedAtLeast(readParked("ios"), age);
 	if (records.length === 0) return [];
 	let sims;
@@ -5622,14 +5525,24 @@ async function collectParkedSims(deps, age = {}) {
 	try {
 		sims = await (deps.listAllIosSims ?? listAllIosSimsAsync)({
 			timeoutMs: DEVICE_LIST_TIMEOUT_MS$1,
-			includeUnavailable: true
+			includeUnavailable: true,
+			operation,
+			signal: operation?.signal
 		});
-	} catch {
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
 		return describeParkedSims(records, [], [], { simsChecked: false });
 	}
 	try {
-		deviceTypes = await (deps.listIosDeviceTypes ?? listIosDeviceTypesAsync)();
-	} catch {}
+		deviceTypes = await (deps.listIosDeviceTypes ?? listIosDeviceTypesAsync)({
+			operation,
+			signal: operation?.signal
+		});
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
+	}
 	return describeParkedSims(records, sims, deviceTypes);
 }
 function poolConfigurationDeviceProfile(configuration) {
@@ -5642,19 +5555,35 @@ function poolConfigurationDeviceProfile(configuration) {
 	}
 }
 async function collectParkedAvds(deps, age = {}) {
+	const operation = deps.operation;
+	operation?.signal.throwIfAborted();
 	const records = parkedAtLeast(readParked("android"), age);
 	if (!records.length) return [];
 	let avds = null;
 	try {
-		avds = await (deps.listAvds ?? listAvdsAsync)();
-	} catch {}
+		avds = await (deps.listAvds ?? listAvdsAsync)({
+			operation,
+			signal: operation?.signal
+		});
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
+	}
 	const reports = [];
 	for (const record of records) {
+		operation?.signal.throwIfAborted();
 		let bytes = null;
 		try {
 			const directory = (deps.avdDirectory ?? ownedAvdDirectory)(record.name);
-			if (directory) bytes = await (deps.directorySize ?? directorySizeAsync)(directory, { timeoutMs: AVD_SIZE_TIMEOUT_MS });
-		} catch {}
+			if (directory) bytes = await (deps.directorySize ?? directorySizeAsync)(directory, {
+				timeoutMs: AVD_SIZE_TIMEOUT_MS,
+				operation,
+				signal: operation?.signal
+			});
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
+		}
 		reports.push({
 			name: record.name,
 			systemImage: record.systemImage,
@@ -5667,7 +5596,7 @@ async function collectParkedAvds(deps, age = {}) {
 	}
 	return reports;
 }
-async function eraseParkedDevices(sims, avds) {
+async function eraseParkedDevices(sims, avds, output = GC_OUTPUT, operation) {
 	let failures = 0;
 	const devices = [...sims.map((sim) => ({
 		platform: "ios",
@@ -5683,74 +5612,82 @@ async function eraseParkedDevices(sims, avds) {
 		bytes: avd.bytes
 	}))];
 	for (const device of devices) {
+		operation?.signal.throwIfAborted();
 		const what = `parked ${device.platform === "ios" ? "ios sim" : "android emulator"} ${device.name}`;
 		if (device.listed !== true) {
 			const unverified = device.listed === null;
 			const detail = unverified ? "Stim could not list devices to verify it; it was kept. Retry stim gc --cache parked --delete." : "it is not on this machine; stim gc --delete drops its pool record.";
 			if (unverified) failures++;
-			console.log((unverified ? chalk.red : chalk.dim)(`Did not erase ${what}: ${detail}`));
-			recordGcResult("parkedDevice", unverified ? "failed" : "kept", device.name, {
+			output.log((unverified ? chalk.red : chalk.dim)(`Did not erase ${what}: ${detail}`));
+			output.record("parkedDevice", unverified ? "failed" : "kept", device.name, {
 				id: device.id,
 				detail
 			});
 			continue;
 		}
-		const result = device.platform === "ios" ? await eraseParkedIosSim(device.id, { label: device.name }) : await eraseParkedAvd(device.id);
+		const result = device.platform === "ios" ? await eraseParkedIosSim(device.id, {
+			label: device.name,
+			operation
+		}) : await eraseParkedAvd(device.id, { operation });
+		operation?.signal.throwIfAborted();
 		if (result.status === "torn-down") {
-			console.log(chalk.green(`Erased ${what}; it stays parked`));
-			recordGcResult("parkedDevice", "done", device.name, {
+			output.log(chalk.green(`Erased ${what}; it stays parked`));
+			output.record("parkedDevice", "done", device.name, {
 				id: device.id,
 				bytes: device.bytes
 			});
 		} else if (result.status === "failed") {
 			failures++;
-			console.log(chalk.red(`Failed to erase ${what}: ${result.reason}`));
-			recordGcResult("parkedDevice", "failed", device.name, {
+			output.log(chalk.red(`Failed to erase ${what}: ${result.reason}`));
+			output.record("parkedDevice", "failed", device.name, {
 				id: device.id,
 				detail: result.reason
 			});
-		} else console.log(chalk.dim(`Skipped ${device.name}; it is no longer parked.`));
+		} else output.log(chalk.dim(`Skipped ${device.name}; it is no longer parked.`));
 	}
 	return failures;
 }
-async function deleteParkedAvds(avds) {
+async function deleteParkedAvds(avds, output = GC_OUTPUT, operation) {
 	let failures = 0;
 	for (const avd of avds) {
+		operation?.signal.throwIfAborted();
 		if (avd.listed === null) {
 			failures++;
-			console.log(chalk.red(`Could not verify parked android emulator ${avd.name}; its pool record was kept.`));
-			recordGcResult("parkedDevice", "failed", avd.name, {
+			output.log(chalk.red(`Could not verify parked android emulator ${avd.name}; its pool record was kept.`));
+			output.record("parkedDevice", "failed", avd.name, {
 				id: avd.name,
 				detail: "Stim could not list emulators to verify it; its pool record was kept. Retry stim gc --delete."
 			});
 			continue;
 		}
-		const result = await teardownParkedAvd(avd.name);
+		const result = await teardownParkedAvd(avd.name, { operation });
+		operation?.signal.throwIfAborted();
 		if (result.status === "failed") {
 			failures++;
-			console.log(chalk.red(`Failed to delete parked android emulator ${avd.name}: ${result.reason}`));
-			recordGcResult("parkedDevice", "failed", avd.name, {
+			output.log(chalk.red(`Failed to delete parked android emulator ${avd.name}: ${result.reason}`));
+			output.record("parkedDevice", "failed", avd.name, {
 				id: avd.name,
 				detail: result.reason
 			});
 		} else if (result.status === "torn-down") {
-			console.log(chalk.green(`Deleted parked android emulator ${avd.name}`));
-			recordGcResult("parkedDevice", "done", avd.name, {
+			output.log(chalk.green(`Deleted parked android emulator ${avd.name}`));
+			output.record("parkedDevice", "done", avd.name, {
 				id: avd.name,
 				bytes: avd.bytes
 			});
-		} else console.log(chalk.dim(`Skipped ${avd.name}; it is no longer parked.`));
+		} else output.log(chalk.dim(`Skipped ${avd.name}; it is no longer parked.`));
 	}
 	return failures;
 }
-async function deleteParkedSims(parkedSims, deps = {}) {
+async function deleteParkedSims(parkedSims, deps = {}, output = GC_OUTPUT) {
 	let failures = 0;
 	let emptied = 0;
 	for (const sim of parkedSims) {
+		deps.operation?.signal.throwIfAborted();
 		if (sim.listed === null) {
 			failures++;
-			console.log(chalk.red(`Could not verify parked ios sim ${sim.name} (${sim.udid}); its pool record was kept.`));
-			recordGcResult("parkedDevice", "failed", sim.name, {
+			output.log(chalk.red(`Could not verify parked ios sim ${sim.name} (${sim.udid}); its pool record was kept.`));
+			output.record("parkedDevice", "failed", sim.name, {
 				id: sim.udid,
 				detail: "Stim could not list simulators to verify it; its pool record was kept. Retry stim gc --delete."
 			});
@@ -5759,35 +5696,38 @@ async function deleteParkedSims(parkedSims, deps = {}) {
 		try {
 			const teardown = sim.listed ? await teardownParkedIosSim(sim.udid, {
 				label: sim.name,
-				deleteSim: deps.deleteParkedIosSim
+				deleteSim: deps.deleteParkedIosSim,
+				operation: deps.operation
 			}) : null;
-			if (!(sim.listed ? teardown?.status === "torn-down" : await dropParked("ios", sim.udid))) {
+			if (!(sim.listed ? teardown?.status === "torn-down" : await dropParked("ios", sim.udid, deps.operation))) {
 				if (teardown?.status === "failed") {
 					failures++;
-					console.log(chalk.red(`Failed to delete parked ios sim ${sim.name}: ${teardown.reason}`));
-					recordGcResult("parkedDevice", "failed", sim.name, {
+					output.log(chalk.red(`Failed to delete parked ios sim ${sim.name}: ${teardown.reason}`));
+					output.record("parkedDevice", "failed", sim.name, {
 						id: sim.udid,
 						detail: teardown.reason
 					});
-				} else console.log(chalk.dim(`Skipped ${sim.name} (${sim.udid}); it is no longer parked.`));
+				} else output.log(chalk.dim(`Skipped ${sim.name} (${sim.udid}); it is no longer parked.`));
 				continue;
 			}
 			emptied++;
-			recordGcResult("parkedDevice", "done", sim.name, {
+			output.record("parkedDevice", "done", sim.name, {
 				id: sim.udid,
 				bytes: sim.listed ? sim.bytes : null
 			});
-			console.log(chalk.green(sim.listed ? `Deleted parked ios sim ${sim.name} (${sim.udid})` : `Dropped the parked record for ${sim.name} (${sim.udid}); it is not on this machine.`));
+			output.log(chalk.green(sim.listed ? `Deleted parked ios sim ${sim.name} (${sim.udid})` : `Dropped the parked record for ${sim.name} (${sim.udid}); it is not on this machine.`));
 		} catch (err) {
+			if (err instanceof WorkspaceProcessCleanupError) throw err;
+			deps.operation?.signal.throwIfAborted();
 			failures++;
-			console.log(chalk.red(`Failed to delete parked ios sim ${sim.name}: ${err?.message || err}`));
-			recordGcResult("parkedDevice", "failed", sim.name, {
+			output.log(chalk.red(`Failed to delete parked ios sim ${sim.name}: ${err?.message || err}`));
+			output.record("parkedDevice", "failed", sim.name, {
 				id: sim.udid,
 				detail: err?.message || String(err)
 			});
 		}
 	}
-	if (emptied) console.log(chalk.dim(`  emptied ${plural(emptied, "parked simulator")} from the pool`));
+	if (emptied) output.log(chalk.dim(`  emptied ${plural(emptied, "parked simulator")} from the pool`));
 	return failures;
 }
 function deviceSweepIsScoped(env = process.env) {
@@ -5821,13 +5761,16 @@ function collectDeviceLeases(now) {
 		kept
 	};
 }
-async function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords) {
+async function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords, output = GC_OUTPUT, operation) {
 	let deleteFailures = 0;
 	async function reap(d, onlyIfMissing = false) {
+		operation?.signal.throwIfAborted();
 		const r = d.kind === "ios" ? await teardownOwnedIosSim(d.id, {
 			del: true,
-			label: d.name
+			label: d.name,
+			operation
 		}) : await teardownOwnedAvd(d.name, {
+			operation,
 			del: true,
 			onlyIfMissing,
 			..."project" in d ? { owner: {
@@ -5835,7 +5778,7 @@ async function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRe
 				slot: d.slot
 			} } : {},
 			..."project" in d ? { onRemoved: () => {
-				if (clearDevice(d.project, d.kind, d.slot, d.id)) console.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
+				if (clearDevice(d.project, d.kind, d.slot, d.id)) output.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
 			} } : {},
 			..."orphanedDirectory" in d ? { orphanedDirectory: d.orphanedDirectory } : {}
 		});
@@ -5845,19 +5788,19 @@ async function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRe
 			bytes: d.bytes ?? null
 		};
 		if (r.status === "torn-down") {
-			console.log(chalk.green(`Deleted ${what}`));
-			recordGcResult("device", "done", d.name, result);
-		} else if (r.status === "missing") console.log(chalk.dim(`${what} is already gone; nothing to delete.`));
+			output.log(chalk.green(`Deleted ${what}`));
+			output.record("device", "done", d.name, result);
+		} else if (r.status === "missing") output.log(chalk.dim(`${what} is already gone; nothing to delete.`));
 		else if (r.status === "skipped") {
-			console.log(chalk.yellow(`Skipped ${what}: ${r.reason} -- left for a later gc`));
-			recordGcResult("device", "kept", d.name, {
+			output.log(chalk.yellow(`Skipped ${what}: ${r.reason} -- left for a later gc`));
+			output.record("device", "kept", d.name, {
 				...result,
 				detail: `${r.reason}; left for a later gc`
 			});
 		} else {
 			deleteFailures++;
-			console.log(chalk.red(`Failed to delete ${d.kind} device ${d.name}: ${r.reason}`));
-			recordGcResult("device", "failed", d.name, {
+			output.log(chalk.red(`Failed to delete ${d.kind} device ${d.name}: ${r.reason}`));
+			output.record("device", "failed", d.name, {
 				...result,
 				detail: r.reason
 			});
@@ -5869,20 +5812,24 @@ async function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRe
 		const status = await reap(d);
 		if (d.kind === "ios" && (status === "torn-down" || status === "missing")) {
 			clearDevice(d.project, d.kind, d.slot, d.id);
-			console.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
+			output.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
 		}
 	}
-	for (const r of staleDeviceRecords) if (r.kind === "android" && r.owned) await reap({
-		...r,
-		name: r.id,
-		idleDays: 0
-	}, true);
-	else if (await withConfigLockAsync$1(() => {
-		if (r.kind === "android" && deviceSlotPlatforms(getProject(r.project), r.slot)?.android?.owned) return false;
-		return clearDevice(r.project, r.kind, r.slot, r.id);
-	})) {
-		console.log(chalk.green(`Cleared the ${r.kind} record for ${r.project} (${r.id} is not on this machine)`));
-		recordGcResult("deviceRecord", "done", r.project, { id: r.id });
+	for (const r of staleDeviceRecords) {
+		operation?.signal.throwIfAborted();
+		if (r.kind === "android" && r.owned) await reap({
+			...r,
+			name: r.id,
+			idleDays: 0
+		}, true);
+		else if (await withConfigLockAsync$1(() => {
+			operation?.signal.throwIfAborted();
+			if (r.kind === "android" && deviceSlotPlatforms(getProject(r.project), r.slot)?.android?.owned) return false;
+			return clearDevice(r.project, r.kind, r.slot, r.id);
+		}, operation?.signal)) {
+			output.log(chalk.green(`Cleared the ${r.kind} record for ${r.project} (${r.id} is not on this machine)`));
+			output.record("deviceRecord", "done", r.project, { id: r.id });
+		}
 	}
 	return deleteFailures;
 }
@@ -6094,14 +6041,16 @@ function listAvdRecords(notices, env) {
 	}
 	return [...records.values()];
 }
-function simctl(args, env) {
-	return getExecutor().runFileAsync("xcrun", ["simctl", ...args], {
+function simctl(args, env, operation) {
+	return runOperationFile(operation, getExecutor(), "xcrun", ["simctl", ...args], {
 		timeoutMs: DEVICE_LIST_TIMEOUT_MS$1,
 		killSignal: "SIGKILL",
-		env
+		env,
+		cwd: operation?.cwd
 	});
 }
-async function collectInventory(config, deadProjects, env = process.env) {
+async function collectInventory(config, deadProjects, env = process.env, operation) {
+	operation?.signal.throwIfAborted();
 	const childEnv = Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== void 0));
 	const notices = [];
 	let sims = [];
@@ -6112,8 +6061,10 @@ async function collectInventory(config, deadProjects, env = process.env) {
 				"list",
 				"devices",
 				"--json"
-			], childEnv));
+			], childEnv, operation));
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			operation?.signal.throwIfAborted();
 			notices.push(`simulators not listed: ${describeError(error)}`);
 		}
 		try {
@@ -6121,8 +6072,10 @@ async function collectInventory(config, deadProjects, env = process.env) {
 				"runtime",
 				"list",
 				"-j"
-			], childEnv));
+			], childEnv, operation));
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			operation?.signal.throwIfAborted();
 			notices.push(`simulator runtime images not listed: ${describeError(error)}`);
 		}
 		try {
@@ -6130,8 +6083,10 @@ async function collectInventory(config, deadProjects, env = process.env) {
 				"list",
 				"runtimes",
 				"-j"
-			], childEnv), runtimes));
+			], childEnv, operation), runtimes));
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			operation?.signal.throwIfAborted();
 			notices.push(`simulator runtimes not listed: ${describeError(error)}`);
 		}
 	}
@@ -6225,29 +6180,37 @@ function readWrapper(path) {
 		return missing$1(error) ? null : "unreadable";
 	}
 }
-async function projectWrapperRoots(project) {
+async function projectWrapperRoots(project, operation) {
 	try {
-		const { context, settings } = await resolveProjectSettingsAsync(project);
+		const { context, settings } = await resolveProjectSettingsAsync(project, {
+			env: operation?.env,
+			signal: operation?.signal,
+			declareFor: operation
+		});
 		return {
 			roots: [project, androidLayoutSetting(settings, project, context.repoRoot ?? project).gradleRoot],
 			resolved: true
 		};
-	} catch {
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		return {
 			roots: [project],
 			resolved: false
 		};
 	}
 }
-async function projectPins(project) {
+async function projectPins(project, operation) {
+	operation?.signal.throwIfAborted();
 	if (!isDirectory(project)) return {
 		versions: [],
 		unreadable: true
 	};
-	const { roots, resolved } = await projectWrapperRoots(project);
+	const { roots, resolved } = await projectWrapperRoots(project, operation);
 	let unreadable = !resolved;
 	const versions = [];
 	for (const root of roots) {
+		operation?.signal.throwIfAborted();
 		const text = readWrapper(join(root, "gradle", "wrapper", "gradle-wrapper.properties"));
 		if (text === null) continue;
 		const version = text === "unreadable" ? null : parseWrapperVersion(text);
@@ -6260,13 +6223,16 @@ async function projectPins(project) {
 	};
 }
 /** The Gradle versions registered projects pin in their wrapper, and the projects whose pin cannot be read. */
-async function projectGradleVersions(projects) {
+async function projectGradleVersions(projects, operation) {
 	const used = /* @__PURE__ */ new Map();
 	const unreadable = [];
-	const pins = await Promise.all(projects.map(async (project) => ({
+	const read = async (project) => ({
 		project,
-		...await projectPins(project)
-	})));
+		...await projectPins(project, operation)
+	});
+	const pins = [];
+	if (operation) for (const project of projects) pins.push(await read(project));
+	else pins.push(...await Promise.all(projects.map(read)));
 	for (const { project, versions, unreadable: partial } of pins) {
 		if (partial) unreadable.push(project);
 		for (const version of new Set(versions)) used.set(version, [...used.get(version) ?? [], project]);
@@ -6293,40 +6259,61 @@ function parseSimRuntimes(runtimeList, deviceList) {
 function parseXcodeBuildVersion(output) {
 	return output ? /^Build version (\S+)/m.exec(output)?.[1] ?? null : null;
 }
-async function quiet(file, args) {
+async function quiet(file, args, operation) {
 	try {
-		return await getExecutor().runFileAsync(file, args, {
+		return await runOperationFile(operation, getExecutor(), file, args, {
 			timeoutMs: TOOL_TIMEOUT_MS,
-			killSignal: "SIGKILL"
+			killSignal: "SIGKILL",
+			cwd: operation?.cwd,
+			signal: operation?.signal
 		});
-	} catch {
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		return null;
 	}
 }
-async function measure(dirs) {
+async function measure(dirs, operation) {
 	const darwin = process.platform === "darwin";
-	const [sizes, runtimeList, deviceList, agentDevice, xcode] = await Promise.all([
-		Promise.all(dirs.map(async (dir) => {
-			const result = await measureDu(["-sk", dir]);
-			return {
-				dir,
-				bytes: result.complete ? result.sizes.get(dir) ?? null : null
-			};
-		})),
-		darwin ? quiet("xcrun", [
-			"simctl",
-			"runtime",
-			"list",
-			"-j"
-		]) : null,
-		darwin ? quiet("xcrun", [
-			"simctl",
-			"list",
-			"devices",
-			"--json"
-		]) : null,
-		quiet("agent-device", ["--version"]),
-		darwin ? quiet("xcodebuild", ["-version"]) : null
+	const size = async (dir) => {
+		const result = await measureDu(["-sk", dir], operation);
+		return {
+			dir,
+			bytes: result.complete ? result.sizes.get(dir) ?? null : null
+		};
+	};
+	const measureSizes = async () => {
+		if (!operation) return Promise.all(dirs.map(size));
+		const sizes = [];
+		for (const dir of dirs) sizes.push(await size(dir));
+		return sizes;
+	};
+	const runtimes = () => darwin ? quiet("xcrun", [
+		"simctl",
+		"runtime",
+		"list",
+		"-j"
+	], operation) : null;
+	const devices = () => darwin ? quiet("xcrun", [
+		"simctl",
+		"list",
+		"devices",
+		"--json"
+	], operation) : null;
+	const agent = () => quiet("agent-device", ["--version"], operation);
+	const version = () => darwin ? quiet("xcodebuild", ["-version"], operation) : null;
+	const [sizes, runtimeList, deviceList, agentDevice, xcode] = operation ? [
+		await measureSizes(),
+		await runtimes(),
+		await devices(),
+		await agent(),
+		await version()
+	] : await Promise.all([
+		measureSizes(),
+		runtimes(),
+		devices(),
+		agent(),
+		version()
 	]);
 	return {
 		version: 1,
@@ -6426,7 +6413,7 @@ function assembleMachineCacheReport(usage, discovery, gradleUse, agentDeviceUsag
 }
 async function getMachineCacheReport(agentDeviceUsage, { maxAgeMs = MAX_AGE_MS, operation } = {}) {
 	const discovery = discover(operation?.env, operation?.cwd);
-	const gradleUse = await projectGradleVersions(Object.keys(loadConfig$1()?.projects ?? {}));
+	const gradleUse = await projectGradleVersions(Object.keys(loadConfig$1()?.projects ?? {}), operation);
 	const dirs = [
 		...[...discovery.versionDirs].filter(([version]) => !gradleUse.used.has(version)).flatMap(([, list]) => list),
 		...discovery.modulesDir ? [discovery.modulesDir] : [],
@@ -6436,7 +6423,7 @@ async function getMachineCacheReport(agentDeviceUsage, { maxAgeMs = MAX_AGE_MS,
 	const age = cached ? Date.now() - Date.parse(cached.measuredAt) : Infinity;
 	let usage = cached;
 	if (!usage || age < 0 || age >= maxAgeMs || JSON.stringify(usage.roots) !== JSON.stringify(dirs)) {
-		usage = await measure(dirs);
+		usage = await measure(dirs, operation);
 		writeUsageCache(machineCacheUsageFile(), usage, operation?.signal);
 	}
 	return assembleMachineCacheReport(usage, discovery, gradleUse, agentDeviceUsage, operation?.env);
@@ -6554,15 +6541,24 @@ function mayUseHome(command, homes) {
 		return real !== null && !homes.includes(real);
 	}));
 }
-async function gradleProcesses(home, env = process.env, cwd = process.cwd()) {
+async function gradleProcesses(home, env = process.env, cwd = process.cwd(), signal, operation) {
+	signal?.throwIfAborted();
 	let table;
 	try {
-		table = await getExecutor().runFileAsync("ps", [
+		table = await runOperationFile(operation, getExecutor(), "ps", [
 			"-axww",
 			"-o",
 			"pid=,command="
-		], { timeoutMs: PS_TIMEOUT_MS });
+		], {
+			timeoutMs: PS_TIMEOUT_MS,
+			cwd,
+			...childEnvironment(env),
+			signal
+		});
+		signal?.throwIfAborted();
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		signal?.throwIfAborted();
 		return describeError(error);
 	}
 	const homes = [.../* @__PURE__ */ new Set([home, gradleUserHomeSetting(env, cwd)])];
@@ -6576,8 +6572,8 @@ function insideConfigDir(dir) {
 	const rel = relative(realpathOrNull(config) ?? config, dir);
 	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
 }
-async function liveBlock(home, { pastRunning = false, env = process.env, cwd = process.cwd() } = {}) {
-	const processes = await gradleProcesses(home, env, cwd);
+async function liveBlock(home, { pastRunning = false, env = process.env, cwd = process.cwd(), operation } = {}) {
+	const processes = await gradleProcesses(home, env, cwd, operation?.signal, operation);
 	const config = loadConfig$1();
 	if (config === null) return {
 		blocked: {
@@ -6588,7 +6584,8 @@ async function liveBlock(home, { pastRunning = false, env = process.env, cwd = p
 		running: null,
 		runningPids: []
 	};
-	const { used, unreadable } = await projectGradleVersions(Object.keys(config.projects ?? {}));
+	const { used, unreadable } = await projectGradleVersions(Object.keys(config.projects ?? {}), operation);
+	operation?.signal.throwIfAborted();
 	const pinned = new Set(used.keys());
 	if (typeof processes === "string") return {
 		blocked: {
@@ -6635,7 +6632,8 @@ function stagedDirs(home) {
 		}
 	});
 }
-async function sweepState(pastRunning = false, env = process.env, cwd = process.cwd()) {
+async function sweepState(pastRunning = false, env = process.env, cwd = process.cwd(), operation) {
+	operation?.signal.throwIfAborted();
 	const home = gradleUserHome(env, cwd);
 	const empty = {
 		home,
@@ -6679,7 +6677,8 @@ async function sweepState(pastRunning = false, env = process.env, cwd = process.
 		...await liveBlock(home, {
 			pastRunning,
 			env,
-			cwd
+			cwd,
+			operation
 		})
 	};
 }
@@ -6713,12 +6712,15 @@ function judgeVersion(version, dirs, state, olderThanDays, now, maxEntries = MAX
 		detail: null
 	};
 }
-async function directoryBytes(dirs) {
-	const sizes = await Promise.all(dirs.map(async (dir) => {
-		const result = await measureDu(["-sk", dir]);
+async function directoryBytes(dirs, operation) {
+	const size = async (dir) => {
+		const result = await measureDu(["-sk", dir], operation);
 		return result.complete ? result.sizes.get(dir) ?? null : null;
-	}));
-	return sizes.includes(null) ? null : sizes.reduce((sum, size) => sum + (size ?? 0), 0);
+	};
+	const sizes = [];
+	if (operation) for (const dir of dirs) sizes.push(await size(dir));
+	else sizes.push(...await Promise.all(dirs.map(size)));
+	return sizes.includes(null) ? null : sizes.reduce((sum, bytes) => sum + (bytes ?? 0), 0);
 }
 /**
 * The Gradle versions under GRADLE_USER_HOME that no registered project pins, each with whether `--delete` removes
@@ -6726,8 +6728,8 @@ async function directoryBytes(dirs) {
 * removal left. Shared caches such as `modules-2` are never candidates.
 */
 async function collectGradleVersions({ olderThanDays = null, now = Date.now(), measure = true, maxWalkEntries = MAX_WALK_ENTRIES, pastRunningGradle = false, operation } = {}) {
-	const state = await sweepState(pastRunningGradle, operation?.env ?? process.env, operation?.cwd);
-	const versions = await Promise.all([...state.versionDirs].filter(([version]) => !state.pinned.has(version)).map(async ([version, dirs]) => {
+	const state = await sweepState(pastRunningGradle, operation?.env ?? process.env, operation?.cwd, operation);
+	const read = async ([version, dirs]) => {
 		let tree;
 		if (operation && !state.blocked && dirs.every((dir) => plainChild(dir, state.home))) {
 			tree = {
@@ -6737,8 +6739,12 @@ async function collectGradleVersions({ olderThanDays = null, now = Date.now(), m
 			};
 			for (const dir of dirs) await walkAsync(dir, tree, maxWalkEntries, operation.signal);
 		}
-		return Object.assign(judgeVersion(version, dirs, state, olderThanDays, now, maxWalkEntries, tree), { bytes: measure ? await directoryBytes(dirs) : null });
-	}));
+		return Object.assign(judgeVersion(version, dirs, state, olderThanDays, now, maxWalkEntries, tree), { bytes: measure ? await directoryBytes(dirs, operation) : null });
+	};
+	const entries = [...state.versionDirs].filter(([version]) => !state.pinned.has(version));
+	const versions = [];
+	if (operation) for (const entry of entries) versions.push(await read(entry));
+	else versions.push(...await Promise.all(entries.map(read)));
 	return {
 		home: state.home,
 		olderThanDays,
@@ -6769,19 +6775,32 @@ function stage(dir) {
 * Checks one version again and removes its directories when it is still unpinned and unused: each directory is
 * renamed to a `.stim-delete-*` sibling right after the last process and pin check, then deleted.
 */
-async function deleteGradleVersion(version, { olderThanDays = null, now = Date.now() } = {}) {
-	const state = await sweepState();
+async function deleteGradleVersion(version, { olderThanDays = null, now = Date.now(), operation } = {}) {
+	const state = await sweepState(false, operation?.env, operation?.cwd, operation);
 	const dirs = state.versionDirs.get(version) ?? [];
 	if (dirs.length === 0 && !state.blocked) return {
 		deleted: false,
 		detail: "its directories are already gone"
 	};
-	const judged = judgeVersion(version, dirs, state, olderThanDays, now);
+	let tree;
+	if (operation && !state.blocked && dirs.every((dir) => plainChild(dir, state.home))) {
+		tree = {
+			newestMs: 0,
+			entries: 0,
+			error: null
+		};
+		for (const dir of dirs) await walkAsync(dir, tree, MAX_WALK_ENTRIES, operation.signal);
+	}
+	const judged = judgeVersion(version, dirs, state, olderThanDays, now, MAX_WALK_ENTRIES, tree);
 	if (!judged.willDelete) return {
 		deleted: false,
 		detail: judged.detail ?? "it is no longer eligible"
 	};
-	const live = await liveBlock(state.home);
+	const live = await liveBlock(state.home, {
+		env: operation?.env,
+		cwd: operation?.cwd,
+		operation
+	});
 	if (live.blocked) return {
 		deleted: false,
 		detail: live.blocked.detail
@@ -6794,56 +6813,71 @@ async function deleteGradleVersion(version, { olderThanDays = null, now = Date.n
 		deleted: false,
 		detail: `one of its paths is no longer a plain directory inside ${state.home}`
 	};
+	operation?.signal.throwIfAborted();
 	const staged = dirs.map(stage);
-	for (const dir of staged) rmSync(dir, {
-		recursive: true,
-		force: true
-	});
+	for (const dir of staged) {
+		operation?.signal.throwIfAborted();
+		await rm(dir, {
+			recursive: true,
+			force: true
+		});
+	}
 	return {
 		deleted: true,
 		detail: dirs.join(", ")
 	};
 }
-function deleteLeftovers(sweep) {
+async function deleteLeftovers(sweep, output, operation) {
 	let failures = 0;
-	for (const dir of sweep.leftovers) try {
-		rmSync(dir, {
-			recursive: true,
-			force: true
-		});
-		console.log(chalk.green(`Finished deleting ${dir}`));
-		recordGcResult("gradleVersion", "done", basename(dir), { id: dir });
-	} catch (error) {
-		failures += 1;
-		console.log(chalk.red(`Failed to finish deleting ${dir}: ${describeError(error)}`));
-		recordGcResult("gradleVersion", "failed", basename(dir), {
-			id: dir,
-			detail: describeError(error)
-		});
+	for (const dir of sweep.leftovers) {
+		operation?.signal.throwIfAborted();
+		try {
+			await rm(dir, {
+				recursive: true,
+				force: true
+			});
+			output.log(chalk.green(`Finished deleting ${dir}`));
+			output.record("gradleVersion", "done", basename(dir), { id: dir });
+		} catch (error) {
+			operation?.signal.throwIfAborted();
+			failures += 1;
+			output.log(chalk.red(`Failed to finish deleting ${dir}: ${describeError(error)}`));
+			output.record("gradleVersion", "failed", basename(dir), {
+				id: dir,
+				detail: describeError(error)
+			});
+		}
 	}
 	return failures;
 }
-async function deleteGradleVersions(sweep) {
+async function deleteGradleVersions(sweep, output = GC_OUTPUT, operation) {
+	operation?.signal.throwIfAborted();
 	if (!sweep) return 0;
-	let failures = deleteLeftovers(sweep);
+	let failures = await deleteLeftovers(sweep, output, operation);
 	for (const entry of sweep.versions) {
+		operation?.signal.throwIfAborted();
 		if (!entry.willDelete) continue;
 		try {
-			const result = await deleteGradleVersion(entry.version, { olderThanDays: sweep.olderThanDays });
+			const result = await deleteGradleVersion(entry.version, {
+				olderThanDays: sweep.olderThanDays,
+				operation
+			});
 			if (result.deleted) {
-				console.log(chalk.green(`Deleted Gradle ${entry.version}: ${result.detail}`));
-				recordGcResult("gradleVersion", "done", `Gradle ${entry.version}`, {
+				output.log(chalk.green(`Deleted Gradle ${entry.version}: ${result.detail}`));
+				output.record("gradleVersion", "done", `Gradle ${entry.version}`, {
 					bytes: entry.bytes,
 					id: entry.dirs[0]
 				});
 			} else {
-				console.log(chalk.yellow(`Kept Gradle ${entry.version}: ${result.detail}`));
-				recordGcResult("gradleVersion", "kept", `Gradle ${entry.version}`, { detail: result.detail });
+				output.log(chalk.yellow(`Kept Gradle ${entry.version}: ${result.detail}`));
+				output.record("gradleVersion", "kept", `Gradle ${entry.version}`, { detail: result.detail });
 			}
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			operation?.signal.throwIfAborted();
 			failures += 1;
-			console.log(chalk.red(`Failed to delete Gradle ${entry.version}: ${describeError(error)}`));
-			recordGcResult("gradleVersion", "failed", `Gradle ${entry.version}`, { detail: describeError(error) });
+			output.log(chalk.red(`Failed to delete Gradle ${entry.version}: ${describeError(error)}`));
+			output.record("gradleVersion", "failed", `Gradle ${entry.version}`, { detail: describeError(error) });
 		}
 	}
 	return failures;
@@ -6950,15 +6984,17 @@ function previewScopedEmptying(caches, env = process.env) {
 function ownsItsDirectory(cache) {
 	return !Array.isArray(cache.files) && !cacheDirRefusal(cache.dir);
 }
-function emptyCache(cache) {
+async function emptyCache(cache, signal, operation) {
 	if (cache.prune === "report-only") return {
 		removed: 0,
 		bytes: 0,
 		skipped: "report-only shared cache; Stim never deletes it"
 	};
-	if (cache.prune !== "atomic") return pruneCache(cache, {
+	if (cache.prune !== "atomic") return pruneCacheAsync(cache, {
 		olderThanDays: 0,
-		now: Date.now() + DAY_MS
+		now: Date.now() + DAY_MS,
+		signal,
+		operation
 	});
 	const claim = claimForEmptying(cache.dir);
 	if (typeof claim === "string") return {
@@ -6969,8 +7005,9 @@ function emptyCache(cache) {
 	try {
 		let names;
 		try {
-			names = readdirSync$1(cache.dir);
+			names = await readdir(cache.dir);
 		} catch (e) {
+			signal?.throwIfAborted();
 			return {
 				removed: 0,
 				bytes: 0,
@@ -6979,15 +7016,19 @@ function emptyCache(cache) {
 		}
 		let removed = 0;
 		let failed = 0;
-		for (const name of names) try {
-			rmSync$1(join$1(cache.dir, name), {
-				recursive: true,
-				force: true
-			});
-			removed++;
-		} catch {
-			failed++;
+		for (const name of names) {
+			signal?.throwIfAborted();
+			try {
+				await rm(join$1(cache.dir, name), {
+					recursive: true,
+					force: true
+				});
+				removed++;
+			} catch {
+				failed++;
+			}
 		}
+		signal?.throwIfAborted();
 		return {
 			removed,
 			bytes: failed ? 0 : cache.bytes ?? 0,
@@ -7009,12 +7050,13 @@ function reportFailures(cache, failed, { log, record, fail }) {
 	fail();
 	return true;
 }
-function trimCaches(caches, olderThan, output = GC_OUTPUT) {
+async function trimCaches(caches, olderThan, output = GC_OUTPUT, signal, operation) {
 	const { log, record } = output;
 	let cacheBytes = 0;
 	let failures = 0;
 	const trimmed = [];
 	for (const c of caches) {
+		signal?.throwIfAborted();
 		if (c.machineGlobal) {
 			log(chalk.yellow(`Left ${c.name} alone: ${c.machineGlobal}`));
 			record("cache", "kept", c.name, {
@@ -7023,7 +7065,11 @@ function trimCaches(caches, olderThan, output = GC_OUTPUT) {
 			});
 			continue;
 		}
-		const r = pruneCache(c, { olderThanDays: olderThan });
+		const r = await pruneCacheAsync(c, {
+			olderThanDays: olderThan,
+			signal,
+			operation
+		});
 		if (r.skipped) {
 			log(chalk.yellow(`Left ${c.name} alone: ${r.skipped}`));
 			record("cache", "kept", c.name, {
@@ -7047,10 +7093,11 @@ function trimCaches(caches, olderThan, output = GC_OUTPUT) {
 		failures
 	};
 }
-function emptyCaches(caches, output = GC_OUTPUT) {
+async function emptyCaches(caches, output = GC_OUTPUT, signal, operation) {
 	const { log, record } = output;
 	let cacheBytes = 0;
 	for (const c of caches) {
+		signal?.throwIfAborted();
 		if (!c.willEmpty) {
 			log(chalk.yellow(`Left ${c.name} alone: ${c.emptySkipped}`));
 			record("cache", "kept", c.name, {
@@ -7059,7 +7106,7 @@ function emptyCaches(caches, output = GC_OUTPUT) {
 			});
 			continue;
 		}
-		const r = emptyCache(c);
+		const r = await emptyCache(c, signal, operation);
 		if (r.skipped) {
 			log(chalk.yellow(`Left ${c.name} alone: ${r.skipped}`));
 			record("cache", "kept", c.name, {
@@ -8285,17 +8332,24 @@ function collectIdleDevices(config, sims, deadProjects, now = Date.now(), env) {
 		buildInProgress: workspaceBuildInProgress
 	});
 }
-async function deviceActivityInputsAsync(config, sims, now, env, deadProjects = []) {
-	const resolve = ownedAvdSerialResolverAsync({ timeoutMs: 5e3 });
+async function deviceActivityInputsAsync(config, sims, now, env, deadProjects = [], signal, operation) {
+	const resolve = ownedAvdSerialResolverAsync({
+		timeoutMs: 5e3,
+		signal,
+		operation
+	});
 	const serials = /* @__PURE__ */ new Map();
 	for (const [project, record] of Object.entries(config?.projects ?? {})) {
+		signal?.throwIfAborted();
 		if (deadProjects.includes(project)) continue;
 		for (const { platforms } of projectDeviceSlots(record)) {
 			const android = platforms.android;
 			if (!android?.owned || !android.avdName || serials.has(android.avdName)) continue;
 			try {
 				serials.set(android.avdName, (await resolve(android.avdName)).serial ?? null);
-			} catch {
+			} catch (error) {
+				if (error instanceof WorkspaceProcessCleanupError) throw error;
+				signal?.throwIfAborted();
 				serials.set(android.avdName, null);
 			}
 		}
@@ -8305,18 +8359,20 @@ async function deviceActivityInputsAsync(config, sims, now, env, deadProjects =
 		sims,
 		readActivity: createActivityReaderAsync({
 			now,
-			env
+			env,
+			signal,
+			operation
 		}),
 		androidSerial: (name) => serials.get(name) ?? null
 	};
 }
-async function collectOwnedDeviceActivityAsync(config, sims, now = Date.now(), env) {
-	const devices = findOwnedDeviceActivity(await deviceActivityInputsAsync(config, sims, now, env));
+async function collectOwnedDeviceActivityAsync(config, sims, now = Date.now(), env, signal, operation) {
+	const devices = findOwnedDeviceActivity(await deviceActivityInputsAsync(config, sims, now, env, [], signal, operation));
 	return Promise.all(devices.map(async (device) => Object.assign({}, device, { activity: await device.activity })));
 }
-async function collectIdleDevicesAsync(config, sims, deadProjects, now = Date.now(), env) {
+async function collectIdleDevicesAsync(config, sims, deadProjects, now = Date.now(), env, signal, operation) {
 	const pending = findOwnedDeviceActivity({
-		...await deviceActivityInputsAsync(config, sims, now, env, deadProjects),
+		...await deviceActivityInputsAsync(config, sims, now, env, deadProjects, signal, operation),
 		deadProjects
 	});
 	return idleDevicesFromActivity(await Promise.all(pending.map(async (device) => Object.assign({}, device, { activity: await device.activity }))), workspaceBuildInProgress, now);
@@ -8330,7 +8386,8 @@ function idleDeviceLines(devices) {
 		return `  ${d.kind}${slot} ${d.name} (${d.project}) -- ${idle}${build}`;
 	})];
 }
-async function shutDownIdleDevices(devices, idleMs, recollect, { log, record } = GC_OUTPUT) {
+async function shutDownIdleDevices(devices, idleMs, recollect, { log, record } = GC_OUTPUT, signal, operation) {
+	signal?.throwIfAborted();
 	const candidates = idleShutdownCandidates(devices, idleMs);
 	const shutDown = [];
 	if (candidates.length === 0) {
@@ -8341,8 +8398,10 @@ async function shutDownIdleDevices(devices, idleMs, recollect, { log, record } =
 		};
 	}
 	const fresh = idleShutdownCandidates(await recollect(), idleMs);
+	signal?.throwIfAborted();
 	let failures = 0;
 	for (const device of candidates) {
+		signal?.throwIfAborted();
 		const what = `${device.kind} ${device.name}`;
 		const current = fresh.find((d) => d.kind === device.kind && d.id === device.id && d.project === device.project && d.slot === device.slot);
 		if (!current) {
@@ -8353,10 +8412,16 @@ async function shutDownIdleDevices(devices, idleMs, recollect, { log, record } =
 			});
 			continue;
 		}
-		const outcome = device.kind === "ios" ? await teardownOwnedIosSim(device.id, { label: device.name }) : await teardownOwnedAvd(device.id, { owner: {
-			projectPath: device.project,
-			slot: device.slot
-		} });
+		const outcome = device.kind === "ios" ? await teardownOwnedIosSim(device.id, {
+			label: device.name,
+			operation
+		}) : await teardownOwnedAvd(device.id, {
+			owner: {
+				projectPath: device.project,
+				slot: device.slot
+			},
+			operation
+		});
 		if (outcome.status === "torn-down") {
 			shutDown.push(device);
 			log(chalk.green(`Shut down ${what}, idle ${formatLongDuration(current.idleForMs)}`));
@@ -8477,7 +8542,18 @@ function describeMetroLastStop(stop) {
 }
 //#endregion
 //#region src/supervisor/cache-reset.ts
-async function stopOwnedMetro(root, requester) {
+async function stopOwnedMetro(root, requester, signal) {
+	const resolve = async (port, probeSignal) => {
+		throwIfCancelled(probeSignal, "Metro reset");
+		const result = await resolveProjectMetro(port, root, {
+			pidsOf: (candidate) => listeningPidsAsync(candidate, process.platform, probeSignal),
+			cwdOf: async (pid) => (await processCwds([pid], probeSignal)).get(pid) ?? null,
+			probe: (candidate) => isMetroRunning(candidate, probeSignal)
+		});
+		throwIfCancelled(probeSignal, "Metro reset");
+		return result;
+	};
+	throwIfCancelled(signal, "Metro reset");
 	const project = getProject(root);
 	const port = project?.metroPort;
 	const target = resolveSupervisorTarget({
@@ -8489,7 +8565,7 @@ async function stopOwnedMetro(root, requester) {
 		status: "unverified",
 		reason: target.reason ?? "unknown identity"
 	};
-	if (port && target.status !== "ours" && !(await resolveProjectMetro(port, root)).missing) return {
+	if (port && target.status !== "ours" && !(await resolve(port, signal)).missing) return {
 		status: "external",
 		reason: `a dev server Stim did not start answers on port ${port}`
 	};
@@ -8498,23 +8574,24 @@ async function stopOwnedMetro(root, requester) {
 		pid: target.pid,
 		processToken: target.processToken
 	};
-	requestDevServerStop(root, target.processToken, requester);
-	const signalled = killMetroTree(target.pid, target.processToken);
-	if (!signalled) withdrawDevServerStopRequest(root, target.processToken);
+	await withWorkspaceStateLockAsync(root, () => requestDevServerStop(root, target.processToken, requester), signal);
+	const signalled = await killMetroTreeAsync(target.pid, target.processToken);
+	if (!signalled) await withWorkspaceStateLockAsync(root, () => withdrawDevServerStopRequest(root, target.processToken));
 	if (!signalled || !await (0, process_identity_exports.waitForProcessExit)(expected, 1e4)) return {
 		status: "stuck",
 		reason: `supervisor pid ${target.pid} did not exit`
 	};
-	if (port && !(await resolveProjectMetro(port, root)).missing) return {
+	if (port && !(await resolve(port)).missing) return {
 		status: "port-occupied",
 		reason: `port ${port} is still occupied after stopping Metro`
 	};
-	clearWorkspaceSupervisor(root, expected);
-	clearSupervisor(root, expected);
+	await withWorkspaceStateLockAsync(root, () => clearWorkspaceSupervisor(root, expected));
+	await withConfigLockAsync$1(() => clearSupervisor(root, expected));
+	throwIfCancelled(signal, "Metro reset");
 	return { status: "stopped" };
 }
-async function stopOwnedMetroForReset(root) {
-	const stopped = await stopOwnedMetro(root, { by: "stim start --reset-cache" });
+async function stopOwnedMetroForReset(root, signal) {
+	const stopped = await stopOwnedMetro(root, { by: "stim start --reset-cache" }, signal);
 	switch (stopped.status) {
 		case "unverified": throw supervisorError("STIM_SUPERVISOR_EXITED", `Cannot reset Metro: ${stopped.reason}.`, "Stop it with the tool that started it, then retry. Stim leaves unverified processes alone.");
 		case "external": throw supervisorError("STIM_SUPERVISOR_EXITED", "Cannot reset an externally started dev server.", "Stop it with the tool that started it, then retry `stim start --reset-cache`.");
@@ -8667,10 +8744,16 @@ function estimateMemoryUse({ config, sims, androidSerial, supervisorRunning }) {
 		liveWorkspaces: liveCount
 	};
 }
-async function listSims() {
+async function listSims(signal, operation) {
 	try {
-		return await listAllIosSimsAsync({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
-	} catch {
+		return await listAllIosSimsAsync({
+			timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+			signal,
+			operation
+		});
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		signal?.throwIfAborted();
 		return null;
 	}
 }
@@ -8689,20 +8772,30 @@ function runningSupervisorPid(path, project) {
 	});
 	return target.status === "ours" ? target.pid ?? null : null;
 }
-async function readMemoryUse(simSnapshot) {
-	const resolve = ownedAvdSerialResolverAsync({ timeoutMs: 5e3 });
+async function readMemoryUse(simSnapshot, signal, operation) {
+	signal?.throwIfAborted();
+	const resolve = ownedAvdSerialResolverAsync({
+		timeoutMs: 5e3,
+		signal,
+		operation
+	});
 	const config = loadConfig$1();
-	const sims = simSnapshot ? await snapshotSims(simSnapshot) : await listSims();
+	const sims = simSnapshot && !signal ? await snapshotSims(simSnapshot) : await listSims(signal, operation);
+	signal?.throwIfAborted();
 	const serials = /* @__PURE__ */ new Map();
 	for (const record of Object.values(config?.projects ?? {})) for (const { platforms } of projectDeviceSlots(record)) {
+		signal?.throwIfAborted();
 		const android = platforms.android;
 		if (!android?.owned || !android.avdName || serials.has(android.avdName)) continue;
 		try {
 			serials.set(android.avdName, (await resolve(android.avdName)).serial ?? null);
-		} catch {
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			signal?.throwIfAborted();
 			serials.set(android.avdName, null);
 		}
 	}
+	signal?.throwIfAborted();
 	return estimateMemoryUse({
 		config,
 		sims,
@@ -8734,7 +8827,7 @@ function isOtherWorkspace(root) {
 function deviceLabel(device) {
 	return `${device.kind} ${device.name} in ${device.project}`;
 }
-async function reclaimIdleDevices({ root, dryRun, note, now, env }) {
+async function reclaimIdleDevices({ root, dryRun, note, now, env, signal, operation }) {
 	if (deviceSweepIsScoped(env)) {
 		note(chalk.dim(phaseLine("budget", "idle devices left alone: STIM_HOME scopes this config, devices are global")));
 		return {
@@ -8743,13 +8836,18 @@ async function reclaimIdleDevices({ root, dryRun, note, now, env }) {
 		};
 	}
 	const other = isOtherWorkspace(root);
-	const collect = async (at) => idleShutdownCandidates((await collectIdleDevicesAsync(loadConfig$1(), await listSims() ?? [], [], at, env)).filter((device) => other(device.project)), 0);
+	const collect = async (at) => {
+		signal?.throwIfAborted();
+		const devices = await collectIdleDevicesAsync(loadConfig$1(), await listSims(signal, operation) ?? [], [], at, env, signal, operation);
+		signal?.throwIfAborted();
+		return idleShutdownCandidates(devices.filter((device) => other(device.project)), 0);
+	};
 	const idle = await collect(now);
 	if (dryRun || idle.length === 0) return {
 		targets: idle.map(deviceLabel),
 		failures: 0
 	};
-	const { failures, shutDown } = await shutDownIdleDevices(idle, 0, () => collect(Date.now()), stepOutput(note));
+	const { failures, shutDown } = await shutDownIdleDevices(idle, 0, () => collect(Date.now()), stepOutput(note), signal, operation);
 	return {
 		targets: shutDown.map(deviceLabel),
 		failures
@@ -8760,7 +8858,7 @@ function idleSince(path, now) {
 	const at = Date.parse(activity.lastActivityAt ?? "");
 	return activity.state === "idle" && Number.isFinite(at) ? at : null;
 }
-async function reclaimIdleDevServers({ root, dryRun, note, now, env }) {
+async function reclaimIdleDevServers({ root, dryRun, note, now, env, signal, operation }) {
 	const config = loadConfig$1();
 	const other = isOtherWorkspace(root);
 	const serving = Object.entries(config?.projects ?? {}).flatMap(([path, project]) => {
@@ -8774,7 +8872,8 @@ async function reclaimIdleDevServers({ root, dryRun, note, now, env }) {
 		targets: [],
 		failures: 0
 	};
-	const sims = await listSims();
+	const sims = await listSims(signal, operation);
+	signal?.throwIfAborted();
 	if (sims === null) {
 		note(chalk.dim(phaseLine("budget", "dev servers left alone: simulators could not be listed to prove them idle")));
 		return {
@@ -8782,7 +8881,8 @@ async function reclaimIdleDevServers({ root, dryRun, note, now, env }) {
 			failures: 0
 		};
 	}
-	const busy = new Set((await collectOwnedDeviceActivityAsync(config, sims, now, env)).filter((device) => device.activity.state !== "idle").map((device) => device.project));
+	const busy = new Set((await collectOwnedDeviceActivityAsync(config, sims, now, env, signal, operation)).filter((device) => device.activity.state !== "idle").map((device) => device.project));
+	signal?.throwIfAborted();
 	const idle = serving.filter(({ path }) => !busy.has(path));
 	if (dryRun) return {
 		targets: idle.map(({ path }) => path),
@@ -8795,6 +8895,7 @@ async function reclaimIdleDevServers({ root, dryRun, note, now, env }) {
 		return Boolean(project && runningSupervisorPid(path, project) === pid && !workspaceBuildInProgress(path) && idleSince(path, Date.now()) !== null);
 	};
 	for (const { path, pid } of idle) {
+		signal?.throwIfAborted();
 		let run;
 		try {
 			run = await withIdleWorkspace(path, async () => {
@@ -8802,20 +8903,28 @@ async function reclaimIdleDevServers({ root, dryRun, note, now, env }) {
 					return await withWorkspaceProcessLock(workspaceDir(path), "metro-start", async () => stillIdle(path, pid) ? stopOwnedMetro(path, {
 						by: "budget reclaim",
 						workspace: root
-					}) : "busy", {
+					}, signal) : "busy", {
 						external: true,
 						waitMs: 0,
-						ownerPurpose: "budget reclaim"
+						ownerPurpose: "budget reclaim",
+						signal,
+						declareSpawnsFor: operation
 					});
 				} catch (error) {
+					if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+					signal?.throwIfAborted();
 					if (workspaceProcessLockError(error)) return "starting";
 					throw error;
 				}
 			}, {
 				purpose: "budget reclaim",
-				supervisor: false
+				supervisor: false,
+				signal,
+				operation
 			});
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			signal?.throwIfAborted();
 			failures++;
 			note(chalk.red(`Could not stop the dev server of ${path}: ${error?.message || error}`));
 			continue;
@@ -8841,12 +8950,14 @@ async function reclaimIdleDevServers({ root, dryRun, note, now, env }) {
 		failures
 	};
 }
-async function reclaimWorkspaceOutputs({ root, dryRun, now, note, diskRecovered }) {
+async function reclaimWorkspaceOutputs({ root, dryRun, now, note, diskRecovered, signal, operation }) {
 	const other = isOtherWorkspace(root);
-	const report = collectWorkspaceOutputs({
+	const report = await collectWorkspaceOutputs({
 		olderThan: null,
 		now,
-		measure: false
+		measure: false,
+		signal,
+		operation
 	});
 	const clearable = report.workspaces.flatMap((entry) => {
 		const project = entry.projectRoot;
@@ -8868,11 +8979,13 @@ async function reclaimWorkspaceOutputs({ root, dryRun, now, note, diskRecovered
 			workspaces: [entry]
 		}, {
 			olderThan: null,
-			now
+			now,
+			signal,
+			operation
 		}, stepOutput(note));
 		failures += result.failures;
 		targets.push(...result.cleared);
-		if (diskRecovered()) break;
+		if (await diskRecovered()) break;
 	}
 	return {
 		targets,
@@ -8885,13 +8998,13 @@ function cacheLabel(cache) {
 function trimmableCaches(env = process.env, cwd) {
 	return planCacheEmptying(discoverCaches(env, cwd), false, env).filter((cache) => cache.prune !== "report-only" && cache.prune !== "atomic" && !cache.machineGlobal);
 }
-function reclaimStaleCacheEntries({ dryRun, note, env, cwd }) {
+async function reclaimStaleCacheEntries({ dryRun, note, env, cwd, signal }) {
 	const caches = trimmableCaches(env, cwd);
 	if (dryRun) return {
 		targets: caches.map(cacheLabel),
 		failures: 0
 	};
-	const { trimmed, failures } = trimCaches(caches, 14, stepOutput(note));
+	const { trimmed, failures } = await trimCaches(caches, 14, stepOutput(note), signal);
 	return {
 		targets: trimmed.map(cacheLabel),
 		failures
@@ -8900,6 +9013,7 @@ function reclaimStaleCacheEntries({ dryRun, note, env, cwd }) {
 function stepOutput(note) {
 	return {
 		log: note,
+		error: note,
 		record: () => {},
 		fail: () => {}
 	};
@@ -8920,6 +9034,8 @@ async function runStep(step, context) {
 	try {
 		return await STEPS[step](context);
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		context.signal?.throwIfAborted();
 		context.note(chalk.red(phaseLine("budget", `${STEP_ACTIONS[step]} failed: ${error?.message || error}`)));
 		return {
 			targets: [],
@@ -8927,8 +9043,8 @@ async function runStep(step, context) {
 		};
 	}
 }
-function spaceUsers() {
-	const home = homedir();
+async function spaceUsers(env = process.env, signal, operation) {
+	const home = env.HOME || env.USERPROFILE || homedir();
 	const candidates = [
 		["Stim state", getConfigDir()],
 		["shared build cache", sharedBuildCache()],
@@ -8942,7 +9058,11 @@ function spaceUsers() {
 		if (measured.has(canonical) || [...measured].some((dir) => canonical.startsWith(`${dir}${sep}`))) continue;
 		measured.add(canonical);
 		if (!existsSync(path)) continue;
-		const bytes = measuredDirectorySize(path, { timeoutMs: USAGE_TIMEOUT_MS });
+		const bytes = await measuredDirectorySizeAsync(path, {
+			timeoutMs: USAGE_TIMEOUT_MS,
+			signal,
+			operation
+		});
 		if (bytes) users.push({
 			label: `${label} ${path}`,
 			bytes
@@ -8966,7 +9086,7 @@ function describeShortfall(budget, measure, short) {
 		...short.workspaces && measure.memory ? [`${measure.memory.liveWorkspaces} active workspaces, over the limit of ${budget.maxLiveWorkspaces}`] : []
 	];
 }
-async function enforceBudget({ root, note, dryRun = false, budget: resolved, env = process.env, simSnapshot, cwd }, overrides = {}) {
+async function enforceBudget({ root, note, dryRun = false, budget: resolved, env = process.env, simSnapshot, cwd, signal, operation }, overrides = {}) {
 	const deps = {
 		...DEFAULT_DEPS,
 		...overrides
@@ -8987,7 +9107,7 @@ async function enforceBudget({ root, note, dryRun = false, budget: resolved, env
 	const paths = [root, getConfigDir()];
 	const measureNow = async () => ({
 		volumes: budget.minFreeDiskMb > 0 || budget.hardFloorDiskMb > 0 ? await (deps.volumesAsync?.(paths) ?? deps.volumes(paths)) : [],
-		memory: budget.maxCommittedMemoryMb > 0 || budget.maxLiveWorkspaces > 0 ? await deps.memory(simSnapshot) : null
+		memory: budget.maxCommittedMemoryMb > 0 || budget.maxLiveWorkspaces > 0 ? await deps.memory(simSnapshot, signal, operation) : null
 	});
 	let measure = await measureNow();
 	let short = budgetShortfalls(budget, measure);
@@ -8995,6 +9115,7 @@ async function enforceBudget({ root, note, dryRun = false, budget: resolved, env
 	const plan = reclaimPlan(short);
 	if (plan.length) note(chalk.yellow(phaseLine("budget", `${describeShortfall(budget, measure, short).join("; ")}; ${dryRun ? "would reclaim" : "reclaiming"}`)));
 	for (const step of plan) {
+		signal?.throwIfAborted();
 		if (!dryRun && (!overBudget(short) || DISK_ONLY.includes(step) && short.disk.length === 0)) break;
 		const freeBefore = measure.volumes.reduce((sum, v) => sum + v.freeMb, 0);
 		const result = await deps.step(step, {
@@ -9004,11 +9125,14 @@ async function enforceBudget({ root, note, dryRun = false, budget: resolved, env
 			dryRun,
 			note,
 			now: deps.now(),
-			diskRecovered: () => budgetShortfalls(budget, {
-				volumes: deps.volumes(paths),
+			diskRecovered: async () => budgetShortfalls(budget, {
+				volumes: await (deps.volumesAsync?.(paths) ?? deps.volumes(paths)),
 				memory: null
-			}).disk.length === 0
+			}).disk.length === 0,
+			signal,
+			operation
 		});
+		signal?.throwIfAborted();
 		if (!dryRun) {
 			simSnapshot?.invalidate();
 			measure = await measureNow();
@@ -9026,7 +9150,7 @@ async function enforceBudget({ root, note, dryRun = false, budget: resolved, env
 	}
 	if (!dryRun && short.hardFloor.length) {
 		const tight = short.hardFloor.map((v) => `${formatSpace(v.freeMb)} on ${v.volume}`).join(" and ");
-		const users = deps.usage();
+		const users = await deps.usage(env, signal, operation);
 		return {
 			status: "refused",
 			reclaimed,
@@ -9046,13 +9170,15 @@ async function enforceBudget({ root, note, dryRun = false, budget: resolved, env
 		short
 	};
 }
-async function peekBudget(root, overrides = {}, env = process.env) {
+async function peekBudget(root, overrides = {}, env = process.env, signal) {
 	const outcome = await enforceBudget({
 		root,
 		note: () => {},
 		dryRun: true,
-		env
+		env,
+		signal
 	}, {
+		...signal ? { volumesAsync: (paths) => readVolumeSpaceAsync(paths, signal) } : {},
 		...overrides,
 		step: async () => ({
 			targets: [],
@@ -9064,7 +9190,10 @@ async function peekBudget(root, overrides = {}, env = process.env) {
 	return shortfall.length ? shortfall.join("; ") : null;
 }
 async function budgetGate(args, overrides = {}) {
-	const outcome = await enforceBudget(args, overrides);
+	const outcome = await enforceBudget(args, {
+		...args.signal ? { volumesAsync: (paths) => readVolumeSpaceAsync(paths, args.signal) } : {},
+		...overrides
+	});
 	return {
 		reclaimed: "reclaimed" in outcome ? outcome.reclaimed : [],
 		refusal: outcome.status === "ok" ? null : outcome.refusal
@@ -9115,7 +9244,9 @@ async function inspectBudget(root, deps = {}, env = process.env, operation) {
 		dryRun: true,
 		budget: read.budget,
 		env,
-		cwd: operation?.cwd
+		cwd: operation?.cwd,
+		signal: operation?.signal,
+		operation
 	}, {
 		...operation ? { volumesAsync: (paths) => readVolumeSpaceAsync(paths, operation.signal) } : {},
 		...deps