stim 1.21.0 → 1.23.0

package/dist/{act-DHAw2A2S.mjs → act-DG54PWtJ.mjs}

@@ -1,30 +1,30 @@
-import { n as isTimeoutError, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { n as isTimeoutError, r as WorkspaceProcessCleanupError, t as getExecutor } from "./exec-DEoAhcze.mjs";
 import { g as workspaceStateFile$1, m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
-import { F as isOnMountedVolume, I as listMountedVolumes, K as projectDeviceSlots, N as directorySizeAsync, P as formatBytes, R as measuredDirectorySizeAsync, _ as loadConfig$1, p as getProject } from "./config-CYcBF478.mjs";
-import { o as formatLongDuration, u as plural } from "./command-output-B1UrjZHL.mjs";
-import { r as readWorkspaceState$1, u as workspaceLastUsed } from "./workspace-state-Cjuigeeu.mjs";
-import { E as maintenanceKeepSetting, J as resolveProjectSettingsAsync, Lt as resolveFullRef, Ot as listWorktrees, Rt as resolveFullRefAsync, St as hasPopulatedSubmodulesAsync, Tt as hasUncommittedWorkAsync, Ut as unpushedCommitsAsync, Vt as sourceCheckoutOf, Xt as removeTemporaryEntry, _t as dirtyPathsAsync, kt as listWorktreesAsync, q as resolveProjectSettings, zt as resolveSourceCheckoutAsync } from "./settings-CsJDEXgK.mjs";
-import { i as gitQuietAsync, r as gitQuiet } from "./git-C3iTsJaZ.mjs";
-import { i as findProjectRoot$1 } from "./project-BZNjmW_8.mjs";
-import { a as unregister, n as readManifest } from "./cache-manifest-DkkqguoK.mjs";
-import { A as workspaceBuildInProgress, E as collectOwnedDeviceActivityAsync, St as deleteProjectDevices, T as collectOwnedDeviceActivity, Tt as deviceSweepIsScoped, X as emptyCaches, _r as phase, br as discoverCaches, bt as deleteParkedAvds, ct as deleteGradleVersion, d as trimmableCaches, f as stopOwnedMetro, fr as memorySweepIsScoped, gr as stopIdleGradleDaemons, gt as DEVICE_LIST_TIMEOUT_MS, i as enforceBudget, kt as findStaleProjectDevices, nt as planCacheEmptying, o as machineNumber, pt as waitForGradleExit, r as cacheLabel, sr as collectMemoryReport, st as collectGradleVersions, u as resolveBudget, vt as collectParkedAvds, xr as pruneCache, xt as deleteParkedSims, yt as collectParkedSims } from "./budget-Bs6SxxzO.mjs";
+import { F as isOnMountedVolume, G as projectDeviceSlots, I as listMountedVolumes, L as measuredDirectorySizeAsync, N as directorySizeAsync, P as formatBytes, _ as loadConfig$1, p as getProject } from "./config-DlrsduwG.mjs";
+import { o as formatLongDuration, u as plural } from "./command-output-Db8BqzxH.mjs";
+import { c as gitQuiet, l as gitQuietAsync, n as runOperationFileQuiet, r as childEnvironment } from "./operation-exec-BW0em61G.mjs";
+import { r as readWorkspaceState$1, u as workspaceLastUsed } from "./workspace-state-U08dEzhG.mjs";
+import { E as maintenanceKeepSetting, Et as listWorktreesAsync, Ft as resolveFullRefAsync, It as resolveSourceCheckoutAsync, J as resolveProjectSettingsAsync, Rt as sourceCheckoutOf, St as hasUncommittedWorkAsync, Tt as listWorktrees, Wt as removeTemporaryEntryAsync, bt as hasPopulatedSubmodulesAsync, gt as dirtyPathsAsync, q as resolveProjectSettings, zt as unpushedCommitsAsync } from "./settings-C7O8A6ZI.mjs";
+import { i as findProjectRoot$1 } from "./project-CTLNHCfE.mjs";
+import { a as unregister, n as readManifest } from "./cache-manifest-DSeQjt-Q.mjs";
+import { A as workspaceBuildInProgress, E as collectOwnedDeviceActivityAsync, St as deleteProjectDevices, T as collectOwnedDeviceActivity, Tt as deviceSweepIsScoped, X as emptyCaches, _r as phase, br as discoverCaches, bt as deleteParkedAvds, ct as deleteGradleVersion, d as trimmableCaches, f as stopOwnedMetro, fr as memorySweepIsScoped, gr as stopIdleGradleDaemons, gt as DEVICE_LIST_TIMEOUT_MS, i as enforceBudget, kt as findStaleProjectDevices, nt as planCacheEmptying, o as machineNumber, pt as waitForGradleExit, r as cacheLabel, sr as collectMemoryReport, st as collectGradleVersions, u as resolveBudget, vt as collectParkedAvds, xr as pruneCache, xt as deleteParkedSims, yt as collectParkedSims } from "./budget-DnPX3DXj.mjs";
 import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { B as takeGcResults, a as collectWorkspaceOutputs, c as listWorkspaceDirs, f as withIdleWorkspace, i as collectOrphanedWorkspaces, o as deleteOrphanedWorkspaces, p as workspaceInUse, r as clearWorkspaceOutputs, s as isInsideWorkspaces, z as recordGcResult } from "./workspaces-BccMFmGQ.mjs";
-import { N as listBuildLocks, b as leaseIsExpired, g as workspaceActivity, x as listLeaseFiles } from "./activity-BzVfHSrY.mjs";
-import { H as ownedAvdSerialResolver, M as listAvds, U as ownedAvdSerialResolverAsync, gt as readParked, z as ownedAvdDirectory } from "./android-DUYkNF4u.mjs";
-import { d as listAllIosSims, f as listAllIosSimsAsync } from "./ios-CpByZy12.mjs";
+import { V as takeGcResults, a as collectWorkspaceOutputs, c as listWorkspaceDirs, f as withIdleWorkspace, i as collectOrphanedWorkspaces, m as workspaceInUseAsync, o as deleteOrphanedWorkspaces, p as workspaceInUse, r as clearWorkspaceOutputs, s as isInsideWorkspaces, z as GC_OUTPUT } from "./workspaces-BxzYlo3P.mjs";
+import { N as listBuildLocks, b as leaseIsExpired, g as workspaceActivity, x as listLeaseFiles } from "./activity-B5RtpFda.mjs";
+import { F as listAvdsAsync, G as ownedAvdSerialResolverAsync, P as listAvds, V as ownedAvdDirectory, vt as readParked } from "./android-C7sVmyI9.mjs";
+import { d as listAllIosSims, f as listAllIosSimsAsync } from "./ios-hcBpnEGk.mjs";
 import { s as metroStoreRoot } from "./errors-ccaPc4ox.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
-import { A as lowestFree, C as measurePressure, D as diskPressureLevel, O as levelFloors, S as measureDisk, a as matchWorktreeEntry, c as reclaimKeys, i as excludeWatchmanCookies, j as protectWindowMs, m as removeWorktreeTarget, o as nestedWorktrees, r as excludePodChurn, s as porcelainPath, w as measurePressureAsync, x as cacheBlocked } from "./worktree-DQ6Zi2Mv.mjs";
-import { c as FETCH_FRESH_MS, d as localDefaultBranchAsync, l as fetchDefaultBranchAsync, o as recordPullRequestLookup, p as mergeStateAsync, u as lastFetchedAtAsync } from "./warm-progress-BHX5r0Ei.mjs";
-import { n as describePullRequest, o as pullRequestLookups, r as endedPullRequest } from "./pull-request-Lfetn8Kr.mjs";
+import { A as levelFloors, C as measureDisk, E as measurePressureAsync, M as lowestFree, N as protectWindowMs, S as cacheBlocked, T as measurePressure, a as matchWorktreeEntry, c as reclaimKeys, i as excludeWatchmanCookies, k as diskPressureLevel, m as removeWorktreeTarget, o as nestedWorktrees, r as excludePodChurn, s as porcelainPath, w as measureDiskAsync } from "./worktree-8lqn_lBp.mjs";
+import { c as FETCH_FRESH_MS, d as localDefaultBranchAsync, l as fetchDefaultBranchAsync, o as recordPullRequestLookup, p as mergeStateAsync, u as lastFetchedAtAsync } from "./warm-progress-CA3TgT3-.mjs";
+import { n as describePullRequest, r as endedPullRequest, s as pullRequestLookups } from "./pull-request-W1IuLXDt.mjs";
+import { readClaimSet } from "@stim-cli/core/ownership-claim";
 import { existsSync, lstatSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { buildCacheRoot, configDir, metroCacheRoot } from "@stim-cli/core";
 import { LAST_BUILD_KEYS, MAINTENANCE_LOG_NAME, loadConfig, readBuildHistory, readMaintenanceState, readPullRequestCache, settingDefinition, sharedCompilationCache } from "@stim-cli/core/state";
 import { isAbsolute as isAbsolute$1, join as join$1 } from "path";
-import { readClaimSet } from "@stim-cli/core/ownership-claim";
 import chalk from "chalk";
 import { existsSync as existsSync$1, readdirSync as readdirSync$1, statSync as statSync$1 } from "fs";
 import { lstat, readdir, realpath, rename, stat } from "node:fs/promises";
@@ -175,22 +175,9 @@ function idleDaysOf(keys, now) {
 	const last = lastUsedOf(keys);
 	return Number.isFinite(last) ? Math.max(0, Math.floor((now - last) / DAY_MS)) : null;
 }
-function deviceReads() {
-	let sims;
-	let resolver;
-	return {
-		sims: () => {
-			if (sims === void 0) try {
-				sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
-			} catch {
-				sims = null;
-			}
-			return sims;
-		},
-		avdSerial: (avdName) => (resolver ??= ownedAvdSerialResolver({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }))(avdName)
-	};
-}
-async function reportDeviceReads(keys) {
+async function reportDeviceReads(keys, operation) {
+	const signal = operation?.signal;
+	signal?.throwIfAborted();
 	const slots = keys.flatMap((key) => {
 		try {
 			return projectDeviceSlots(getProject(key));
@@ -204,18 +191,34 @@ async function reportDeviceReads(keys) {
 	}));
 	let sims = null;
 	if (requestedSims.size) try {
-		sims = await listAllIosSimsAsync({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
-	} catch {}
+		sims = await listAllIosSimsAsync({
+			timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+			operation,
+			signal
+		});
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		signal?.throwIfAborted();
+	}
 	const names = new Set(slots.flatMap(({ platforms }) => {
 		const android = platforms.android;
 		return android?.owned && android.avdName ? [android.avdName] : [];
 	}));
 	const avds = /* @__PURE__ */ new Map();
-	const resolver = ownedAvdSerialResolverAsync({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
-	for (const name of names) try {
-		avds.set(name, { value: await resolver(name) });
-	} catch (error) {
-		avds.set(name, { error });
+	const resolver = ownedAvdSerialResolverAsync({
+		timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+		operation,
+		signal
+	});
+	for (const name of names) {
+		signal?.throwIfAborted();
+		try {
+			avds.set(name, { value: await resolver(name) });
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			signal?.throwIfAborted();
+			avds.set(name, { error });
+		}
 	}
 	return {
 		sims: (udid) => requestedSims.has(udid) || sims?.some((sim) => sim.udid === udid) ? sims : null,
@@ -227,8 +230,10 @@ async function reportDeviceReads(keys) {
 		}
 	};
 }
-function inUseOf(keys, checks, devices = deviceReads()) {
-	return [.../* @__PURE__ */ new Set([...keys.flatMap((key) => workspaceInUse(key, checks)), ...deviceUseOf(keys, devices)])];
+async function inUseOf(keys, checks, devices, signal, operation) {
+	const reasons = [];
+	for (const key of keys) reasons.push(...await workspaceInUseAsync(key, checks, signal, operation));
+	return [.../* @__PURE__ */ new Set([...reasons, ...deviceUseOf(keys, devices)])];
 }
 function deviceUseOf(keys, devices) {
 	const reasons = [];
@@ -297,12 +302,18 @@ function worktreeActivityOf(path, keys) {
 	])?.trim();
 	return activityFromGitDir(gitDir, keys);
 }
-async function worktreeActivityOfAsync(path, keys) {
+async function worktreeActivityOfAsync(path, keys, operation) {
 	const gitDir = (await gitQuietAsync(path, [
 		"rev-parse",
 		"--path-format=absolute",
 		"--git-dir"
-	], { killSignal: "SIGKILL" }))?.trim();
+	], {
+		...operation ? childEnvironment(operation.env) : {},
+		signal: operation?.signal,
+		declareFor: operation,
+		cwd: operation?.cwd,
+		killSignal: "SIGKILL"
+	}))?.trim();
 	return activityFromGitDir(gitDir, keys);
 }
 function activityFromGitDir(gitDir, keys) {
@@ -352,10 +363,14 @@ async function unlessTimedOut(read, unknown) {
 		throw error;
 	}
 }
-async function porcelainOf(path, gitAnswered) {
+async function porcelainOf(path, gitAnswered, operation) {
 	if (gitAnswered === null) return null;
 	if (!gitAnswered) return [];
-	const lines = await unlessTimedOut(() => dirtyPathsAsync(path, { limit: Infinity }), null);
+	const lines = await unlessTimedOut(() => dirtyPathsAsync(path, { limit: Infinity }, {
+		env: operation?.env,
+		signal: operation?.signal,
+		declareFor: operation
+	}), null);
 	return lines?.length ? lines : null;
 }
 function candidateRoots() {
@@ -367,13 +382,20 @@ function candidateRoots() {
 		...linkedWorktreesOf(registered)
 	])].filter((root) => existsSync$1(root)).toSorted();
 }
-async function candidateRootsAsync() {
+async function candidateRootsAsync(operation) {
+	operation?.signal.throwIfAborted();
+	const options = {
+		env: operation?.env,
+		signal: operation?.signal,
+		declareFor: operation
+	};
 	const registered = Object.keys(loadConfig$1()?.projects ?? {}).filter(isAbsolute$1);
 	const recorded = listWorkspaceDirs().flatMap((entry) => entry.projectRoot ? [entry.projectRoot] : []);
 	const linked = /* @__PURE__ */ new Set();
 	for (const root of registered) {
+		operation?.signal.throwIfAborted();
 		if (!existsSync$1(root)) continue;
-		const { entries, ...source } = await resolveSourceCheckoutAsync(root);
+		const { entries, ...source } = await resolveSourceCheckoutAsync(root, options);
 		if ("refusal" in source) continue;
 		for (const entry of entries) if (!entry.bare && !entry.prunable && entry.path !== source.path) linked.add(entry.path);
 	}
@@ -394,8 +416,8 @@ function linkedWorktreesOf(roots) {
 	}
 	return [...linked];
 }
-async function staleFetch(repo, now, freshMs) {
-	const at = await lastFetchedAtAsync(repo);
+async function staleFetch(repo, now, freshMs, execution) {
+	const at = await lastFetchedAtAsync(repo, execution);
 	if (at !== null && now - at < freshMs) return null;
 	return at === null ? "the repository has no recorded fetch" : `the repository was last fetched ${formatLongDuration(Math.max(0, now - at))} ago`;
 }
@@ -412,18 +434,27 @@ function notRefreshedNote(fetch, facts) {
 	const stale = [fetch, lookup && "unavailable" in lookup && lookup.unavailable === PULL_REQUEST_NOT_CHECKED ? "its pull request was not checked" : null].filter(Boolean);
 	return stale.length ? `merge state not refreshed: ${stale.join(", ")}; the next maintenance worktree check, which a stim command starts when it is due, or \`stim gc --delete\` checks again` : null;
 }
-async function checkMergeStates(pending, idle, grace, noOwnCommitsIdleMs, refresh, freshMs) {
+async function checkMergeStates(pending, idle, grace, noOwnCommitsIdleMs, refresh, freshMs, operation) {
 	const repos = /* @__PURE__ */ new Map();
+	const execution = {
+		...operation ? childEnvironment(operation.env) : {},
+		signal: operation?.signal,
+		declareFor: operation,
+		cwd: operation?.cwd,
+		killSignal: "SIGKILL"
+	};
 	for (const entry of pending) repos.set(entry.repo, [...repos.get(entry.repo) ?? [], entry]);
 	for (const [repo, entries] of repos) {
-		const target = refresh ? await fetchDefaultBranchAsync(repo, grace.now) : await localDefaultBranchAsync(repo);
-		const fetch = refresh ? null : await staleFetch(repo, grace.now, freshMs);
+		operation?.signal.throwIfAborted();
+		const target = refresh ? await fetchDefaultBranchAsync(repo, grace.now, execution) : await localDefaultBranchAsync(repo, execution);
+		const fetch = refresh ? null : await staleFetch(repo, grace.now, freshMs, execution);
 		for (const { candidate, facts } of entries) {
+			operation?.signal.throwIfAborted();
 			const merge = "error" in target ? {
 				merged: false,
 				unknown: true,
 				detail: `merge state unknown: ${target.error}`
-			} : await mergeStateAsync(candidate.path, target);
+			} : await mergeStateAsync(candidate.path, target, execution);
 			const verdict = worktreeSkipReason({
 				...facts,
 				merge
@@ -442,8 +473,8 @@ async function checkMergeStates(pending, idle, grace, noOwnCommitsIdleMs, refres
 * Classifies each linked worktree of a registered project or its repository. A merged one is removable; with `idle`, so is one unused for
 * `olderThan` days; with `removesNoOwnCommits`, so is one with no commits of its own beyond the default branch whose
 * last activity is older than the grace period, and never younger than 5 minutes. Device use is read last, in one pass against one simulator list and one AVD resolver, so
-* the resolver's time budget covers only device reads. Pull requests are asked once per repository, all
-* repositories at once. Merge state is checked only where it decides the verdict, after one fetch per repository.
+* the resolver's time budget covers only device reads. Pull requests are asked once per repository, sequentially
+* with an operation and concurrently otherwise. Merge state is checked only where it decides the verdict, after one fetch per repository.
 * Without `refresh`, it runs no fetch and no `gh`: merge state comes from the existing remote-tracking ref and pull
 * requests from the cache `status --watch` writes, and a kept verdict that fresher state could change says so.
 */
@@ -456,11 +487,18 @@ async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOw
 	const freshMs = refresh ? 0 : reportFreshMs(operation);
 	const noOwnCommitsIdleMs = removesNoOwnCommits ? Math.max(grace.ms, NO_OWN_COMMITS_PRESSURE_FLOOR_MS) : null;
 	const groups = /* @__PURE__ */ new Map();
+	operation?.signal.throwIfAborted();
+	const read = {
+		env: operation?.env,
+		signal: operation?.signal,
+		declareFor: operation
+	};
 	const outside = [];
-	const candidates = await candidateRootsAsync();
+	const candidates = await candidateRootsAsync(operation);
 	if (candidates.length) phase("worktrees", `checking ${plural(candidates.length, "project")} for merged or idle worktrees`, operation);
 	for (const root of candidates) {
-		const entry = matchWorktreeEntry(await listWorktreesAsync(root), root);
+		operation?.signal.throwIfAborted();
+		const entry = matchWorktreeEntry(await listWorktreesAsync(root, read), root);
 		if (!entry) {
 			outside.push({
 				path: root,
@@ -480,22 +518,23 @@ async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOw
 	}
 	const inspected = [];
 	for (const [path, roots] of groups) {
-		const { entries, ...source } = await resolveSourceCheckoutAsync(path);
+		operation?.signal.throwIfAborted();
+		const { entries, ...source } = await resolveSourceCheckoutAsync(path, read);
 		const entry = matchWorktreeEntry(entries, path);
 		const keys = [.../* @__PURE__ */ new Set([...roots, ...reclaimKeys(path)])];
 		const idleDays = idleDaysOf(keys, now);
 		const linked = !("refusal" in source) && entry !== null && source.path !== entry.path;
-		const activity = linked && (grace.ms > 0 || days !== null || removesNoOwnCommits) ? await worktreeActivityOfAsync(path, keys) : null;
-		const gitAnswered = linked ? await unlessTimedOut(() => hasUncommittedWorkAsync(path), null) : null;
-		const head = linked ? await resolveFullRefAsync(path, "HEAD") : null;
+		const activity = linked && (grace.ms > 0 || days !== null || removesNoOwnCommits) ? await worktreeActivityOfAsync(path, keys, operation) : null;
+		const gitAnswered = linked ? await unlessTimedOut(() => hasUncommittedWorkAsync(path, read), null) : null;
+		const head = linked ? await resolveFullRefAsync(path, "HEAD", read) : null;
 		const facts = {
 			source: "refusal" in source ? source : linked ? "linked" : "source",
 			bare: Boolean(entry?.bare),
 			locked: Boolean(entry?.locked),
 			nested: entry ? nestedWorktrees(entries, entry.path) : [],
-			porcelain: await porcelainOf(path, gitAnswered),
-			unpushed: linked ? await unlessTimedOut(() => unpushedCommitsAsync(path), null) : null,
-			submodules: linked ? await unlessTimedOut(() => hasPopulatedSubmodulesAsync(path), null) : false,
+			porcelain: await porcelainOf(path, gitAnswered, operation),
+			unpushed: linked ? await unlessTimedOut(() => unpushedCommitsAsync(path, read), null) : null,
+			submodules: linked ? await unlessTimedOut(() => hasPopulatedSubmodulesAsync(path, read), null) : false,
 			inUse: [],
 			idleDays,
 			merge: null,
@@ -521,10 +560,10 @@ async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOw
 		});
 	}
 	const linked = inspected.filter(({ facts }) => facts.source === "linked");
-	for (const { candidate, facts } of linked) facts.inUse = candidate.keys.flatMap((key) => workspaceInUse(key, { managedLocks: true }));
-	const devices = await reportDeviceReads(linked.flatMap(({ candidate }) => candidate.keys));
+	for (const { candidate, facts } of linked) for (const key of candidate.keys) facts.inUse.push(...await workspaceInUseAsync(key, { managedLocks: true }, operation?.signal, operation));
+	const devices = await reportDeviceReads(linked.flatMap(({ candidate }) => candidate.keys), operation);
 	for (const { candidate, facts } of linked) facts.inUse = [.../* @__PURE__ */ new Set([...facts.inUse, ...deviceUseOf(candidate.keys, devices)])];
-	if (refresh) await lookUpPullRequests(inspected);
+	if (refresh) await lookUpPullRequests(inspected, operation);
 	else readCachedPullRequests(inspected, now, freshMs);
 	const worktrees = [];
 	const pending = [];
@@ -543,7 +582,7 @@ async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOw
 		});
 		worktrees.push(candidate);
 	}
-	await checkMergeStates(pending, days, grace, noOwnCommitsIdleMs, refresh, freshMs);
+	await checkMergeStates(pending, days, grace, noOwnCommitsIdleMs, refresh, freshMs, operation);
 	const listed = [...worktrees, ...outside].filter((w) => idle || w.skipCode !== "not-a-worktree" && w.skipCode !== "source-checkout");
 	return {
 		idle: days === null ? null : {
@@ -556,7 +595,7 @@ async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOw
 		worktrees: listed
 	};
 }
-async function lookUpPullRequests(inspected) {
+async function lookUpPullRequests(inspected, operation) {
 	const repos = /* @__PURE__ */ new Map();
 	for (const { candidate, facts, repo, branch } of inspected) {
 		if (repo === null || branch === null || candidate.head === null) continue;
@@ -570,11 +609,12 @@ async function lookUpPullRequests(inspected) {
 			query
 		}]);
 	}
-	const lookup = pullRequestLookups();
-	await Promise.all([...repos].map(async ([repo, entries]) => {
+	const lookup = pullRequestLookups({ operation });
+	const probes = [...repos].map(([repo, entries]) => async () => {
 		const answers = await lookup(repo, entries.map(({ query }) => query));
 		const at = (/* @__PURE__ */ new Date()).toISOString();
 		entries.forEach(({ facts, query }, i) => {
+			operation?.signal.throwIfAborted();
 			const answer = answers[i] ?? null;
 			facts.pullRequest = answer;
 			if (answer && "pullRequest" in answer) recordPullRequestLookup({
@@ -583,7 +623,12 @@ async function lookUpPullRequests(inspected) {
 				head: query.head
 			}, answer.pullRequest, at);
 		});
-	}));
+	});
+	if (operation) for (const probe of probes) {
+		operation.signal.throwIfAborted();
+		await probe();
+	}
+	else await Promise.all(probes.map((probe) => probe()));
 }
 function readCachedPullRequests(inspected, now, freshMs) {
 	let gh;
@@ -613,33 +658,43 @@ function cachedPullRequest(cached, branch, head, now, freshMs) {
 		endedAt: open ? null : endedAt ?? null
 	} };
 }
-function noOwnCommitsRecheck(sweep, path, keys, now) {
+async function noOwnCommitsRecheck(sweep, path, keys, now, operation) {
 	if (!sweep.idle) {
 		if (sweep.noOwnCommitsIdleMs === null) return "it has no commits of its own and is not idle";
-		return noOwnCommitsActivityBlocker(worktreeActivityOf(path, keys), sweep.noOwnCommitsIdleMs, now)?.text ?? null;
+		return noOwnCommitsActivityBlocker(await worktreeActivityOfAsync(path, keys, operation), sweep.noOwnCommitsIdleMs, now)?.text ?? null;
 	}
 	const idleDays = idleDaysOf(keys, now);
 	if (idleDays !== null) return idleDays < sweep.idle.olderThan ? `used ${idleDays}d ago since gc checked it` : null;
-	const activity = worktreeActivityOf(path, keys);
+	const activity = await worktreeActivityOfAsync(path, keys, operation);
 	if (!activity) return "its last activity could not be read";
 	const days = activityIdleDays(activity, now);
 	return days < sweep.idle.olderThan ? `active ${days}d ago since gc checked it: ${activity.basis}` : null;
 }
-async function removeWorktrees(sweep, { now = Date.now() } = {}) {
+async function removeWorktrees(sweep, { now = Date.now(), operation } = {}, output = GC_OUTPUT) {
 	let failures = 0;
 	for (const candidate of sweep.worktrees) {
+		operation?.signal.throwIfAborted();
 		if (candidate.skipped) continue;
 		let kept = [];
-		const guard = (lockedKeys) => {
+		const guard = async (lockedKeys) => {
 			const keys = [.../* @__PURE__ */ new Set([...candidate.keys, ...lockedKeys])];
 			const unlocked = keys.filter((key) => !lockedKeys.includes(key));
-			const reasons = [...inUseOf(lockedKeys, { managedLocks: false }), ...inUseOf(unlocked, { managedLocks: true })].map((r) => `in use: ${r}`);
+			const devices = await reportDeviceReads(keys, operation);
+			const reasons = [...await inUseOf(lockedKeys, { managedLocks: false }, devices, operation?.signal, operation), ...await inUseOf(unlocked, { managedLocks: true }, devices, operation?.signal, operation)].map((r) => `in use: ${r}`);
 			const mergedHead = candidate.merge?.merged ? candidate.merge.head : endedPullRequest(candidate.pullRequest) ? candidate.head : null;
 			if (mergedHead) {
-				if (resolveFullRef(candidate.path, "HEAD") !== mergedHead) reasons.push("its HEAD moved since gc checked it");
+				if (await resolveFullRefAsync(candidate.path, "HEAD", {
+					env: operation?.env,
+					signal: operation?.signal,
+					declareFor: operation
+				}) !== mergedHead) reasons.push("its HEAD moved since gc checked it");
 			} else if (hasNoOwnCommits(candidate.merge)) {
-				if (resolveFullRef(candidate.path, "HEAD") !== candidate.head) reasons.push("its HEAD moved since gc checked it");
-				const recent = noOwnCommitsRecheck(sweep, candidate.path, keys, Date.now());
+				if (await resolveFullRefAsync(candidate.path, "HEAD", {
+					env: operation?.env,
+					signal: operation?.signal,
+					declareFor: operation
+				}) !== candidate.head) reasons.push("its HEAD moved since gc checked it");
+				const recent = await noOwnCommitsRecheck(sweep, candidate.path, keys, Date.now(), operation);
 				if (recent) reasons.push(recent);
 			} else {
 				const idleDays = idleDaysOf(keys, now);
@@ -649,7 +704,7 @@ async function removeWorktrees(sweep, { now = Date.now() } = {}) {
 				const recent = graceBlocker({
 					merge: candidate.merge,
 					pullRequest: candidate.pullRequest,
-					activity: worktreeActivityOf(candidate.path, keys)
+					activity: await worktreeActivityOfAsync(candidate.path, keys, operation)
 				}, {
 					ms: sweep.graceMs,
 					now: Date.now()
@@ -669,22 +724,26 @@ async function removeWorktrees(sweep, { now = Date.now() } = {}) {
 				linkedOnly: true,
 				guard,
 				mergedHead,
-				expectedHead
+				expectedHead,
+				output,
+				operation
 			});
 		} catch (thrown) {
+			if (thrown instanceof WorkspaceProcessCleanupError || thrown instanceof Error && "reportCleanup" in thrown) throw thrown;
+			operation?.signal.throwIfAborted();
 			error = thrown?.message || String(thrown);
-			console.error(chalk.red(`Could not remove ${candidate.path}: ${error}`));
+			output.error(chalk.red(`Could not remove ${candidate.path}: ${error}`));
 		}
 		if (removed) {
-			console.log(chalk.green(`Removed the worktree ${candidate.path} (${worktreeRemovalReason(candidate, sweep)})`));
-			recordGcResult("worktree", "done", candidate.path, { detail: worktreeRemovalReason(candidate, sweep) });
+			output.log(chalk.green(`Removed the worktree ${candidate.path} (${worktreeRemovalReason(candidate, sweep)})`));
+			output.record("worktree", "done", candidate.path, { detail: worktreeRemovalReason(candidate, sweep) });
 		} else if (kept.length) {
-			console.log(chalk.yellow(`Kept the worktree ${candidate.path}: ${kept.join("; ")}`));
-			recordGcResult("worktree", "kept", candidate.path, { detail: kept.join("; ") });
+			output.log(chalk.yellow(`Kept the worktree ${candidate.path}: ${kept.join("; ")}`));
+			output.record("worktree", "kept", candidate.path, { detail: kept.join("; ") });
 		} else {
 			failures++;
-			console.error(chalk.yellow(`Kept the worktree ${candidate.path}; see the lines above for why.`));
-			recordGcResult("worktree", "failed", candidate.path, { detail: error ?? "stim worktree remove did not remove it; see the details" });
+			output.error(chalk.yellow(`Kept the worktree ${candidate.path}; see the lines above for why.`));
+			output.record("worktree", "failed", candidate.path, { detail: error ?? "stim worktree remove did not remove it; see the details" });
 		}
 	}
 	return failures;
@@ -874,9 +933,11 @@ async function maintenancePinnedAsync(root, operation) {
 	try {
 		return maintenanceKeepSetting((await resolveProjectSettingsAsync(root, {
 			env: operation.env,
-			signal: operation.signal
+			signal: operation.signal,
+			declareFor: operation
 		})).settings);
-	} catch {
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
 		operation.signal.throwIfAborted();
 		return true;
 	}
@@ -909,14 +970,19 @@ function cachedDeviceActivity(now) {
 		return answer.devices;
 	};
 }
-function cachedDeviceActivityAsync(now, env) {
+function cachedDeviceActivityAsync(now, env, signal, operation) {
 	const answers = /* @__PURE__ */ new Map();
 	return (withSims) => {
 		let answer = answers.get(withSims);
 		if (!answer) {
 			answer = (async () => {
-				const sims = withSims ? await listAllIosSimsAsync({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }) : [];
-				return collectOwnedDeviceActivityAsync(loadConfig$1(), sims, now, env);
+				signal?.throwIfAborted();
+				const sims = withSims ? await listAllIosSimsAsync({
+					timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+					signal,
+					operation
+				}) : [];
+				return collectOwnedDeviceActivityAsync(loadConfig$1(), sims, now, env, signal, operation);
 			})();
 			answers.set(withSims, answer);
 		}
@@ -955,12 +1021,15 @@ function workspaceActiveReason(root, now, windowMs, devices = (withSims) => read
 	}
 	return step.value;
 }
-async function workspaceActiveReasonAsync(root, now, windowMs, devices) {
+async function workspaceActiveReasonAsync(root, now, windowMs, devices, signal) {
 	const checks = workspaceActiveChecks(root, now, windowMs);
 	let step = checks.next();
 	while (!step.done) try {
+		signal?.throwIfAborted();
 		step = checks.next(await devices(step.value));
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		signal?.throwIfAborted();
 		step = checks.throw(error);
 	}
 	return step.value;
@@ -1105,13 +1174,13 @@ function planDeviceDeletion(options) {
 	while (!step.done) step = checks.next(workspaceActiveReason(step.value, options.now, options.windowMs, activity));
 	return step.value;
 }
-async function planDeviceDeletionAsync(options, signal) {
-	const activity = cachedDeviceActivityAsync(options.now, options.env ?? process.env);
+async function planDeviceDeletionAsync(options, signal, operation) {
+	const activity = cachedDeviceActivityAsync(options.now, options.env ?? process.env, signal, operation);
 	const checks = deviceDeletionChecks(options);
 	let step = checks.next();
 	while (!step.done) {
 		signal.throwIfAborted();
-		step = checks.next(await workspaceActiveReasonAsync(step.value, options.now, options.windowMs, activity));
+		step = checks.next(await workspaceActiveReasonAsync(step.value, options.now, options.windowMs, activity, signal));
 	}
 	return step.value;
 }
@@ -1151,11 +1220,14 @@ async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices
 	const skips = [];
 	const blocked = [];
 	const days = settings.olderThanDays;
-	for (const entry of collectWorkspaceOutputs({
+	const outputs = await collectWorkspaceOutputs({
 		olderThan: days,
 		now,
-		measure: false
-	}).workspaces) {
+		measure: false,
+		signal: operation?.signal,
+		operation
+	});
+	for (const entry of outputs.workspaces) {
 		const root = entry.projectRoot === null ? null : canonicalPath(entry.projectRoot);
 		if (root === null || !entry.willClear || root === protectedRoot) continue;
 		if (pinned(root)) {
@@ -1187,7 +1259,10 @@ async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices
 		check: "sweep"
 	});
 	try {
-		const orphans = collectOrphanedWorkspaces(Object.keys(loadConfig$1()?.projects ?? {}), listMountedVolumes(), { measure: false });
+		const orphans = await collectOrphanedWorkspaces(Object.keys(loadConfig$1()?.projects ?? {}), listMountedVolumes(), {
+			measure: false,
+			operation
+		});
 		for (const orphan of orphans.orphaned) actions.push({
 			kind: "would-remove-orphan",
 			target: orphan.dir,
@@ -1200,6 +1275,8 @@ async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices
 			reason: kept.reason
 		});
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		blocked.push(`Could not look for orphaned workspace directories: ${error instanceof Error ? error.message : error}`);
 	}
 	if (devices && settings.deviceIdleDays > 0) {
@@ -1217,7 +1294,7 @@ async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices
 			},
 			env: operation?.env
 		};
-		const reaped = operation ? await planDeviceDeletionAsync(options, operation.signal) : planDeviceDeletion(options);
+		const reaped = operation ? await planDeviceDeletionAsync(options, operation.signal, operation) : planDeviceDeletion(options);
 		actions.push(...reaped.actions);
 		skips.push(...reaped.skips);
 	}
@@ -1285,7 +1362,7 @@ async function planWorktrees({ protectedRoot, pinned, now, level, graceMs, sizes
 			extra: { check: "worktree" },
 			env: operation?.env
 		};
-		const devices = operation ? await planDeviceDeletionAsync(options, operation.signal) : planDeviceDeletion(options);
+		const devices = operation ? await planDeviceDeletionAsync(options, operation.signal, operation) : planDeviceDeletion(options);
 		actions.push(...devices.actions);
 		skips.push(...devices.skips);
 	}
@@ -1343,11 +1420,15 @@ function artifactWorktree(root, entries, source = sourceCheckoutOf(entries)) {
 		keys
 	};
 }
-async function artifactWorktreesAsync(signal) {
+async function artifactWorktreesAsync(signal, operation) {
 	const found = /* @__PURE__ */ new Map();
-	for (const root of await candidateRootsAsync()) {
+	for (const root of await candidateRootsAsync(operation)) {
 		signal.throwIfAborted();
-		const { entries, ...source } = await resolveSourceCheckoutAsync(root);
+		const { entries, ...source } = await resolveSourceCheckoutAsync(root, {
+			env: operation?.env,
+			signal,
+			declareFor: operation
+		});
 		const entry = artifactWorktree(root, entries, source);
 		if (entry) found.set(entry.path, entry);
 	}
@@ -1440,10 +1521,10 @@ function artifactGuard(candidate, kind, pinned, locked) {
 	if (inUse.length) return `in use: ${inUse.join("; ")}`;
 	return null;
 }
-async function collectArtifactsAsync(kind, options, signal) {
+async function collectArtifactsAsync(kind, options, signal, operation) {
 	const candidates = [];
 	const skips = [];
-	for (const worktree of await artifactWorktreesAsync(signal)) {
+	for (const worktree of await artifactWorktreesAsync(signal, operation)) {
 		if (kind === "dependencies" && !worktree.linked) continue;
 		const root = canonicalPath(worktree.path);
 		const protectedHere = options.protectedRoot === root || options.protectedRoot.startsWith(`${root}${sep}`);
@@ -1479,11 +1560,17 @@ async function collectArtifactsAsync(kind, options, signal) {
 					"ls-files",
 					"--",
 					relative(worktree.path, path)
-				]);
+				], {
+					...operation ? childEnvironment(operation.env) : {},
+					cwd: operation?.cwd,
+					signal,
+					declareFor: operation,
+					killSignal: "SIGKILL"
+				});
 				const untracked = tracked !== null && !tracked.trim();
 				reason = keptReason(candidate, kind, options, {
 					tracked,
-					activity: untracked ? await worktreeActivityOfAsync(worktree.path, worktree.keys) : null,
+					activity: untracked ? await worktreeActivityOfAsync(worktree.path, worktree.keys, operation) : null,
 					written: untracked ? await newestWriteAsync(path, SCAN_DEPTH[kind], signal) : null
 				});
 			}
@@ -1691,17 +1778,18 @@ function inside(parent, path) {
 	return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
 }
 /** Basenames of running executables, or null when the process list cannot be read. */
-async function runningExecutables() {
-	try {
-		const out = await getExecutor().runFileAsync("ps", [
-			"-axww",
-			"-o",
-			"comm="
-		], { timeoutMs: 1e4 });
-		return new Set(out.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => basename(line)));
-	} catch {
-		return null;
-	}
+async function runningExecutables(operation, signal) {
+	const out = await runOperationFileQuiet(operation, getExecutor(), "ps", [
+		"-axww",
+		"-o",
+		"comm="
+	], {
+		timeoutMs: 1e4,
+		cwd: operation?.cwd,
+		signal
+	});
+	if (out === null) return null;
+	return new Set(out.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => basename(line)));
 }
 function stimKept(identity, scan, projects) {
 	const registered = projects.find((root) => inside(identity, root) || inside(root, identity));
@@ -1728,7 +1816,7 @@ function temporaryRoot(env) {
 * 24 hours. Null with STIM_HOME set, because TMPDIR is shared by every Stim home, and for the real TMPDIR a test
 * process recorded in STIM_TEST_GUARD_REAL_TMPDIR.
 */
-async function collectTempLeftovers({ now = Date.now(), env = process.env, signal } = {}) {
+async function collectTempLeftovers({ now = Date.now(), env = process.env, signal, operation } = {}) {
 	if (deviceSweepIsScoped(env)) return null;
 	let root;
 	let names;
@@ -1746,7 +1834,7 @@ async function collectTempLeftovers({ now = Date.now(), env = process.env, signa
 	let projects = registeredProjects();
 	let executables;
 	const traceBusy = async () => {
-		if (executables === void 0) executables = await runningExecutables();
+		if (executables === void 0) executables = await runningExecutables(operation, signal);
 		const listed = executables;
 		if (listed === null) return "the running processes could not be listed";
 		const running = [...TRACE_PROCESSES].filter((name) => listed.has(name));
@@ -1775,7 +1863,11 @@ async function collectTempLeftovers({ now = Date.now(), env = process.env, signa
 		const kind = kindOf(name, stat, jestName);
 		if (!kind) continue;
 		if (kind === "jest") {
-			const bytes = await directorySizeAsync(path, { timeoutMs: 1e4 });
+			const bytes = await directorySizeAsync(path, {
+				timeoutMs: 1e4,
+				signal,
+				operation
+			});
 			entries.push({
 				kind,
 				path,
@@ -1845,7 +1937,7 @@ function tempLeftoverSection(report) {
 	} : null;
 }
 /** Deletes what a fresh `collectTempLeftovers` marks for deletion. Returns the bytes freed and the failures. */
-async function deleteTempLeftovers(options = {}) {
+async function deleteTempLeftovers(options = {}, output = GC_OUTPUT) {
 	const report = await collectTempLeftovers(options);
 	const done = {
 		count: 0,
@@ -1861,7 +1953,7 @@ async function deleteTempLeftovers(options = {}) {
 			const staged = entry.kind === "xctrace" || name.startsWith(STAGING_PREFIX) ? entry.path : join(report.root, `${STAGING_PREFIX}${name}`);
 			const before = staged === entry.path ? null : await report.recheck?.(entry.path, entry.path, entry.kind) ?? null;
 			if (before) {
-				recordGcResult("tempLeftover", "kept", entry.path, {
+				output.record("tempLeftover", "kept", entry.path, {
 					bytes: entry.bytes,
 					detail: before
 				});
@@ -1873,6 +1965,7 @@ async function deleteTempLeftovers(options = {}) {
 				const original = name.startsWith(STAGING_PREFIX) ? join(report.root, name.slice(13)) : entry.path;
 				kept = await report.recheck?.(staged, original, entry.kind) ?? null;
 			} catch (error) {
+				if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
 				kept = `it could not be checked again: ${errorCode(error)}`;
 				if (options.signal?.aborted) {
 					if (staged !== entry.path) await rename(staged, entry.path).catch(() => {});
@@ -1885,32 +1978,33 @@ async function deleteTempLeftovers(options = {}) {
 					if (staged !== entry.path) await rename(staged, entry.path);
 				} catch (error) {
 					detail = `${kept}; it stays at ${staged} because it could not be renamed back: ${errorCode(error)}`;
-					console.log(chalk.yellow(`Kept ${entry.path} at ${staged}: ${detail}`));
+					output.log(chalk.yellow(`Kept ${entry.path} at ${staged}: ${detail}`));
 				}
-				recordGcResult("tempLeftover", "kept", entry.path, {
+				output.record("tempLeftover", "kept", entry.path, {
 					bytes: entry.bytes,
 					detail
 				});
 				continue;
 			}
-			removeTemporaryEntry(staged);
+			await removeTemporaryEntryAsync(staged, options.signal);
 			done.count++;
 			done.bytes += entry.bytes;
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
 			if (options.signal?.aborted) throw error;
 			if (errorCode(error) === "ENOENT") continue;
 			done.failures++;
 			const detail = error instanceof Error ? error.message : String(error);
-			console.log(chalk.red(`Could not delete ${entry.path}: ${detail}`));
-			recordGcResult("tempLeftover", "failed", entry.path, {
+			output.log(chalk.red(`Could not delete ${entry.path}: ${detail}`));
+			output.record("tempLeftover", "failed", entry.path, {
 				bytes: entry.bytes,
 				detail
 			});
 		}
 	}
 	if (done.count) {
-		console.log(chalk.green(`Deleted ${plural(done.count, "TMPDIR leftover")} (${formatBytes(done.bytes)}) in ${report.root}`));
-		recordGcResult("tempLeftover", "done", report.root, {
+		output.log(chalk.green(`Deleted ${plural(done.count, "TMPDIR leftover")} (${formatBytes(done.bytes)}) in ${report.root}`));
+		output.record("tempLeftover", "done", report.root, {
 			bytes: done.bytes,
 			detail: `${plural(done.count, "entry", "entries")} deleted`
 		});
@@ -1924,11 +2018,13 @@ async function planLevel2({ settings, sizes, protectedRoot, pinned, now, operati
 	const actions = [];
 	const skips = [];
 	const reason = `disk pressure level 2, idle for ${settings.pressureProtectMinutes} minutes`;
-	const outputs = collectWorkspaceOutputs({
+	const outputs = (await collectWorkspaceOutputs({
 		olderThan: null,
 		now,
-		measure: false
-	}).workspaces.flatMap((entry) => {
+		measure: false,
+		signal: operation?.signal,
+		operation
+	})).workspaces.flatMap((entry) => {
 		const root = entry.projectRoot === null ? null : canonicalPath(entry.projectRoot);
 		if (root === null || !entry.willClear || root === protectedRoot || pinned(root)) return [];
 		const used = workspaceLastUsed(root);
@@ -1958,7 +2054,8 @@ async function planLevel2({ settings, sizes, protectedRoot, pinned, now, operati
 	const leftovers = await collectTempLeftovers({
 		now,
 		env: operation?.env,
-		signal: operation?.signal
+		signal: operation?.signal,
+		operation
 	});
 	const deletable = leftovers?.entries.filter((entry) => entry.willDelete) ?? [];
 	if (leftovers && deletable.length) actions.push({
@@ -1974,7 +2071,7 @@ async function planLevel2({ settings, sizes, protectedRoot, pinned, now, operati
 		protectedRoot,
 		pinned
 	};
-	const build = operation ? await collectArtifactsAsync("build", options, operation.signal) : collectArtifacts("build", options);
+	const build = operation ? await collectArtifactsAsync("build", options, operation.signal, operation) : collectArtifacts("build", options);
 	for (const candidate of build.candidates) actions.push({
 		kind: "would-clear-build-dirs",
 		target: candidate.path,
@@ -1994,7 +2091,7 @@ async function planLevel2({ settings, sizes, protectedRoot, pinned, now, operati
 		extra: { level: 2 },
 		env: operation?.env
 	};
-	const devices = operation ? await planDeviceDeletionAsync(deviceOptions, operation.signal) : planDeviceDeletion(deviceOptions);
+	const devices = operation ? await planDeviceDeletionAsync(deviceOptions, operation.signal, operation) : planDeviceDeletion(deviceOptions);
 	actions.push(...devices.actions);
 	skips.push(...devices.skips);
 	return {
@@ -2049,7 +2146,7 @@ async function planLevel3({ settings, sizes, protectedRoot, pinned, now, refresh
 	}) : null;
 	actions.push(...worktrees?.actions ?? []);
 	skips.push(...worktrees?.skips ?? []);
-	const activity = operation ? cachedDeviceActivityAsync(now, operation.env) : null;
+	const activity = operation ? cachedDeviceActivityAsync(now, operation.env, operation.signal, operation) : null;
 	for (const root of Object.keys(loadConfig$1()?.projects ?? {}).map(canonicalPath)) {
 		if (root === protectedRoot || pinned(root)) continue;
 		if (workspaceInUse(root, {
@@ -2057,7 +2154,7 @@ async function planLevel3({ settings, sizes, protectedRoot, pinned, now, refresh
 			hosted: false,
 			nativeRun: false
 		}).length === 0) continue;
-		const active = activity ? await workspaceActiveReasonAsync(root, now, windowMs, activity) : workspaceActiveReason(root, now, windowMs);
+		const active = activity ? await workspaceActiveReasonAsync(root, now, windowMs, activity, operation?.signal) : workspaceActiveReason(root, now, windowMs);
 		if (active) skips.push({
 			target: root,
 			reason: active,
@@ -2078,7 +2175,7 @@ async function planLevel3({ settings, sizes, protectedRoot, pinned, now, refresh
 		protectedRoot,
 		pinned
 	};
-	const dependencies = operation ? await collectArtifactsAsync("dependencies", artifactOptions, operation.signal) : collectArtifacts("dependencies", artifactOptions);
+	const dependencies = operation ? await collectArtifactsAsync("dependencies", artifactOptions, operation.signal, operation) : collectArtifacts("dependencies", artifactOptions);
 	for (const candidate of dependencies.candidates) actions.push({
 		kind: "would-delete-dependencies",
 		target: candidate.path,
@@ -2163,13 +2260,17 @@ async function plannedMaintenance(pressure, sizes, settings, { devices = true, s
 		dryRun: true,
 		budget,
 		env,
-		cwd: operation?.cwd
+		cwd: operation?.cwd,
+		signal: operation?.signal,
+		operation
 	}, { volumes: () => pressure.disk }) : null;
 	if (outcome && outcome.status !== "ok") throw new Error(outcome.refusal.message);
-	const outputs = collectWorkspaceOutputs({
+	const outputs = await collectWorkspaceOutputs({
 		olderThan: null,
 		now: Date.now(),
-		measure: false
+		measure: false,
+		signal: operation?.signal,
+		operation
 	});
 	const currentSizes = sizes.map((size) => {
 		if (size.category === "compilation-cache") return {
@@ -2182,14 +2283,18 @@ async function plannedMaintenance(pressure, sizes, settings, { devices = true, s
 	});
 	const pins = /* @__PURE__ */ new Map();
 	if (operation) {
-		const candidates = await candidateRootsAsync();
+		const candidates = await candidateRootsAsync(operation);
 		const roots = /* @__PURE__ */ new Set([
 			...Object.keys(loadConfig()?.projects ?? {}),
 			...candidates,
 			...sizes.flatMap((size) => size.workspace ? [size.workspace] : []),
 			...outputs.workspaces.flatMap((entry) => entry.projectRoot ? [entry.projectRoot] : [])
 		]);
-		for (const path of candidates) for (const entry of await listWorktreesAsync(path)) roots.add(entry.path);
+		for (const path of candidates) for (const entry of await listWorktreesAsync(path, {
+			env: operation.env,
+			signal: operation.signal,
+			declareFor: operation
+		})) roots.add(entry.path);
 		for (const path of Array.from(roots, canonicalPath)) roots.add(path);
 		for (const path of roots) pins.set(path, await maintenancePinnedAsync(path, operation));
 	}
@@ -2294,6 +2399,8 @@ async function previewMaintenance({ devices = true, refresh = true, operation }
 			note: settings.invalid ?? (state === null ? "no pass has run yet; sizes have not been measured" : null)
 		};
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		return {
 			mode: settings?.mode ?? "off",
 			...settings?.invalid ? { invalid: settings.invalid } : {},
@@ -2307,8 +2414,8 @@ async function previewMaintenance({ devices = true, refresh = true, operation }
 }
 //#endregion
 //#region src/maintenance/act.ts
-function freedSince(beforeMb) {
-	const freed = lowestFree(measureDisk()) - beforeMb;
+function freedSince(beforeMb, disk = measureDisk()) {
+	const freed = lowestFree(disk) - beforeMb;
 	return Number.isFinite(freed) && freed > 0 ? Math.round(freed * 1024 * 1024) : 0;
 }
 const kept = (detail) => ({
@@ -2470,8 +2577,9 @@ async function deleteParkedDevice(action) {
 	const { results } = await quietly(async () => await deleteParkedSims(sims) + await deleteParkedAvds(avds));
 	return outcomeOf(results, freedSince(before));
 }
-async function deleteOwnedDevicesOf(root, { noneIsKept = false } = {}) {
-	if (deviceSweepIsScoped()) return null;
+async function deleteOwnedDevicesOf(root, { noneIsKept = false, operation, output = GC_OUTPUT } = {}) {
+	operation?.signal.throwIfAborted();
+	if (deviceSweepIsScoped(operation?.env ?? process.env)) return null;
 	const config = loadConfig$1();
 	const project = config?.projects?.[root];
 	if (!config || !project) return null;
@@ -2479,9 +2587,20 @@ async function deleteOwnedDevicesOf(root, { noneIsKept = false } = {}) {
 	let sims = [];
 	let avds = [];
 	try {
-		if (owns("ios")) sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
-		if (owns("android")) avds = listAvds();
+		if (owns("ios")) sims = await listAllIosSimsAsync({
+			timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+			operation,
+			signal: operation?.signal
+		});
+		operation?.signal.throwIfAborted();
+		if (owns("android")) avds = await listAvdsAsync({
+			operation,
+			signal: operation?.signal
+		});
+		operation?.signal.throwIfAborted();
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
 		return {
 			status: "failed",
 			bytes: 0,
@@ -2499,7 +2618,7 @@ async function deleteOwnedDevicesOf(root, { noneIsKept = false } = {}) {
 		lastTouched: () => 0
 	});
 	if (noneIsKept && devices.length === 0) return kept("it owns no listed devices any more");
-	const failures = await deleteProjectDevices([], devices, []);
+	const failures = await deleteProjectDevices([], devices, [], output, operation);
 	return failures ? {
 		status: "failed",
 		bytes: 0,
@@ -2541,16 +2660,31 @@ async function stopWorkspace(action, context) {
 * Deletes the owned simulators and emulators of a workspace that stays idle for `windowMs`, under its native-run
 * claim, without stopping anything: a running dev server, lease, lock or driver keeps every device.
 */
-async function deleteIdleWorkspaceDevices(root, { windowMs, protectedRoot, purpose }) {
+async function deleteIdleWorkspaceDevices(root, { windowMs, protectedRoot, purpose, operation, output }) {
+	operation?.signal.throwIfAborted();
 	if (root === protectedRoot) return kept("the command that started this pass runs in it");
-	if (maintenancePinned(root)) return kept("pinned by maintenance.keep");
-	if (deviceSweepIsScoped()) return kept("STIM_HOME scopes this config, and devices are machine-wide");
-	const active = workspaceActiveReason(root, Date.now(), windowMs);
+	if (operation ? await maintenancePinnedAsync(root, operation) : maintenancePinned(root)) return kept("pinned by maintenance.keep");
+	if (deviceSweepIsScoped(operation?.env ?? process.env)) return kept("STIM_HOME scopes this config, and devices are machine-wide");
+	const activeReason = async () => {
+		const now = Date.now();
+		if (!operation) return workspaceActiveReason(root, now, windowMs);
+		const reason = await workspaceActiveReasonAsync(root, now, windowMs, cachedDeviceActivityAsync(now, operation.env, operation.signal, operation), operation.signal);
+		operation.signal.throwIfAborted();
+		return reason;
+	};
+	const active = await activeReason();
 	if (active) return kept(active);
-	const before = lowestFree(measureDisk());
-	const run = await withIdleWorkspace(root, async () => workspaceActiveReason(root, Date.now(), windowMs) ? kept("it became active") : deleteOwnedDevicesOf(root, { noneIsKept: true }), { purpose });
+	const before = lowestFree(operation ? await measureDiskAsync(operation) : measureDisk());
+	const run = await withIdleWorkspace(root, async () => await activeReason() ? kept("it became active") : deleteOwnedDevicesOf(root, {
+		noneIsKept: true,
+		operation,
+		output
+	}), {
+		purpose,
+		operation
+	});
 	if (!run.ran) return kept(`in use: ${run.reasons.join("; ")}`);
-	const bytes = freedSince(before);
+	const bytes = operation ? freedSince(before, await measureDiskAsync(operation)) : freedSince(before);
 	return run.value ? {
 		...run.value,
 		bytes