stim 1.20.2 → 1.22.0

package/dist/{gc-qWOMdnER.mjs → gc-CXxN-4SE.mjs}

@@ -1,40 +1,47 @@
-import { A as acquireAvdClaim, D as withConfigLock$1, F as listMountedVolumes, L as volumeRootFor, M as directorySize, N as formatBytes, P as isOnMountedVolume, S as removeProject, W as projectDeviceSlots, _ as loadConfig$1, j as ownership_claim_exports, k as process_identity_exports } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { d as removeExpiredLease, h as listBuildLocks } from "./device-lease-BX1sJQ2E.mjs";
-import { D as withDirLock$1, E as workspaceStateFile, s as workspaceLastUsed, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { h as shortUdid, o as formatLongDuration, u as plural } from "./command-output-BTy8hZ0F.mjs";
-import { _ as detectIsExpo, r as findProjectRoot } from "./project-_phNIJfs.mjs";
-import { A as listAvds, H as parseAvdSystemImage, I as ownedAvdDirectory, M as listOrphanedAvdDirectories, V as parseAvdDeviceProfile, _ as avdStorageRoots, at as POOL_SETTING_REMEDY, d as androidToolPath, dt as parkedMaxSetting, ft as readParked, it as isStimOwnedSim, j as listInstalledSystemImages, m as avdNameAbsent, o as androidHome, p as avdIniPaths, rt as isStimOwnedAvd } from "./android-Mz_Inn3w.mjs";
-import { n as readCreatedDevices$1, t as forgetCreatedDevice } from "./created-devices-Dzd5C2LF.mjs";
-import { C as recordGcResult, I as listBuildSlots, T as canonicalPath, a as collectWorkspaceOutputs, c as listWorkspaceDirs, f as withIdleWorkspace, i as collectOrphanedWorkspaces, l as rootPresence, n as WORKSPACE_OUTPUT_DIRS, o as deleteOrphanedWorkspaces, p as workspaceInUse, r as clearWorkspaceOutputs, s as isInsideWorkspaces, t as REBUILD_COST, u as sizeText, w as takeGcResults } from "./workspaces-C36s2jb9.mjs";
-import { $ as memoryWorkPending, A as findStaleProjectDevices, B as previewScopedEmptying, C as deleteProjectDevices, D as eraseParkedDevices, E as deviceSweepIsScoped, F as includesParkedDevices, H as selectsBeyondCaches, I as includesRecordings, L as includesWorkspaceOutputs, M as withAndroidAvdSizes, N as emptyCaches, O as findOrphanedDevices, P as includesArchives, Q as memorySweepIsScoped, R as isWorkspacesScope, S as deleteParkedSims, T as describeUnverifiableDevices, U as trimCaches, V as selectCaches, W as parseArchiveSelector, X as memoryLines, Y as memoryCacheKind, Z as memoryScope, _ as DEVICE_LIST_TIMEOUT_MS, at as discoverCaches, b as collectParkedSims, d as collectIdleDevices, et as reclaimMemory, h as shutDownIdleDevices, j as unverifiedDeviceCommand, k as findStaleDeviceRecords, m as parseIdleDuration, nt as phase, p as idleDeviceLines, q as collectMemoryReport, st as sizeCaches, tt as scopedMemoryReport, v as collectDeviceLeases, w as describeParkedSims, x as deleteParkedAvds, y as collectParkedAvds, z as planCacheEmptying } from "./budget-f7516Zk0.mjs";
-import { f as resolveEasCliBin } from "./remote-cache-OyOyVIS3.mjs";
-import { d as listAllIosSims } from "./ios-RkW4pnQf.mjs";
-import { C as parseSessionListPage, T as verifyStoppedSession, _ as findOrphanedOwnedSessions, b as isDefinitiveMissingSessionError, d as withRemoteSessionLock, f as withEasProjectLock, v as getSessionArgs, w as stopSessionArgs, x as listOwnedSessionsArgs, y as inspectSessionForTeardown } from "./device-remote-xRT0Vmo9.mjs";
-import { a as removeEasSessionClaim, n as easMachineStateRoot$1, r as readEasSessionLedger$1 } from "./eas-session-ledger-Cm0Gwq2F.mjs";
-import { r as readCollectors } from "./ownership-DCtw_2IA.mjs";
-import { c as removeWorktrees, l as worktreePullRequestNote, n as previewMaintenance, s as collectWorktreeSweep, u as worktreeRemovalReason } from "./preview-78a9kR_-.mjs";
-import { _ as reclaimProject, g as describeDereferenced, v as deleteSelectedArchives, y as sweepArchiveStaging } from "./worktree-CgvJYJ-Q.mjs";
-import { i as getSwiftpmCacheUsage, n as swiftpmCacheLines, r as getAgentDeviceUsage, t as agentDeviceLines } from "./agent-device-usage-output-Dzgv6lgR.mjs";
-import { existsSync, lstatSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
-import { basename, dirname, isAbsolute, join } from "node:path";
-import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1 } from "path";
-import { assertHostedDeviceLedger, deviceHostArea, deviceHostRoot, hostedDeviceId, isJsonObject, listRecordedDevices, listStatusCacheEntries, maintenanceRunClaims, parseHostedPlatformDevice, readArchives, readHostedDevice, readHostedDeviceLedger, readHostedSessions, recordedBytes } from "@stim-cli/core/state";
+import { c as declareSpawnsOn, f as stopDeclaringSpawnsOn, g as process_identity_exports, h as withDrainingCancellation, r as WorkspaceProcessCleanupError, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
+import { d as workspaceDir } from "./paths-DQtTgsBf.mjs";
+import { F as isOnMountedVolume, G as projectDeviceSlots, I as listMountedVolumes, L as measuredDirectorySizeAsync, N as directorySizeAsync, O as withConfigLockAsync$1, P as formatBytes, R as volumeRootFor, S as removeProject, _ as loadConfig$1, d as getConfigDir, j as acquireAvdClaim } from "./config-DlrsduwG.mjs";
+import { h as shortUdid, o as formatLongDuration, u as plural } from "./command-output-gwpm28fu.mjs";
+import { f as throwIfCancelled, t as runOperationFile } from "./operation-exec-BW0em61G.mjs";
+import { u as workspaceLastUsed } from "./workspace-state-U08dEzhG.mjs";
+import { Et as listWorktreesAsync, It as resolveSourceCheckoutAsync } from "./settings-C7O8A6ZI.mjs";
+import { i as findProjectRoot$1, v as detectIsExpo } from "./project-wM_XFTvE.mjs";
+import { n as easMachineStateRoot$1, o as removeEasSessionClaimAsync, r as readEasSessionLedger$1 } from "./eas-session-ledger-DlY_serQ.mjs";
+import { $ as includesRecordings, At as unverifiedDeviceCommand, C as collectIdleDevices, D as idleDeviceLines, Dt as findOrphanedDevices, Et as eraseParkedDevices, Ft as withRemoteSessionGcLocks, In as runProcessOperation, Kt as withEasProjectLock, Mt as collectEasSessionSweep, Nt as deleteEasSessions, O as parseIdleDuration, Ot as findStaleDeviceRecords, Pt as describeError, Q as includesParkedDevices, Sr as sizeCaches, St as deleteProjectDevices, Tt as deviceSweepIsScoped, X as emptyCaches, Z as includesArchives, _r as phase, _t as collectDeviceLeases, at as selectsBeyondCaches, br as discoverCaches, bt as deleteParkedAvds, dr as memoryScope, dt as gradleVersionsPending, et as includesWorkspaceOutputs, fr as memorySweepIsScoped, ft as includesGradleVersions, gt as DEVICE_LIST_TIMEOUT_MS, hr as scopedMemoryReport, ht as collectInventory, ir as parseArchiveSelector, it as selectCaches, jt as withAndroidAvdSizes, k as shutDownIdleDevices, kt as findStaleProjectDevices, lr as memoryCacheKind, lt as deleteGradleVersions, mr as reclaimMemory, mt as getMachineCacheReport, nt as planCacheEmptying, ot as trimCaches, pr as memoryWorkPending, rt as previewScopedEmptying, sr as collectMemoryReport, st as collectGradleVersions, tt as isWorkspacesScope, ur as memoryLines, ut as gradleVersionLines, vt as collectParkedAvds, w as collectIdleDevicesAsync, wt as describeUnverifiableDevices, xt as deleteParkedSims, yt as collectParkedSims } from "./budget-Cvwn54qV.mjs";
+import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
+import { B as createGcResults, L as listBuildSlots, a as collectWorkspaceOutputs, c as listWorkspaceDirs, f as withIdleWorkspace, i as collectOrphanedWorkspaces, l as rootPresence, m as workspaceInUseAsync, n as WORKSPACE_OUTPUT_DIRS, o as deleteOrphanedWorkspaces, r as clearWorkspaceOutputs, s as isInsideWorkspaces, t as REBUILD_COST, u as sizeText, z as GC_OUTPUT } from "./workspaces-CpANmBlq.mjs";
+import { N as listBuildLocks, k as removeExpiredLease } from "./activity-CMLmzp7o.mjs";
+import { n as forgetCreatedDeviceAsync, r as readCreatedDevices$1 } from "./created-devices-x9rN6bhs.mjs";
+import { F as listAvdsAsync, L as listOrphanedAvdDirectories, V as ownedAvdDirectory, _t as parkedMaxSetting, dt as POOL_SETTING_REMEDY, h as avdNameAbsent } from "./android-C7sVmyI9.mjs";
+import { d as listAllIosSims, f as listAllIosSimsAsync } from "./ios-hcBpnEGk.mjs";
+import { r as readCollectors } from "./ownership-C5fo5Edb.mjs";
+import { a as matchWorktreeEntry, b as deleteSelectedArchives, v as describeDereferenced, x as sweepArchiveStaging, y as reclaimProject } from "./worktree-CHecZ4Oq.mjs";
+import { s as writeCacheFile } from "./warm-progress-CA3TgT3-.mjs";
+import { _ as collectWorktreeSweep, a as previewMaintenance, b as worktreeRemovalReason, c as deleteTempLeftovers, d as ARTIFACT_DIRS, f as appRoots, g as candidateRootsAsync, h as ownedDeviceUsage, l as tempLeftoverLines, o as triggeringRoot, p as finishedWorkspaces, s as collectTempLeftovers, t as deleteIdleWorkspaceDevices, u as tempLeftoverSection, v as removeWorktrees, y as worktreePullRequestNote } from "./act-DsuqEkiM.mjs";
+import { i as getSwiftpmCacheUsage, n as swiftpmCacheLines, r as getAgentDeviceUsage, t as agentDeviceLines } from "./agent-device-usage-output-DUFaTMdd.mjs";
+import { existsSync, lstatSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { LOG_ROTATE_BYTES, ensurePrivateDir, rotatedLogPath, withDirLock, withDirLockTransaction } from "@stim-cli/core";
+import { assertHostedDeviceLedger, configLockPath, deviceHostArea, deviceHostRoot, diskUsageCacheFile, hostedDeviceId, isJsonObject, listRecordedDevicesAsync, listStatusCacheEntries, maintenanceRunClaims, parseHostedPlatformDevice, readArchivesAsync, readDiskUsage, readHostedDevice, readHostedDeviceLedger, readHostedSessions, recordedBytes } from "@stim-cli/core/state";
+import { isAbsolute as isAbsolute$1, join as join$1 } from "path";
 import { fileURLToPath } from "node:url";
-import { closeSync as closeSync$1, existsSync as existsSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readSync as readSync$1, readdirSync as readdirSync$1, renameSync as renameSync$1, rmSync as rmSync$1, statSync as statSync$1, utimesSync as utimesSync$1, writeFileSync as writeFileSync$1 } from "fs";
-import { LOG_ROTATE_BYTES, rotatedLogPath } from "@stim-cli/core";
-import { InvalidArgumentError } from "commander";
+import { setImmediate } from "node:timers/promises";
 import chalk from "chalk";
+import { existsSync as existsSync$1 } from "fs";
+import { InvalidArgumentError } from "commander";
+import { open, readdir, rename, rm, stat, utimes, writeFile } from "node:fs/promises";
 //#region src/commands/gc/archives.ts
-function stagingOrNone() {
+async function stagingOrNone(signal) {
 	try {
-		return sweepArchiveStaging(false, 5e3);
+		return await sweepArchiveStaging(false, 5e3, signal);
 	} catch {
+		signal?.throwIfAborted();
 		return [];
 	}
 }
-function collectArchives(scope, olderThan, now) {
-	const records = readArchives();
+async function collectArchives(scope, olderThan, now, signal) {
+	signal?.throwIfAborted();
+	const records = await readArchivesAsync(signal);
 	const { kind, id } = parseArchiveSelector(scope) ?? {
 		kind: null,
 		id: null
@@ -53,7 +60,7 @@ function collectArchives(scope, olderThan, now) {
 			expires: record.expires,
 			willDelete: (id === null && olderThan !== null ? now - Date.parse(record.removedAt) >= olderThan * 864e5 : true) && (!kind || record.bytes[kind] > 0)
 		})),
-		staging: stagingOrNone(),
+		staging: await stagingOrNone(signal),
 		unknownId: id !== null && !match ? id : null,
 		knownIds: records.map((record) => record.id),
 		kind
@@ -67,467 +74,50 @@ function archiveLines(selection) {
 		...selection.staging.map((entry) => `  ${entry.path}: ${entry.kept ? `kept: ${entry.reason}` : "abandoned staging"}${entry.removeCommand ? `; ${entry.removeCommand}` : ""}`)
 	];
 }
-function deleteArchives(selection) {
+async function deleteArchives(selection, output = GC_OUTPUT, signal) {
+	signal?.throwIfAborted();
 	if (!selection) return 0;
 	let failures = 0;
-	for (const record of selection.records.filter((entry) => entry.willDelete)) try {
-		deleteSelectedArchives([record.id], selection.kind);
-		recordGcResult("archive", "done", record.id, {
-			id: record.id,
-			bytes: record.bytes
-		});
-	} catch (error) {
-		failures++;
-		recordGcResult("archive", "failed", record.id, {
-			id: record.id,
-			detail: error.message
-		});
-		console.error(`Could not delete ${record.id}: ${error.message}`);
+	for (const record of selection.records.filter((entry) => entry.willDelete)) {
+		signal?.throwIfAborted();
+		try {
+			await deleteSelectedArchives([record.id], selection.kind, signal);
+			output.record("archive", "done", record.id, {
+				id: record.id,
+				bytes: record.bytes
+			});
+		} catch (error) {
+			signal?.throwIfAborted();
+			failures++;
+			output.record("archive", "failed", record.id, {
+				id: record.id,
+				detail: error.message
+			});
+			output.error(`Could not delete ${record.id}: ${error.message}`);
+		}
 	}
 	try {
-		const remaining = new Set(sweepArchiveStaging(true, 5e3).map((entry) => entry.path));
-		for (const entry of selection.staging) if (!entry.kept && !remaining.has(entry.path)) recordGcResult("archive", "done", "archive staging", { id: entry.path });
+		const remaining = new Set((await sweepArchiveStaging(true, 5e3, signal)).map((entry) => entry.path));
+		for (const entry of selection.staging) if (!entry.kept && !remaining.has(entry.path)) output.record("archive", "done", "archive staging", { id: entry.path });
 	} catch (error) {
+		signal?.throwIfAborted();
 		failures++;
-		console.error(`Could not clear archive staging: ${error.message}`);
+		output.error(`Could not clear archive staging: ${error.message}`);
 	}
 	return failures;
 }
 function archiveRefusal(selection) {
 	if (selection?.unknownId === void 0 || selection.unknownId === null) return null;
-	process.exitCode = 1;
-	const message = `Unknown archive "${selection.unknownId}".`;
-	const remedy = `Known archive ids: ${selection.knownIds.join(", ") || "(none)"}`;
-	console.error(chalk.red(message));
-	console.error(chalk.dim(remedy));
-	console.error(chalk.red("failed: STIM_BAD_ARG"));
 	return {
 		code: "STIM_BAD_ARG",
-		message,
-		remedy
+		message: `Unknown archive "${selection.unknownId}".`,
+		remedy: `Known archive ids: ${selection.knownIds.join(", ") || "(none)"}`
 	};
 }
 function archiveWorkPending(selection, otherWork) {
 	return otherWork || Boolean(selection?.records.some((record) => record.willDelete) || selection?.staging.some((entry) => !entry.kept));
 }
 //#endregion
-//#region src/commands/gc/eas-sessions.ts
-const EAS_OPERATION_TIMEOUT_MS = 3e4;
-const EAS_COLLECTION_TIMEOUT_MS = 6e4;
-const EAS_MAX_LIST_PAGES = 100;
-const EAS_LOCK_WAIT_MS = 0;
-const EAS_LOCK_SNAPSHOT_RETRIES = 3;
-const PROXY_CREDENTIAL_ENV = ["AGENT_DEVICE_DAEMON_BASE_URL", "AGENT_DEVICE_DAEMON_AUTH_TOKEN"];
-function describeError(error) {
-	const candidate = error;
-	if (typeof candidate?.stderr === "string" && candidate.stderr.trim()) return candidate.stderr.trim();
-	if (typeof candidate?.message === "string" && candidate.message.trim()) return candidate.message.trim();
-	return String(error);
-}
-function readRecordedRemoteSessionIds(roots) {
-	const ids = /* @__PURE__ */ new Set();
-	const notices = [];
-	let safe = true;
-	for (const root of new Set(roots)) {
-		try {
-			if (!statSync$1(root).isDirectory()) throw new Error("path is not a directory");
-			readdirSync$1(root);
-		} catch (error) {
-			safe = false;
-			notices.push(`${root} is not available as a readable workspace directory: ${describeError(error)}`);
-			continue;
-		}
-		const path = workspaceStateFile(root);
-		if (!existsSync$1(path)) continue;
-		let state;
-		try {
-			state = JSON.parse(readFileSync$1(path, "utf-8"));
-		} catch (error) {
-			safe = false;
-			notices.push(`${path} could not be read as valid JSON: ${describeError(error)}`);
-			continue;
-		}
-		if (!state || typeof state !== "object" || Array.isArray(state)) {
-			safe = false;
-			notices.push(`${path} does not contain a valid workspace state object.`);
-			continue;
-		}
-		const remote = state.remoteDevice;
-		if (remote === void 0) continue;
-		if (!remote || typeof remote !== "object" || Array.isArray(remote)) {
-			safe = false;
-			notices.push(`${path} has a malformed remote session record.`);
-			continue;
-		}
-		const id = remote.sessionId;
-		if (typeof id !== "string" || id.length === 0) {
-			safe = false;
-			notices.push(`${path} has a remote session record with no valid session id.`);
-			continue;
-		}
-		ids.add(id);
-	}
-	return {
-		ids: [...ids],
-		notices,
-		safe
-	};
-}
-function claimStateAbsence(claim) {
-	const stateDir = dirname$1(claim.stateFile);
-	let entries;
-	try {
-		if (!statSync$1(stateDir).isDirectory()) throw new Error("path is not a directory");
-		entries = readdirSync$1(stateDir);
-	} catch (error) {
-		return {
-			absent: false,
-			notice: `${stateDir} is not available for EAS ownership verification: ${describeError(error)}`
-		};
-	}
-	if (!entries.includes(basename$1(claim.stateFile))) return {
-		absent: true,
-		notice: null
-	};
-	let state;
-	try {
-		state = JSON.parse(readFileSync$1(claim.stateFile, "utf-8"));
-	} catch (error) {
-		return {
-			absent: false,
-			notice: `${claim.stateFile} could not be read as valid JSON: ${describeError(error)}`
-		};
-	}
-	if (!state || typeof state !== "object" || Array.isArray(state)) return {
-		absent: false,
-		notice: `${claim.stateFile} does not contain a valid workspace state object.`
-	};
-	const remote = state.remoteDevice;
-	if (remote === void 0) return {
-		absent: true,
-		notice: null
-	};
-	if (!remote || typeof remote !== "object" || Array.isArray(remote)) return {
-		absent: false,
-		notice: `${claim.stateFile} has a malformed remote session record.`
-	};
-	const sessionId = remote.sessionId;
-	if (typeof sessionId !== "string" || !sessionId) return {
-		absent: false,
-		notice: `${claim.stateFile} has a remote session record with no valid session id.`
-	};
-	return {
-		absent: sessionId !== claim.sessionId,
-		notice: null
-	};
-}
-function collectEasSessionSweep(config, deps) {
-	const projectRoot = (deps.findProjectRoot ?? findProjectRoot)(process.cwd());
-	const empty = (notices = []) => ({
-		projectScope: projectRoot,
-		orphaned: [],
-		notices,
-		deletionSafe: notices.length === 0
-	});
-	if (!projectRoot || !(deps.detectIsExpo ?? detectIsExpo)(projectRoot)) return empty();
-	if (deps.easSweepBlockedNotice) return empty([deps.easSweepBlockedNotice]);
-	const eas = (deps.resolveEasCliBin ?? resolveEasCliBin)(projectRoot);
-	if (!eas) return empty(["EAS session sweep skipped: eas-cli is not available for the current Expo project."]);
-	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().runFile(file, args, options));
-	const sessions = [];
-	const seenCursors = /* @__PURE__ */ new Set();
-	const now = deps.easNow ?? Date.now;
-	const collectionTimeoutMs = deps.easCollectionTimeoutMs ?? EAS_COLLECTION_TIMEOUT_MS;
-	const maxPages = deps.easMaxPages ?? EAS_MAX_LIST_PAGES;
-	const deadline = now() + collectionTimeoutMs;
-	let pageCount = 0;
-	let after = null;
-	while (true) {
-		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}.`]);
-		let stdout;
-		try {
-			stdout = run(eas.file, listOwnedSessionsArgs(after), {
-				cwd: projectRoot,
-				timeoutMs: Math.min(EAS_OPERATION_TIMEOUT_MS, remainingMs),
-				omitEnv: PROXY_CREDENTIAL_ENV
-			});
-		} catch (error) {
-			return empty([...recorded.notices, `EAS session list failed for ${projectRoot}: ${describeError(error)}`]);
-		}
-		pageCount++;
-		if (now() > deadline) return empty([...recorded.notices, `EAS session list exceeded its total time limit for ${projectRoot}.`]);
-		const parsed = parseSessionListPage(stdout);
-		if (!parsed.ok) return empty([...recorded.notices, parsed.reason]);
-		sessions.push(...parsed.page.sessions);
-		if (!parsed.page.hasNextPage) break;
-		const cursor = parsed.page.endCursor?.trim();
-		if (!cursor) return empty([...recorded.notices, "EAS session list has a next page but returned no pagination cursor."]);
-		if (seenCursors.has(cursor)) return empty([...recorded.notices, `EAS session list repeated pagination cursor ${cursor}.`]);
-		seenCursors.add(cursor);
-		after = cursor;
-	}
-	const lockedRoots = deps.easLockedRoots;
-	if (lockedRoots) {
-		if (easLockRoots(projectRoot, loadConfig$1()).some((root) => !lockedRoots.includes(root))) return empty([...recorded.notices, "EAS session sweep skipped: registered workspace roots changed after remote-session locks were acquired."]);
-	}
-	const compared = findOrphanedOwnedSessions({
-		sessions,
-		recordedSessionIds: recorded.ids,
-		projectScope: projectRoot
-	});
-	const notices = [...recorded.notices, ...compared.notices];
-	if (ledger.notice) notices.push(ledger.notice);
-	const orphaned = [];
-	if (ledger.safe && recorded.safe) for (const session of compared.orphaned) {
-		const claim = ledger.claims.get(session.id);
-		if (!claim || claim.name !== session.name || claim.platform !== session.platform) {
-			notices.push(`EAS session ${session.id} (${session.name}) is unclaimed or its fixed ownership record does not match; it was not selected for deletion.`);
-			continue;
-		}
-		const state = claimStateAbsence(claim);
-		if (state.notice) {
-			notices.push(state.notice);
-			continue;
-		}
-		if (state.absent) orphaned.push(session);
-	}
-	return {
-		projectScope: projectRoot,
-		orphaned,
-		notices,
-		deletionSafe: recorded.safe && ledger.safe
-	};
-}
-function easLockRoots(projectRoot, config) {
-	return [...new Set([...Object.keys(config?.projects ?? {}), projectRoot].map(canonicalPath))].toSorted();
-}
-function unavailableLockRootNotice(roots) {
-	for (const root of roots) try {
-		if (!statSync$1(root).isDirectory()) throw new Error("path is not a directory");
-		readdirSync$1(root);
-	} catch (error) {
-		return `EAS session sweep skipped: ${root} is not available for remote-session lock inspection: ${describeError(error)}`;
-	}
-	return null;
-}
-function malformedRemoteSessionLockNotice(roots) {
-	for (const root of roots) {
-		const lockPath = join$1(workspaceDir(root), "remote-session.lock");
-		if (!existsSync$1(lockPath)) continue;
-		if ((0, ownership_claim_exports.readClaimSet)(lockPath).unresolved.length === 0) continue;
-		return `EAS session sweep skipped: the remote-session lock at ${lockPath} has a malformed owner record.`;
-	}
-	return null;
-}
-async function withRemoteSessionGcLocks(projectRoot, deps, fn) {
-	const withLock = deps.withRemoteSessionLock ?? withRemoteSessionLock;
-	const waitMs = deps.easLockWaitMs ?? EAS_LOCK_WAIT_MS;
-	const maxSnapshots = deps.easLockSnapshotRetries ?? EAS_LOCK_SNAPSHOT_RETRIES;
-	for (let attempt = 0; attempt < maxSnapshots; attempt++) {
-		const roots = easLockRoots(projectRoot, loadConfig$1());
-		const unavailable = unavailableLockRootNotice(roots);
-		if (unavailable) return fn({
-			...deps,
-			easSweepBlockedNotice: unavailable
-		});
-		const malformed = malformedRemoteSessionLockNotice(roots);
-		if (malformed) return fn({
-			...deps,
-			easSweepBlockedNotice: malformed
-		});
-		let expanded = false;
-		let coreStarted = false;
-		const acquire = (index) => index === roots.length ? (async () => {
-			if (easLockRoots(projectRoot, loadConfig$1()).some((root) => !roots.includes(root))) {
-				expanded = true;
-				return null;
-			}
-			coreStarted = true;
-			return fn({
-				...deps,
-				easSweepBlockedNotice: void 0,
-				easLockedRoots: roots
-			});
-		})() : withLock(roots[index], () => acquire(index + 1), { waitMs });
-		try {
-			const result = await acquire(0);
-			if (!expanded) return result;
-		} catch (error) {
-			if (coreStarted) throw error;
-			return fn({
-				...deps,
-				easSweepBlockedNotice: `EAS session sweep skipped: remote-session lock acquisition failed: ${describeError(error)}`
-			});
-		}
-	}
-	return fn({
-		...deps,
-		easSweepBlockedNotice: `EAS session sweep skipped: registered workspace roots kept changing during remote-session lock acquisition.`
-	});
-}
-async function deleteEasSessions(easSessionSweep, deps) {
-	let deleteFailures = 0;
-	const refuseAll = (detail) => {
-		deleteFailures += easSessionSweep.orphaned.length;
-		for (const session of easSessionSweep.orphaned) recordGcResult("easSession", "failed", session.name, {
-			id: session.id,
-			detail
-		});
-	};
-	if (easSessionSweep.orphaned.length && easSessionSweep.deletionSafe && easSessionSweep.projectScope) {
-		const projectScope = easSessionSweep.projectScope;
-		const withProjectLock = deps.withEasProjectLock ?? withEasProjectLock;
-		let finalSweepStarted = false;
-		try {
-			await withProjectLock(projectScope, () => {
-				finalSweepStarted = true;
-				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}`));
-						return;
-					}
-					const coordinatedDeps = lockedDeps;
-					const currentConfig = loadConfig$1();
-					const currentRoots = easLockRoots(projectScope, currentConfig);
-					const registryExpanded = coordinatedDeps.easLockedRoots && currentRoots.some((root) => !coordinatedDeps.easLockedRoots.includes(root));
-					const currentRecords = registryExpanded ? null : readRecordedRemoteSessionIds([...Object.keys(currentConfig?.projects ?? {}), projectScope]);
-					const ledgerRoot = coordinatedDeps.easLedgerRoot ?? easMachineStateRoot$1();
-					const ledger = readEasSessionLedger$1(ledgerRoot);
-					const removeClaim = coordinatedDeps.removeEasSessionClaim ?? removeEasSessionClaim;
-					const reconcileClaim = (sessionId) => {
-						let detail = "the claim store did not remove it";
-						try {
-							if (removeClaim(sessionId, ledgerRoot)) return;
-						} catch (error) {
-							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.`));
-					};
-					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."));
-					} 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}`));
-					} 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));
-						for (const session of easSessionSweep.orphaned) {
-							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, {
-									id: session.id,
-									detail: "it has a workspace record and was left running"
-								});
-								continue;
-							}
-							const claim = ledger.claims.get(session.id);
-							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, {
-									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"}.`
-								});
-								continue;
-							}
-							if (!eas) {
-								deleteFailures++;
-								console.log(chalk.red(`Could not verify EAS session ${session.id}: eas-cli is not available.`));
-								recordGcResult("easSession", "failed", session.name, {
-									id: session.id,
-									detail: `Could not verify EAS session ${session.id}: eas-cli is not available.`
-								});
-								continue;
-							}
-							const options = {
-								cwd: session.projectScope,
-								timeoutMs: EAS_OPERATION_TIMEOUT_MS,
-								omitEnv: PROXY_CREDENTIAL_ENV
-							};
-							let live;
-							try {
-								live = run(eas.file, getSessionArgs(session.id), options);
-							} catch (error) {
-								if (isDefinitiveMissingSessionError(error, session.id)) {
-									console.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, {
-										id: session.id,
-										detail: `Could not verify EAS session ${session.id}: ${describeError(error)}`
-									});
-								}
-								continue;
-							}
-							const inspection = inspectSessionForTeardown(live, session.id);
-							if (inspection.action === "already-stopped") {
-								console.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, {
-									id: session.id,
-									detail: `Could not stop EAS session ${session.id}: ${inspection.reason}`
-								});
-								continue;
-							}
-							let stopped;
-							try {
-								stopped = run(eas.file, stopSessionArgs(session.id), options);
-							} catch (error) {
-								deleteFailures++;
-								console.log(chalk.red(`Could not stop EAS session ${session.id}: ${describeError(error)}`));
-								recordGcResult("easSession", "failed", session.name, {
-									id: session.id,
-									detail: `Could not stop EAS session ${session.id}: ${describeError(error)}`
-								});
-								continue;
-							}
-							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, {
-									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 });
-							reconcileClaim(session.id);
-						}
-					}
-				});
-			}, {
-				waitMs: 0,
-				ownerPurpose: "EAS orphan deletion",
-				machineRoot: deps.easLedgerRoot
-			});
-		} catch (error) {
-			const phase = finalSweepStarted ? "failed" : "lock acquisition failed";
-			refuseAll(`EAS session deletion ${phase}: ${describeError(error)}`);
-			console.log(chalk.red(`EAS session deletion ${phase}: ${describeError(error)}`));
-		}
-	}
-	return deleteFailures;
-}
-//#endregion
 //#region src/commands/gc/eas-ledger.ts
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 /**
@@ -548,20 +138,92 @@ function findStaleEasLedgerEntries(mountedVolumes, deps = {}) {
 		workspaceRoot
 	}));
 }
-function forgetStaleEasLedgerEntries(entries, mountedVolumes, deps = {}) {
+async function forgetStaleEasLedgerEntries(entries, mountedVolumes, deps = {}, output = GC_OUTPUT, signal) {
+	signal?.throwIfAborted();
 	let failures = 0;
 	const root = deps.easLedgerRoot ?? easMachineStateRoot$1();
-	const remove = deps.removeEasSessionClaim ?? removeEasSessionClaim;
-	for (const entry of entries) try {
-		if (remove(entry.id, root, (claim) => isStaleEasLedgerEntry(claim, mountedVolumes))) console.log(chalk.green(`Forgot the EAS ledger entry ${entry.id} (invalid id, ${entry.workspaceRoot} is gone)`));
-		else console.log(chalk.dim(`Kept the EAS ledger entry ${entry.id}: it changed since the report.`));
-	} catch (error) {
-		failures++;
-		console.log(chalk.red(`Could not forget the EAS ledger entry ${entry.id}: ${describeError(error)}`));
+	const remove = deps.removeEasSessionClaim ?? removeEasSessionClaimAsync;
+	for (const entry of entries) {
+		await setImmediate();
+		signal?.throwIfAborted();
+		try {
+			if (await remove(entry.id, root, (claim) => isStaleEasLedgerEntry(claim, mountedVolumes), signal)) output.log(chalk.green(`Forgot the EAS ledger entry ${entry.id} (invalid id, ${entry.workspaceRoot} is gone)`));
+			else output.log(chalk.dim(`Kept the EAS ledger entry ${entry.id}: it changed since the report.`));
+		} catch (error) {
+			signal?.throwIfAborted();
+			failures++;
+			output.log(chalk.red(`Could not forget the EAS ledger entry ${entry.id}: ${describeError(error)}`));
+		}
 	}
+	signal?.throwIfAborted();
 	return failures;
 }
 //#endregion
+//#region src/devices/machine-cache-usage-output.ts
+const size = (bytes) => bytes === null ? "unknown" : formatBytes(bytes);
+function total(values) {
+	const known = values.reduce((sum, value) => sum + (value ?? 0), 0);
+	return `${values.some((value) => value === null) ? "at least " : ""}${formatBytes(known)}`;
+}
+function machineCacheLines(report, now = Date.now()) {
+	if (!report) return [];
+	const { gradle, simRuntimes, deviceSupport, runnerBuilds } = report;
+	const body = [];
+	if (gradle.unusedVersions.length) {
+		body.push(`  Gradle versions no registered project pins (${total(gradle.unusedVersions.map((entry) => entry.bytes))}):`);
+		for (const entry of gradle.unusedVersions) {
+			body.push(`    ${entry.version}: ${size(entry.bytes)}`);
+			for (const dir of entry.dirs) body.push(`      ${dir.dir}`);
+			if (entry.remedy) body.push(chalk.dim(`      remedy: ${entry.remedy}`));
+		}
+		if (gradle.unreadableProjects.length) body.push(chalk.dim(`    ${gradle.unreadableProjects.length} registered project${gradle.unreadableProjects.length === 1 ? " is" : "s are"} missing or unreadable, so a version listed here may still be in use: ${gradle.unreadableProjects.join(", ")}`));
+	}
+	if (gradle.modules) {
+		body.push(`  Gradle dependency cache: ${size(gradle.modules.bytes)}`, `    ${gradle.modules.dir}`);
+		body.push(chalk.dim(`    remedy: ${gradle.modules.remedy}`));
+	}
+	if (!simRuntimes.checked) body.push(chalk.dim("  Simulator runtimes: not checked, simctl did not answer"));
+	else if (simRuntimes.runtimes.length) {
+		body.push(`  Simulator runtimes (${total(simRuntimes.runtimes.map((entry) => entry.bytes))}):`);
+		for (const runtime of simRuntimes.runtimes) {
+			const details = [
+				runtime.devices ? `${runtime.devices} simulator${runtime.devices === 1 ? "" : "s"}` : "no simulator uses it",
+				runtime.lastUsedAt ? `last used ${runtime.lastUsedAt.slice(0, 10)}` : null,
+				runtime.deletable ? null : "not deletable"
+			].filter(Boolean);
+			body.push(`    ${runtime.runtimeIdentifier.replace(/^com\.apple\.CoreSimulator\.SimRuntime\./, "")}${runtime.build ? ` (${runtime.build})` : ""}: ${size(runtime.bytes)}, ${details.join(", ")}`);
+			if (runtime.remedy) body.push(chalk.dim(`      remedy: ${runtime.remedy}`));
+		}
+	}
+	if (deviceSupport.entries.length) {
+		body.push(`  Xcode device support (${total(deviceSupport.entries.map((entry) => entry.bytes))}):`);
+		for (const entry of deviceSupport.entries) body.push(`    ${entry.dir}: ${size(entry.bytes)}`);
+		body.push(chalk.dim(`    remedy: ${deviceSupport.remedy}`));
+	}
+	if (runnerBuilds.groups.length) {
+		const currentVersions = runnerBuilds.agentDeviceVersion && runnerBuilds.xcodeBuildVersion ? `current: agent-device ${runnerBuilds.agentDeviceVersion}, Xcode ${runnerBuilds.xcodeBuildVersion}` : "current versions unknown";
+		body.push(`  agent-device runner builds by version (${currentVersions}):`);
+		for (const group of runnerBuilds.groups) {
+			const details = [
+				`${group.entries} entr${group.entries === 1 ? "y" : "ies"}`,
+				size(group.bytes),
+				group.oldestUseAt ? `oldest use ${group.oldestUseAt.slice(0, 10)}` : null,
+				group.inUse ? `${group.inUse} in use` : null,
+				group.current ? "current" : group.current === false ? "older toolchain" : null
+			].filter(Boolean);
+			body.push(`    agent-device ${group.packageVersion ?? "unknown"}, Xcode ${group.xcodeBuildVersion ?? "unknown"}: ${details.join(", ")}`);
+		}
+		body.push(chalk.dim(`    remedy: ${runnerBuilds.remedy}`));
+	}
+	for (const notice of report.notices) body.push(chalk.dim(`  ${notice}`));
+	if (!body.length) return [];
+	return [
+		`Other tools' machine-wide caches${report.complete ? "" : " (incomplete)"} - measured ${formatLongDuration(Math.max(0, now - Date.parse(report.measuredAt)))} ago`,
+		...body,
+		chalk.dim("  Stim reports these and never deletes them; use each tool's own cleanup.")
+	];
+}
+//#endregion
 //#region src/commands/gc/status-caches.ts
 const KINDS = ["disk-usage", "pull-request"];
 const KEPT_REASON = {
@@ -627,23 +289,26 @@ function statusCacheLines(stale) {
 	lines.push("              --delete removes them; `stim status` measures a folder again if it comes back.");
 	return lines;
 }
-function deleteStaleStatusCaches(stale) {
+async function deleteStaleStatusCaches(stale, output = GC_OUTPUT, signal) {
+	signal?.throwIfAborted();
 	const mountedVolumes = listMountedVolumes();
 	let failures = 0;
 	for (const kind of KINDS) {
 		let removed = 0;
 		let bytes = 0;
 		for (const entry of stale.filter((candidate) => candidate.kind === kind)) {
+			signal?.throwIfAborted();
 			if (judge(entry.path, mountedVolumes) !== "gone") continue;
 			try {
-				rmSync(entry.file, { force: true });
+				await rm(entry.file, { force: true });
 				removed++;
 				bytes += entry.bytes;
 			} catch (error) {
+				signal?.throwIfAborted();
 				failures++;
 				const detail = error?.message || String(error);
-				console.log(chalk.red(`Could not remove ${entry.file}: ${detail}`));
-				recordGcResult("statusCache", "failed", `${kind} cache entry`, {
+				output.log(chalk.red(`Could not remove ${entry.file}: ${detail}`));
+				output.record("statusCache", "failed", `${kind} cache entry`, {
 					id: entry.file,
 					detail
 				});
@@ -651,11 +316,90 @@ function deleteStaleStatusCaches(stale) {
 		}
 		if (!removed) continue;
 		const label = `${removed} stale ${kind} cache entr${removed === 1 ? "y" : "ies"}`;
-		console.log(chalk.green(`Removed ${label}`));
-		recordGcResult("statusCache", "done", label, { bytes });
+		output.log(chalk.green(`Removed ${label}`));
+		output.record("statusCache", "done", label, { bytes });
+	}
+	signal?.throwIfAborted();
+	return failures;
+}
+//#endregion
+//#region src/commands/gc/finished-devices.ts
+/** The owned devices of workspaces whose linked worktree is finished but kept, such as a dirty one. */
+function collectFinishedDevices({ config, sims, avds, sweep, now = Date.now() }) {
+	const keys = Object.keys(config?.projects ?? {});
+	const devices = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const { root, reason } of finishedWorkspaces(sweep, now)) {
+		const key = keys.find((candidate) => canonicalPath(candidate) === root);
+		const project = key ? config?.projects[key] : void 0;
+		if (!config || !key || !project || seen.has(key)) continue;
+		seen.add(key);
+		for (const { idleDays: _idleDays, ...device } of findStaleProjectDevices({
+			config: {
+				...config,
+				projects: { [key]: project }
+			},
+			sims,
+			avds,
+			olderThanDays: 0,
+			lastTouched: () => 0
+		})) devices.push({
+			...device,
+			reason
+		});
+	}
+	return devices;
+}
+function finishedDeviceLines(devices = []) {
+	if (!devices.length) return [];
+	const lines = [`Owned devices of finished worktrees (${devices.length}) - the worktree is kept, its devices are not:`];
+	for (const device of devices) {
+		lines.push(`  ${device.kind} ${device.name} (${device.id})${device.bytes ? ` ${formatBytes(device.bytes)}` : ""}`);
+		lines.push(`              ${device.project}: ${device.reason}`);
+	}
+	lines.push("              --delete keeps a workspace that is in use, leased, driven, locked or pinned.");
+	return lines;
+}
+async function deleteFinishedDevices({ finishedDevices: devices, worktreeSweep }, output = GC_OUTPUT, operation) {
+	const graceMs = worktreeSweep?.graceMs ?? 0;
+	let failures = 0;
+	for (const project of new Set(devices.map((device) => device.project))) {
+		operation?.signal.throwIfAborted();
+		const outcome = await deleteIdleWorkspaceDevices(canonicalPath(project), {
+			windowMs: graceMs,
+			protectedRoot: triggeringRoot(operation),
+			purpose: "stim gc --delete",
+			operation,
+			output
+		});
+		if (outcome.status === "kept") {
+			output.log(chalk.yellow(`Kept the owned devices of ${project}: ${outcome.detail}`));
+			output.record("device", "kept", project, { detail: outcome.detail });
+		} else if (outcome.status === "failed") {
+			failures++;
+			output.log(chalk.red(`Could not delete the owned devices of ${project}: ${outcome.detail}`));
+			output.record("device", "failed", project, { detail: outcome.detail });
+		}
 	}
 	return failures;
 }
+/** Owned simulator and emulator disk of registered workspaces, by platform. */
+function ownedDeviceDisk(usage, unmeasured = {}) {
+	return ["ios", "android"].flatMap((kind) => {
+		const owned = usage.filter((device) => device.kind === kind && device.workspace);
+		const missing = unmeasured[kind] ?? 0;
+		return owned.length || missing ? [{
+			kind,
+			count: owned.length,
+			bytes: owned.reduce((sum, device) => sum + device.bytes, 0),
+			unmeasured: missing
+		}] : [];
+	});
+}
+function ownedDeviceDiskLines(disk = []) {
+	if (!disk.length) return [];
+	return [`Owned device disk: ${disk.map(({ kind, count, bytes, unmeasured }) => `${count} ${kind === "ios" ? "simulators" : "emulators"} ${formatBytes(bytes)}${unmeasured ? ` (${unmeasured} not measured)` : ""}`).join(", ")}`];
+}
 //#endregion
 //#region src/commands/gc/recordings.ts
 const DAY_MS = 864e5;
@@ -702,23 +446,37 @@ function planRecordings(entries, { whole, olderThan, now }) {
 * workspace and dead project sweeps remove whole, are listed with them; entries whose project root is on an
 * unmounted volume are left out.
 */
-function collectRecordings(plan, gone = []) {
+async function collectRecordings(plan, gone = [], signal) {
+	signal?.throwIfAborted();
 	const mountedVolumes = listMountedVolumes();
-	return planRecordings(listWorkspaceDirs().filter((entry) => entry.projectRoot === null || isOnMountedVolume(entry.projectRoot, mountedVolumes)).map((entry) => Object.assign({}, entry, { recordings: join$1(entry.dir, "recordings") })).filter((entry) => existsSync$1(entry.recordings)).map((entry) => Object.assign({}, entry, {
-		gone: gone.includes(entry.dir),
-		devices: listRecordedDevices(entry.recordings)
-	})), plan);
+	const entries = [];
+	for (const entry of listWorkspaceDirs()) {
+		signal?.throwIfAborted();
+		if (entry.projectRoot !== null && !isOnMountedVolume(entry.projectRoot, mountedVolumes)) continue;
+		const recordings = join$1(entry.dir, "recordings");
+		if (!existsSync$1(recordings)) continue;
+		entries.push({
+			...entry,
+			recordings,
+			gone: gone.includes(entry.dir),
+			devices: await listRecordedDevicesAsync(recordings, false, signal)
+		});
+	}
+	signal?.throwIfAborted();
+	return planRecordings(entries, plan);
 }
 /** Deletes what `planRecordings` chose, planning again from the files on disk. */
-function deleteRecordings(report, plan) {
+async function deleteRecordings(report, plan, output = GC_OUTPUT, signal) {
+	signal?.throwIfAborted();
 	let failures = 0;
 	for (const entry of report) {
+		signal?.throwIfAborted();
 		const label = entry.projectRoot ?? entry.dir;
 		if (entry.withWorkspace) continue;
 		if (!entry.willDelete) {
 			if (entry.keptCode === "unresolved" || entry.keptCode === "recently-recorded") {
-				console.log(chalk.dim(`Kept the device recordings of ${label}: ${entry.keptReason}`));
-				recordGcResult("recording", "kept", label, {
+				output.log(chalk.dim(`Kept the device recordings of ${label}: ${entry.keptReason}`));
+				output.record("recording", "kept", label, {
 					bytes: entry.bytes,
 					detail: entry.keptReason
 				});
@@ -728,27 +486,34 @@ function deleteRecordings(report, plan) {
 		try {
 			let deleted = 0;
 			if (plan.whole) {
-				deleted = recordedBytes(listRecordedDevices(entry.dir));
-				rmSync$1(entry.dir, {
+				deleted = recordedBytes(await listRecordedDevicesAsync(entry.dir, false, signal));
+				signal?.throwIfAborted();
+				await rm(entry.dir, {
 					recursive: true,
 					force: true
 				});
-			} else if (plan.olderThan !== null) for (const segment of oldSegments(listRecordedDevices(entry.dir), plan.olderThan, plan.now)) {
-				rmSync$1(segment.file, { force: true });
-				deleted += segment.bytes;
+			} else if (plan.olderThan !== null) {
+				const devices = await listRecordedDevicesAsync(entry.dir, false, signal);
+				for (const segment of oldSegments(devices, plan.olderThan, plan.now)) {
+					signal?.throwIfAborted();
+					await rm(segment.file, { force: true });
+					deleted += segment.bytes;
+				}
 			}
-			console.log(chalk.green(`Deleted ${formatBytes(deleted)} of device recordings of ${label}`));
-			recordGcResult("recording", "done", label, { bytes: deleted });
+			output.log(chalk.green(`Deleted ${formatBytes(deleted)} of device recordings of ${label}`));
+			output.record("recording", "done", label, { bytes: deleted });
 		} catch (error) {
+			signal?.throwIfAborted();
 			failures++;
 			const detail = error?.message || String(error);
-			console.log(chalk.red(`Could not delete the device recordings of ${label}: ${detail}`));
-			recordGcResult("recording", "failed", label, {
+			output.log(chalk.red(`Could not delete the device recordings of ${label}: ${detail}`));
+			output.record("recording", "failed", label, {
 				bytes: entry.bytes,
 				detail
 			});
 		}
 	}
+	signal?.throwIfAborted();
 	return failures;
 }
 function recordingLines(recordings) {
@@ -850,7 +615,7 @@ function staleEasLedgerLines(entries = []) {
 		"              --delete forgets the LEDGER ENTRY only; no EAS session is contacted."
 	];
 }
-function formatGcReport({ maintenance, archives, skipped = [], deadProjects = [], orphanedPorts, invalidProjects = [], orphanedWorkspaces = [], parkedSims = [], parkedAvds = [], parkedHostedDevices, orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], staleLedgerEntries = [], staleEasLedgerEntries, staleStatusCaches = [], buildLocks = {
+function formatGcReport({ maintenance, archives, skipped = [], deadProjects = [], orphanedPorts, invalidProjects = [], orphanedWorkspaces = [], parkedSims = [], parkedAvds = [], parkedHostedDevices, orphanedDevices = [], unverifiedDevices = [], staleDevices = [], finishedDevices, ownedDeviceDisk, staleDeviceRecords = [], staleLedgerEntries = [], staleEasLedgerEntries, staleStatusCaches = [], buildLocks = {
 	stale: [],
 	live: [],
 	unresolved: []
@@ -866,10 +631,11 @@ function formatGcReport({ maintenance, archives, skipped = [], deadProjects = []
 	orphaned: [],
 	notices: [],
 	deletionSafe: true
-}, agentDeviceUsage = null, swiftpmCacheUsage, caches = [], workspaceOutputs = null, workspaceLogs = [], recordings = [], worktreeSweep = null, memory, cacheScope = null, olderThan = null }, { now = Date.now() } = {}) {
+}, agentDeviceUsage = null, swiftpmCacheUsage, machineCaches, tempLeftovers, gradleVersions, caches = [], workspaceOutputs = null, workspaceLogs = [], recordings = [], worktreeSweep = null, memory, cacheScope = null, olderThan = null }, { now = Date.now() } = {}) {
 	const lines = archiveLines(archives);
 	const parkedHostedLines = formatParkedHostedDeviceReport(parkedHostedDevices, now);
 	const easLedgerLines = staleEasLedgerLines(staleEasLedgerEntries);
+	const finishedLines = finishedDeviceLines(finishedDevices);
 	const staleLocks = buildLocks?.stale ?? [];
 	const liveLocks = buildLocks?.live ?? [];
 	const staleSlots = buildSlots?.stale ?? [];
@@ -884,6 +650,7 @@ function formatGcReport({ maintenance, archives, skipped = [], deadProjects = []
 		parkedHostedLines,
 		orphanedDevices,
 		staleDevices,
+		finishedLines,
 		staleDeviceRecords,
 		staleLedgerEntries,
 		easLedgerLines,
@@ -908,6 +675,7 @@ function formatGcReport({ maintenance, archives, skipped = [], deadProjects = []
 	lines.push(...namedPortLines(orphanedPorts));
 	lines.push(...orphanedWorkspaceLines(orphanedWorkspaces));
 	lines.push(...worktreeSweepLines(worktreeSweep));
+	lines.push(...unlistedWorktreeLines(worktreeSweep));
 	lines.push(...formatParkedSimReport(parkedSims, now, cacheScope !== null));
 	lines.push(...formatParkedAvdReport(parkedAvds, now, cacheScope !== null));
 	lines.push(...parkedHostedLines);
@@ -930,6 +698,7 @@ function formatGcReport({ maintenance, archives, skipped = [], deadProjects = []
 			lines.push(`              ${d.project} (idle ${d.idleDays}d)`);
 		}
 	}
+	lines.push(...finishedLines, ...ownedDeviceDiskLines(ownedDeviceDisk));
 	lines.push(...idleDeviceLines(idleDevices));
 	if (staleDeviceRecords.length) {
 		lines.push(`Stale device records (${staleDeviceRecords.length}) - the device is gone, the project is not:`);
@@ -995,6 +764,9 @@ function formatGcReport({ maintenance, archives, skipped = [], deadProjects = []
 	lines.push(...cacheLines(caches, workspaceOutputs));
 	lines.push(...agentDeviceLines(agentDeviceUsage, true, now));
 	lines.push(...swiftpmCacheLines(swiftpmCacheUsage, now));
+	lines.push(...machineCacheLines(machineCaches, now));
+	lines.push(...tempLeftoverLines(tempLeftovers));
+	lines.push(...gradleVersionLines(gradleVersions));
 	lines.push(...memoryLines(memory, memoryCacheKind(cacheScope), now));
 	lines.push(...maintenanceReportLines(maintenance));
 	return lines;
@@ -1072,18 +844,20 @@ function cacheLines(caches, workspaceOutputs) {
 		if (outputs) lines.push(...workspaceOutputLines(outputs, outputBytes));
 		for (const c of caches) {
 			const tag = c.source ? ` (${c.source})` : "";
-			lines.push(`  ${formatBytes(c.bytes ?? 0).padStart(10)}  ${c.name}${tag}`);
+			lines.push(`  ${sizeText(c.bytes ?? null).padStart(10)}  ${c.name}${tag}`);
 			lines.push(`              ${c.dir}`);
 			if (c.note) lines.push(`              ${c.note}`);
+			if (c.sizeError) lines.push(`              ${c.sizeError}`);
 			if (c.willEmpty) lines.push("              would be EMPTIED");
 			else if (c.emptySkipped) lines.push(`              would be left alone: ${c.emptySkipped}`);
 			else if (c.scopedEmpty?.emptySkipped) lines.push(`              --delete --cache would leave it alone: ${c.scopedEmpty.emptySkipped}`);
 		}
-		lines.push(`  total: ${formatBytes(total)}`);
+		const incomplete = caches.some((c) => c.bytes === void 0) || outputs?.workspaces.some((w) => w.bytes === null);
+		lines.push(`  total: ${incomplete ? "at least " : ""}${formatBytes(total)}`);
 		const doomed = caches.filter((c) => c.willEmpty);
 		if (doomed.length) {
 			const doomedBytes = doomed.reduce((n, c) => n + (c.bytes ?? 0), 0);
-			lines.push(`  would empty ${doomed.length} of these (${formatBytes(doomedBytes)})`);
+			lines.push(`  would empty ${doomed.length} of these (${doomed.some((c) => c.bytes === void 0) ? "at least " : ""}${formatBytes(doomedBytes)})`);
 		}
 		const clearing = outputs?.workspaces.filter((w) => w.willClear) ?? [];
 		if (clearing.length) {
@@ -1093,6 +867,29 @@ function cacheLines(caches, workspaceOutputs) {
 	}
 	return lines;
 }
+const BUILD_STATE_DIRS_SHOWN = 4;
+function buildStateLine(state) {
+	if (!state?.dirs.length) return null;
+	const shown = state.dirs.slice(0, BUILD_STATE_DIRS_SHOWN).map((dir) => `${dir.path} ${sizeText(dir.bytes)}`);
+	const more = state.dirs.length > BUILD_STATE_DIRS_SHOWN ? ", ..." : "";
+	return `              in-tree build state ${sizeText(state.bytes)}: ${shown.join(", ")}${more}`;
+}
+function unlistedWorktreeLines(sweep) {
+	const unlisted = sweep?.unlisted ?? [];
+	if (!unlisted.length) return [];
+	const lines = [`Directories under .worktrees that git does not list as worktrees (${unlisted.length}) - reported, never removed:`];
+	for (const dir of unlisted) {
+		lines.push(`  ${dir.path} (${sizeText(dir.bytes)})`);
+		lines.push(`              ${unlistedWorktreeDetail(dir)}`);
+	}
+	return lines;
+}
+function unlistedWorktreeDetail(dir) {
+	return `git worktree list in ${dir.repository} does not show it, so gc cannot tell whether it holds work; look through it, then remove it with \`${unlistedWorktreeRemedy(dir)}\``;
+}
+function unlistedWorktreeRemedy(dir) {
+	return `rm -rf '${dir.path.replaceAll("'", "'\\''")}'`;
+}
 function worktreeSweepLines(sweep) {
 	if (!sweep || !sweep.idle && !sweep.worktrees.length) return [];
 	const removable = sweep.worktrees.filter((w) => !w.skipped);
@@ -1103,8 +900,10 @@ function worktreeSweepLines(sweep) {
 	for (const w of sweep.worktrees) {
 		const age = w.idleDays === null ? "" : ` (idle ${w.idleDays}d)`;
 		lines.push(`  ${w.path}${age}`);
+		const buildState = buildStateLine(w.buildState);
+		if (buildState) lines.push(buildState);
 		const note = worktreePullRequestNote(w);
-		lines.push(w.skipped ? `              kept: ${w.skipped}${note && !w.skipped.includes(note) ? ` (${note})` : ""}` : `              would be REMOVED by \`stim worktree remove\`: ${worktreeRemovalReason(w)}`);
+		lines.push(w.skipped ? `              kept: ${w.skipped}${note && !w.skipped.includes(note) ? ` (${note})` : ""}` : `              would be REMOVED by \`stim worktree remove\`: ${worktreeRemovalReason(w, sweep)}`);
 	}
 	if (removable.length) lines.push("              --delete runs it without --force; use, idleness and HEAD are re-checked under its removal locks.");
 	return lines;
@@ -1127,7 +926,22 @@ function jsonPullRequest(lookup) {
 		containsHead: pr.containsHead
 	} : null;
 }
-function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedPorts = [], invalidProjects = [], orphanedWorkspaces = [], worktreeSweep = null, parkedSims = [], parkedAvds = [], parkedHostedDevices = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], staleLedgerEntries = [], staleEasLedgerEntries = [], staleStatusCaches = [], buildLocks = {
+function linkedWorktreesJson(sweep) {
+	if (!sweep) return [];
+	return sweep.worktrees.map((w) => ({
+		path: w.path,
+		idleDays: w.idleDays,
+		mergedInto: w.merge?.merged ? w.merge.into : null,
+		pullRequest: jsonPullRequest(w.pullRequest),
+		pullRequestUnknown: w.pullRequest && "unavailable" in w.pullRequest ? w.pullRequest.unavailable : null,
+		willRemove: w.skipCode === null,
+		reason: w.skipCode,
+		detail: w.skipped ?? worktreeRemovalReason(w, sweep),
+		eligibleAt: w.eligibleAt === null ? null : new Date(w.eligibleAt).toISOString(),
+		buildState: w.buildState ?? null
+	}));
+}
+function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedPorts = [], invalidProjects = [], orphanedWorkspaces = [], worktreeSweep = null, parkedSims = [], parkedAvds = [], parkedHostedDevices = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], finishedDevices = [], ownedDeviceDisk = [], staleDeviceRecords = [], staleLedgerEntries = [], staleEasLedgerEntries = [], staleStatusCaches = [], buildLocks = {
 	stale: [],
 	live: [],
 	unresolved: []
@@ -1143,7 +957,7 @@ function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedP
 	orphaned: [],
 	notices: [],
 	deletionSafe: true
-}, workspaceOutputs = null, workspaceLogs = [], recordings = [], agentDeviceUsage = null, swiftpmCacheUsage = null, caches = [], memory = null }) {
+}, workspaceOutputs = null, workspaceLogs = [], recordings = [], agentDeviceUsage = null, swiftpmCacheUsage = null, machineCaches = null, tempLeftovers = null, gradleVersions = null, caches = [], memory = null }) {
 	return {
 		...archives ? {
 			archived: archives.records,
@@ -1161,16 +975,12 @@ function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedP
 			projectRoot,
 			bytes: bytes ?? null
 		})),
-		linkedWorktrees: (worktreeSweep?.worktrees ?? []).map((w) => ({
-			path: w.path,
-			idleDays: w.idleDays,
-			mergedInto: w.merge?.merged ? w.merge.into : null,
-			pullRequest: jsonPullRequest(w.pullRequest),
-			pullRequestUnknown: w.pullRequest && "unavailable" in w.pullRequest ? w.pullRequest.unavailable : null,
-			willRemove: w.skipCode === null,
-			reason: w.skipCode,
-			detail: w.skipped ?? worktreeRemovalReason(w),
-			eligibleAt: w.eligibleAt === null ? null : new Date(w.eligibleAt).toISOString()
+		linkedWorktrees: linkedWorktreesJson(worktreeSweep),
+		unlistedWorktreeDirectories: (worktreeSweep?.unlisted ?? []).map((dir) => ({
+			path: dir.path,
+			repository: dir.repository,
+			bytes: dir.bytes,
+			remedy: unlistedWorktreeRemedy(dir)
 		})),
 		parkedSimulators: parkedSims.map(({ udid, name, model, runtime, parkedAt, app, bytes, listed }) => ({
 			udid,
@@ -1214,6 +1024,16 @@ function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedP
 			idleDays: d.idleDays,
 			bytes: d.bytes ?? null
 		})),
+		finishedDevices: finishedDevices.map((d) => ({
+			kind: d.kind,
+			id: d.id,
+			name: d.name,
+			project: d.project,
+			slot: d.slot ?? null,
+			bytes: d.bytes ?? null,
+			reason: d.reason
+		})),
+		ownedDeviceDisk,
 		staleDeviceRecords: staleDeviceRecords.map((r) => ({
 			kind: r.kind,
 			id: r.id,
@@ -1325,12 +1145,203 @@ function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedP
 		})),
 		agentDevice: agentDeviceUsage,
 		swiftpmCache: swiftpmCacheUsage,
+		machineCaches,
+		tempLeftovers: tempLeftoverSection(tempLeftovers),
+		gradleVersions,
 		memory: memory?.processes ?? [],
 		watchmanRoots: memory?.watchmanRoots ?? [],
 		memoryNotices: (memory?.notices ?? []).map((message) => ({ message }))
 	};
 }
 //#endregion
+//#region src/commands/gc/worktree-sizes.ts
+const SIZE_TIMEOUT_MS = 3e4;
+const BUILD_STATE_MAX_AGE_MS = 36e5;
+const BUILD_STATE_TIMEOUT_MS = 1e4;
+const BUILD_STATE_CONCURRENCY = 4;
+const PNPM_STORE = ".pnpm-store";
+const WORKTREES_DIR = ".worktrees";
+function isDirectory(path) {
+	try {
+		return lstatSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function inside(root, path) {
+	const rel = relative(root, path);
+	return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+async function buildStateDirs(path, keys, operation) {
+	const entries = await listWorktreesAsync(path, {
+		env: operation?.env,
+		signal: operation?.signal,
+		declareFor: operation
+	});
+	const own = keys.filter((key) => matchWorktreeEntry(entries, key)?.path === path);
+	const root = canonicalPath(path);
+	const worktree = {
+		path,
+		linked: true,
+		keys: own
+	};
+	const dirs = /* @__PURE__ */ new Map();
+	const add = (dir) => {
+		if (!isDirectory(dir)) return;
+		const real = canonicalPath(dir);
+		if (inside(root, real) && !dirs.has(real)) dirs.set(real, dir);
+	};
+	for (const kind of ["build", "dependencies"]) for (const base of appRoots(worktree, kind)) for (const dir of ARTIFACT_DIRS[kind]) add(join(base, dir));
+	add(join(path, PNPM_STORE));
+	return [...dirs.keys()];
+}
+function cachedSize(dir, now) {
+	const cached = readDiskUsage(dir);
+	if (!cached) return null;
+	const at = Date.parse(cached.measuredAt);
+	if (now - at >= BUILD_STATE_MAX_AGE_MS) return null;
+	try {
+		return statSync(dir).mtimeMs > at ? null : cached.bytes;
+	} catch {
+		return null;
+	}
+}
+async function duSize(dir, operation) {
+	let out;
+	try {
+		out = await runOperationFile(operation, getExecutor(), "du", ["-sk", dir], {
+			timeoutMs: BUILD_STATE_TIMEOUT_MS,
+			killSignal: "SIGKILL",
+			cwd: operation?.cwd,
+			signal: operation?.signal
+		});
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
+		const stdout = error instanceof Error && "stdout" in error ? error.stdout : null;
+		out = typeof stdout === "string" ? stdout : "";
+	}
+	const kb = /^(\d+)\t/.exec(out)?.[1];
+	return kb ? Number(kb) * 1024 : null;
+}
+async function eachLimited(items, limit, run) {
+	const queue = items[Symbol.iterator]();
+	const worker = async () => {
+		for (const item of queue) await run(item);
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+}
+/**
+* Sizes the regenerable directories maintenance clears and a project-local `.pnpm-store` in each worktree of the
+* sweep, from the disk-usage cache while an entry is under an hour old and no entry was added to or removed from the
+* directory since. Stale directories are measured with one `du` each, sequentially with an operation and at most
+* 4 at once otherwise, with 10 seconds each, so a
+* slow tree delays only itself; a directory du could not measure in time is reported unmeasured (null). Also lists
+* the directories directly under a repository's `.worktrees/` that are no git worktree at all.
+*/
+async function measureWorktreeSweep(sweep, operation) {
+	operation?.signal.throwIfAborted();
+	const now = Date.now();
+	const pending = [];
+	for (const candidate of sweep.worktrees) {
+		operation?.signal.throwIfAborted();
+		if (candidate.skipCode === "not-a-worktree") continue;
+		const dirs = await buildStateDirs(candidate.path, candidate.keys, operation);
+		pending.push({
+			candidate,
+			root: canonicalPath(candidate.path),
+			dirs,
+			sizes: new Map(dirs.map((dir) => [dir, cachedSize(dir, now)]))
+		});
+	}
+	const due = pending.flatMap(({ sizes }) => [...sizes].flatMap(([dir, bytes]) => bytes === null ? [{
+		dir,
+		sizes
+	}] : []));
+	const worktrees = new Set(due.map(({ sizes }) => sizes)).size;
+	if (due.length) phase("worktrees", `measuring the build state of ${plural(worktrees, "worktree")}`, operation);
+	await eachLimited(due, operation ? 1 : BUILD_STATE_CONCURRENCY, async ({ dir, sizes }) => {
+		operation?.signal.throwIfAborted();
+		const measuredAt = (/* @__PURE__ */ new Date()).toISOString();
+		const bytes = await duSize(dir, operation);
+		if (bytes === null) return;
+		sizes.set(dir, bytes);
+		operation?.signal.throwIfAborted();
+		writeCacheFile(diskUsageCacheFile(dir), {
+			path: dir,
+			measuredAt,
+			bytes
+		});
+	});
+	for (const { candidate, root, dirs, sizes } of pending) {
+		const entries = dirs.map((dir) => ({
+			path: relative(root, dir).split(sep).join("/"),
+			bytes: sizes.get(dir) ?? null
+		}));
+		candidate.buildState = {
+			bytes: entries.every((dir) => dir.bytes !== null) ? entries.reduce((sum, dir) => sum + (dir.bytes ?? 0), 0) : null,
+			dirs: entries.toSorted((a, b) => (b.bytes ?? 0) - (a.bytes ?? 0))
+		};
+	}
+	sweep.unlisted = await unlistedWorktreeDirs(operation);
+	return sweep;
+}
+/** Whether `path` is a checkout git still knows: its own `.git` directory, or a `.git` file whose gitdir exists. */
+function hasLiveGitDir(path) {
+	const dotGit = join(path, ".git");
+	let text;
+	try {
+		if (lstatSync(dotGit).isDirectory()) return true;
+		text = readFileSync(dotGit, "utf-8");
+	} catch {
+		return false;
+	}
+	const gitdir = /^gitdir:\s*(.+)$/m.exec(text)?.[1]?.trim();
+	return Boolean(gitdir) && existsSync(resolve(dirname(dotGit), gitdir ?? ""));
+}
+async function unlistedWorktreeDirs(operation) {
+	const repositories = /* @__PURE__ */ new Map();
+	const options = {
+		env: operation?.env,
+		signal: operation?.signal,
+		declareFor: operation
+	};
+	for (const root of await candidateRootsAsync(operation)) {
+		operation?.signal.throwIfAborted();
+		const { entries, ...source } = await resolveSourceCheckoutAsync(root, options);
+		if ("refusal" in source || repositories.has(source.path)) continue;
+		repositories.set(source.path, entries.map((entry) => canonicalPath(entry.path)));
+	}
+	const found = [];
+	for (const [repository, listed] of repositories) {
+		operation?.signal.throwIfAborted();
+		const parent = join(repository, WORKTREES_DIR);
+		let names;
+		try {
+			names = readdirSync(parent);
+		} catch {
+			continue;
+		}
+		for (const name of names.toSorted()) {
+			operation?.signal.throwIfAborted();
+			const path = join(parent, name);
+			if (!isDirectory(path) || hasLiveGitDir(path)) continue;
+			const real = canonicalPath(path);
+			if (listed.some((entry) => entry === real || entry.startsWith(`${real}${sep}`))) continue;
+			found.push({
+				path,
+				repository,
+				bytes: await measuredDirectorySizeAsync(path, {
+					timeoutMs: SIZE_TIMEOUT_MS,
+					operation,
+					signal: operation?.signal
+				})
+			});
+		}
+	}
+	return found;
+}
+//#endregion
 //#region src/commands/gc/ledger.ts
 /** `sims` must be a complete listing, unavailable simulators included, taken after `ledger` was read. */
 function findStaleLedgerEntries(ledger, sims) {
@@ -1361,15 +1372,23 @@ function isStaleAvdName(name, config) {
 function reservedForSetup(name, config) {
 	return Object.values(config?.projects ?? {}).some((project) => projectDeviceSlots(project).some(({ platforms }) => platforms.android?.setupIncomplete && platforms.android.avdName === name));
 }
-function forgetStaleAvdName(name) {
+async function forgetStaleAvdName(name, signal) {
 	let claim = null;
 	try {
 		claim = acquireAvdClaim(name);
-		return withConfigLock$1(() => {
-			if (!isStaleAvdName(name, loadConfig$1())) return false;
-			forgetCreatedDevice("android", name);
-			return true;
-		});
+		while (true) try {
+			return await forgetCreatedDeviceAsync("android", name, signal, (forget) => withDirLock(configLockPath(), () => {
+				if (!isStaleAvdName(name, loadConfig$1())) return false;
+				forget();
+				return true;
+			}, {
+				waitMs: 0,
+				ensureParent: () => ensurePrivateDir(getConfigDir())
+			}));
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "STIM_LOCK_TIMEOUT" && "lockPath" in error && error.lockPath === configLockPath())) throw error;
+			await withConfigLockAsync$1(() => {}, signal);
+		}
 	} finally {
 		(0, ownership_claim_exports.releaseClaim)(claim);
 	}
@@ -1396,23 +1415,28 @@ function isDanglingLink(path) {
 		return false;
 	}
 }
-function forgetStaleLedgerEntries(entries) {
+async function forgetStaleLedgerEntries(entries, output = GC_OUTPUT, signal) {
+	signal?.throwIfAborted();
 	let failures = 0;
 	for (const entry of entries) {
+		await setImmediate();
+		signal?.throwIfAborted();
 		if (entry.kind === "web" && !isStaleProfile(entry.id, existsSync)) continue;
 		try {
 			if (entry.kind === "android") {
-				if (!forgetStaleAvdName(entry.id)) {
-					console.log(chalk.dim(`Kept the ledger entry for android ${entry.id}: the AVD or its setup reappeared`));
+				if (!await forgetStaleAvdName(entry.id, signal)) {
+					output.log(chalk.dim(`Kept the ledger entry for android ${entry.id}: the AVD or its setup reappeared`));
 					continue;
 				}
-			} else forgetCreatedDevice(entry.kind, entry.id);
-			console.log(chalk.green(`Forgot the ledger entry for ${entry.kind} ${entry.id} (not on this machine)`));
+			} else await forgetCreatedDeviceAsync(entry.kind, entry.id, signal);
+			output.log(chalk.green(`Forgot the ledger entry for ${entry.kind} ${entry.id} (not on this machine)`));
 		} catch (error) {
+			signal?.throwIfAborted();
 			failures++;
-			console.log(chalk.red(`Could not forget the ledger entry for ${entry.kind} ${entry.id}: ${error?.message || error}`));
+			output.log(chalk.red(`Could not forget the ledger entry for ${entry.kind} ${entry.id}: ${error?.message || error}`));
 		}
 	}
+	signal?.throwIfAborted();
 	return failures;
 }
 //#endregion
@@ -1423,11 +1447,14 @@ const CAPPED_LOGS = [
 	"device.ndjson"
 ];
 const TRIM_ABOVE_BYTES = 2 * LOG_ROTATE_BYTES;
-function fileSize(path) {
+async function fileSize(path, signal) {
+	signal?.throwIfAborted();
 	try {
-		const stat = statSync$1(path);
-		return stat.isFile() ? stat.size : 0;
+		const metadata = await stat(path);
+		signal?.throwIfAborted();
+		return metadata.isFile() ? metadata.size : 0;
 	} catch {
+		signal?.throwIfAborted();
 		return 0;
 	}
 }
@@ -1446,29 +1473,36 @@ function cappedFiles(logsDir) {
 function trimmable(size) {
 	return size > TRIM_ABOVE_BYTES ? size - LOG_ROTATE_BYTES : 0;
 }
-function excess(logsDir) {
-	return cappedFiles(logsDir).reduce((sum, { file }) => sum + trimmable(fileSize(file)), 0);
+async function excess(logsDir, signal) {
+	let bytes = 0;
+	for (const { file } of cappedFiles(logsDir)) bytes += trimmable(await fileSize(file, signal));
+	return bytes;
 }
 function collectorReason(root) {
 	const platforms = Object.keys(readCollectors(root));
 	return platforms.length ? `a device log collector is recorded for ${platforms.join(", ")}` : null;
 }
-function collectWorkspaceLogs({ exclude = [] } = {}) {
+async function collectWorkspaceLogs({ exclude = [], operation } = {}) {
+	const signal = operation?.signal;
+	signal?.throwIfAborted();
 	const mountedVolumes = listMountedVolumes();
 	const entries = [];
 	for (const { dir, projectRoot, problem } of listWorkspaceDirs()) {
+		signal?.throwIfAborted();
 		if (exclude.includes(dir)) continue;
 		if (projectRoot !== null && !isOnMountedVolume(projectRoot, mountedVolumes)) continue;
 		const logsDir = join$1(dir, "logs");
 		let names;
 		try {
-			names = readdirSync$1(logsDir);
+			names = await readdir(logsDir);
 		} catch {
+			signal?.throwIfAborted();
 			continue;
 		}
-		const bytes = names.reduce((sum, name) => sum + fileSize(join$1(logsDir, name)), 0);
+		let bytes = 0;
+		for (const name of names) bytes += await fileSize(join$1(logsDir, name), signal);
 		if (bytes === 0) continue;
-		const trimBytes = excess(logsDir);
+		const trimBytes = await excess(logsDir, signal);
 		let keptCode = null;
 		let keptReason = null;
 		if (trimBytes > 0) {
@@ -1476,7 +1510,7 @@ function collectWorkspaceLogs({ exclude = [] } = {}) {
 				keptCode = "unresolved";
 				keptReason = `workspace directory not resolved: ${problem ?? "unknown project root"}`;
 			} else {
-				const inUse = workspaceInUse(projectRoot);
+				const inUse = await workspaceInUseAsync(projectRoot, {}, signal, operation);
 				const collector = collectorReason(projectRoot);
 				if (inUse.length) {
 					keptCode = "in-use";
@@ -1497,333 +1531,92 @@ function collectWorkspaceLogs({ exclude = [] } = {}) {
 			keptReason
 		});
 	}
+	signal?.throwIfAborted();
 	return entries;
 }
-function trimToNewest({ file, log }, maxBytes) {
-	if (!trimmable(fileSize(file))) return 0;
-	return withDirLock$1(`${log}.lock`, () => {
-		const { size, atime, mtime } = statSync$1(file);
+async function trimToNewest({ file, log }, maxBytes, signal) {
+	if (!trimmable(await fileSize(file, signal))) return 0;
+	return withDirLockTransaction(`${log}.lock`, async () => {
+		signal?.throwIfAborted();
+		const { size, atime, mtime } = await stat(file);
+		signal?.throwIfAborted();
 		if (!trimmable(size)) return 0;
 		const tail = Buffer.alloc(maxBytes);
-		const fd = openSync$1(file, "r");
+		const fd = await open(file, "r");
 		try {
-			readSync$1(fd, tail, 0, maxBytes, size - maxBytes);
+			signal?.throwIfAborted();
+			await fd.read(tail, 0, maxBytes, size - maxBytes);
 		} finally {
-			closeSync$1(fd);
+			await fd.close();
 		}
+		signal?.throwIfAborted();
 		const newline = tail.indexOf(10);
 		const kept = newline === -1 ? Buffer.alloc(0) : tail.subarray(newline + 1);
 		const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
 		try {
-			writeFileSync$1(tmp, kept);
-			utimesSync$1(tmp, atime, mtime);
-			renameSync$1(tmp, file);
-		} catch (error) {
-			rmSync$1(tmp, { force: true });
-			throw error;
+			await writeFile(tmp, kept, { signal });
+			await utimes(tmp, atime, mtime);
+			signal?.throwIfAborted();
+			await rename(tmp, file);
+		} finally {
+			await rm(tmp, { force: true });
 		}
 		return size - kept.length;
-	});
+	}, { signal });
 }
-async function trimWorkspaceLogs(entries) {
+async function trimWorkspaceLogs(entries, output = GC_OUTPUT, operation) {
+	const signal = operation?.signal;
+	signal?.throwIfAborted();
 	let failures = 0;
 	let trimmed = 0;
 	for (const entry of entries) {
+		signal?.throwIfAborted();
 		const root = entry.projectRoot;
 		if (!entry.willTrim || root === null) {
-			if (entry.keptReason) console.log(chalk.dim(`Kept the logs of ${root ?? entry.dir}: ${entry.keptReason}`));
+			if (entry.keptReason) output.log(chalk.dim(`Kept the logs of ${root ?? entry.dir}: ${entry.keptReason}`));
 			continue;
 		}
 		let run;
 		try {
-			run = await withIdleWorkspace(root, () => {
+			run = await withIdleWorkspace(root, async () => {
 				const collector = collectorReason(root);
 				if (collector) return {
 					kept: collector,
 					bytes: 0
 				};
+				let bytes = 0;
+				for (const capped of cappedFiles(join$1(entry.dir, "logs"))) {
+					signal?.throwIfAborted();
+					bytes += await trimToNewest(capped, LOG_ROTATE_BYTES, signal);
+				}
 				return {
 					kept: null,
-					bytes: cappedFiles(join$1(entry.dir, "logs")).reduce((sum, capped) => sum + trimToNewest(capped, LOG_ROTATE_BYTES), 0)
+					bytes
 				};
-			}, { purpose: "gc" });
+			}, {
+				purpose: "gc",
+				operation
+			});
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			signal?.throwIfAborted();
 			failures++;
-			console.log(chalk.red(`Could not trim the logs of ${root}: ${error?.message || String(error)}`));
+			output.log(chalk.red(`Could not trim the logs of ${root}: ${error?.message || String(error)}`));
 			continue;
 		}
 		if (!run.ran || run.value.kept) {
 			const kept = run.ran ? run.value.kept : `in use: ${run.reasons.join("; ")}`;
-			console.log(chalk.yellow(`Kept the logs of ${root}: ${kept}`));
+			output.log(chalk.yellow(`Kept the logs of ${root}: ${kept}`));
 			continue;
 		}
 		trimmed += run.value.bytes;
-		console.log(chalk.green(`Trimmed the logs of ${root} (${formatBytes(run.value.bytes)})`));
+		output.log(chalk.green(`Trimmed the logs of ${root} (${formatBytes(run.value.bytes)})`));
 	}
-	if (trimmed) console.log(chalk.dim(`Trimmed ${formatBytes(trimmed)} of workspace logs.`));
+	signal?.throwIfAborted();
+	if (trimmed) output.log(chalk.dim(`Trimmed ${formatBytes(trimmed)} of workspace logs.`));
 	return failures;
 }
 //#endregion
-//#region src/commands/gc/inventory.ts
-const IOS_SIMULATOR_PLATFORM = "com.apple.platform.iphonesimulator";
-function text(value) {
-	return typeof value === "string" && value.length > 0 ? value : null;
-}
-function parseSimRuntimeList(jsonOutput) {
-	const parsed = JSON.parse(jsonOutput);
-	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Expected simctl runtime list to return a JSON object.");
-	const runtimes = [];
-	for (const [key, value] of Object.entries(parsed)) {
-		if (!isJsonObject(value)) continue;
-		const entry = value;
-		if (entry.platformIdentifier !== IOS_SIMULATOR_PLATFORM) continue;
-		runtimes.push({
-			identifier: text(entry.identifier) ?? key,
-			runtimeIdentifier: text(entry.runtimeIdentifier),
-			version: text(entry.version),
-			build: text(entry.build),
-			sizeBytes: typeof entry.sizeBytes === "number" && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null,
-			deletable: entry.deletable === true,
-			lastUsedAt: text(entry.lastUsedAt)
-		});
-	}
-	return runtimes;
-}
-function unlistedRuntimes(jsonOutput, images) {
-	const known = new Set(images.map((image) => image.runtimeIdentifier));
-	const parsed = JSON.parse(jsonOutput);
-	if (!Array.isArray(parsed.runtimes)) throw new Error("Expected simctl list runtimes to return a runtimes array.");
-	return parsed.runtimes.flatMap((value) => {
-		if (value === null || typeof value !== "object") return [];
-		const entry = value;
-		const identifier = text(entry.identifier);
-		if (!identifier || !/\.iOS-/.test(identifier) || known.has(identifier)) return [];
-		return [{
-			identifier,
-			runtimeIdentifier: identifier,
-			version: text(entry.version),
-			build: text(entry.buildversion),
-			sizeBytes: null,
-			deletable: false,
-			lastUsedAt: null
-		}];
-	});
-}
-function modelName(deviceTypeIdentifier) {
-	return deviceTypeIdentifier.replace(/^com\.apple\.CoreSimulator\.SimDeviceType\./, "").replaceAll("-", " ");
-}
-function sdkmanagerCommand(pkg) {
-	const tool = androidToolPath("sdkmanager");
-	return `${tool === "sdkmanager" ? tool : JSON.stringify(tool)} --uninstall ${JSON.stringify(pkg)}`;
-}
-function buildInventory({ sims, avds, runtimes, systemImages, config, deadProjects = [] }) {
-	const dead = new Set(deadProjects);
-	const assigned = /* @__PURE__ */ new Map();
-	for (const [project, record] of Object.entries(config?.projects ?? {})) {
-		if (dead.has(project)) continue;
-		let slots;
-		try {
-			slots = projectDeviceSlots(record);
-		} catch {
-			continue;
-		}
-		for (const { slot, platforms } of slots) {
-			if (platforms.ios?.deviceUdid) assigned.set(`ios:${platforms.ios.deviceUdid}`, {
-				project,
-				slot
-			});
-			if (platforms.android?.avdName) assigned.set(`android:${platforms.android.avdName}`, {
-				project,
-				slot
-			});
-		}
-	}
-	const parked = /* @__PURE__ */ new Set([...readParked("ios", { config }).map((sim) => `ios:${sim.udid}`), ...readParked("android", { config }).map((avd) => `android:${avd.name}`)]);
-	const owner = (key, name, created) => {
-		const workspace = assigned.get(key);
-		if (workspace && created()) return {
-			owner: "workspace",
-			project: workspace.project,
-			slot: workspace.slot
-		};
-		if (parked.has(key)) return {
-			owner: "parked",
-			project: null,
-			slot: null
-		};
-		if (!name.startsWith("stim-")) return {
-			owner: "user",
-			project: null,
-			slot: null
-		};
-		return {
-			owner: created() ? "orphaned" : "otherStimHome",
-			project: null,
-			slot: null
-		};
-	};
-	const devices = [...sims.map((sim) => ({
-		kind: "ios",
-		id: sim.udid,
-		name: sim.name,
-		model: modelName(sim.deviceTypeIdentifier),
-		runtime: sim.runtime,
-		state: sim.state,
-		lastUsedAt: sim.lastUsedAt ?? null,
-		bytes: sim.dataPathSize ?? null,
-		directory: sim.dataPath ? sim.dataPath.replace(/\/data\/?$/, "") : null,
-		...owner(`ios:${sim.udid}`, sim.name, () => isStimOwnedSim({
-			udid: sim.udid,
-			name: sim.name
-		}))
-	})), ...avds.map((avd) => ({
-		kind: "android",
-		id: avd.name,
-		name: avd.name,
-		model: avd.deviceProfile,
-		runtime: avd.systemImage,
-		state: null,
-		lastUsedAt: avd.lastUsedAt,
-		bytes: null,
-		directory: avd.directory,
-		...owner(`android:${avd.name}`, avd.name, () => isStimOwnedAvd(avd.name))
-	}))];
-	const simsByRuntime = /* @__PURE__ */ new Map();
-	for (const sim of sims) simsByRuntime.set(sim.runtime, (simsByRuntime.get(sim.runtime) ?? 0) + 1);
-	const avdsByImage = /* @__PURE__ */ new Map();
-	for (const avd of avds) if (avd.systemImage) avdsByImage.set(avd.systemImage, (avdsByImage.get(avd.systemImage) ?? 0) + 1);
-	return {
-		devices,
-		runtimes: runtimes.map((runtime) => ({
-			identifier: runtime.identifier,
-			runtimeIdentifier: runtime.runtimeIdentifier,
-			version: runtime.version,
-			build: runtime.build,
-			bytes: runtime.sizeBytes,
-			lastUsedAt: runtime.lastUsedAt,
-			deviceCount: runtime.runtimeIdentifier ? simsByRuntime.get(runtime.runtimeIdentifier) ?? 0 : 0,
-			command: runtime.deletable ? `xcrun simctl runtime delete ${runtime.identifier}` : null
-		})),
-		systemImages: systemImages.map((image) => ({
-			package: image.pkg,
-			directory: image.directory,
-			avdCount: avdsByImage.get(image.pkg) ?? 0,
-			command: sdkmanagerCommand(image.pkg)
-		}))
-	};
-}
-function modifiedAt(path) {
-	try {
-		return statSync(path).mtime.toISOString();
-	} catch {
-		return null;
-	}
-}
-function isMissing(error) {
-	const code = error.code;
-	return code === "ENOENT" || code === "ENOTDIR";
-}
-function unreadableNotice(what, error) {
-	const notice = `${what} not listed: ${describeError(error)}`;
-	if (process.platform !== "darwin" || error.code !== "EPERM") return notice;
-	return `${notice}. macOS privacy protection blocked the read; allow ${process.env.STIM_DESKTOP_APP ? "Stim Desktop" : "the app that runs stim"} under System Settings > Privacy & Security > Files and Folders (Removable Volumes for an external disk) or Full Disk Access`;
-}
-function listAvdRecords(notices, roots = avdStorageRoots()) {
-	const records = /* @__PURE__ */ new Map();
-	for (const root of roots) {
-		let names;
-		try {
-			names = readdirSync(root);
-		} catch (error) {
-			if (!isMissing(error)) notices.push(unreadableNotice(`AVDs in ${root}`, error));
-			continue;
-		}
-		for (const entry of names) {
-			if (!entry.endsWith(".ini")) continue;
-			const name = entry.slice(0, -4);
-			if (records.has(name)) continue;
-			let ini;
-			try {
-				ini = readFileSync(join(root, entry), "utf8");
-			} catch (error) {
-				if (!isMissing(error)) notices.push(unreadableNotice(`AVD ${name}`, error));
-				continue;
-			}
-			let directory = null;
-			let config = "";
-			let unreadable = null;
-			for (const candidate of avdIniPaths(root, ini)) try {
-				config = readFileSync(join(candidate, "config.ini"), "utf8");
-				directory = candidate;
-				break;
-			} catch (error) {
-				if (!isMissing(error)) unreadable ??= error;
-			}
-			if (!directory && unreadable) notices.push(unreadableNotice(`details of AVD ${name}`, unreadable));
-			records.set(name, {
-				name,
-				directory,
-				systemImage: parseAvdSystemImage(config),
-				deviceProfile: parseAvdDeviceProfile(config),
-				lastUsedAt: directory ? modifiedAt(join(directory, "hardware-qemu.ini")) : null
-			});
-		}
-	}
-	return [...records.values()];
-}
-function simctl(args) {
-	return getExecutor().runFile("xcrun", ["simctl", ...args], {
-		timeoutMs: DEVICE_LIST_TIMEOUT_MS,
-		killSignal: "SIGKILL"
-	});
-}
-function collectInventory(config, deadProjects) {
-	const notices = [];
-	let sims = [];
-	let runtimes = [];
-	if (process.platform === "darwin") {
-		try {
-			sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
-		} catch (error) {
-			notices.push(`simulators not listed: ${describeError(error)}`);
-		}
-		try {
-			runtimes = parseSimRuntimeList(simctl([
-				"runtime",
-				"list",
-				"-j"
-			]));
-		} catch (error) {
-			notices.push(`simulator runtime images not listed: ${describeError(error)}`);
-		}
-		try {
-			runtimes.push(...unlistedRuntimes(simctl([
-				"list",
-				"runtimes",
-				"-j"
-			]), runtimes));
-		} catch (error) {
-			notices.push(`simulator runtimes not listed: ${describeError(error)}`);
-		}
-	}
-	const imagesRoot = join(androidHome(), "system-images");
-	const images = listInstalledSystemImages((error) => notices.push(unreadableNotice("Android system images", error))).map((image) => ({
-		pkg: image.pkg,
-		directory: join(imagesRoot, `android-${image.api}`, image.tag, image.arch)
-	}));
-	return {
-		...buildInventory({
-			sims,
-			avds: listAvdRecords(notices),
-			runtimes,
-			systemImages: images,
-			config,
-			deadProjects
-		}),
-		notices
-	};
-}
-//#endregion
 //#region src/commands/gc/hosted-devices.ts
 function collectParkedHostedDevices({ olderThanDays = null, now = Date.now() } = {}) {
 	const notices = [];
@@ -1872,15 +1665,17 @@ function collectParkedHostedDevices({ olderThanDays = null, now = Date.now() } =
 		notices
 	};
 }
-async function stopHostedDevice(record, claim) {
+async function stopHostedDevice(record, claim, operation) {
+	operation?.signal.throwIfAborted();
 	const home = join(deviceHostArea(record.id), "home");
 	(0, ownership_claim_exports.markClaimChildPending)(claim);
+	if (operation) declareSpawnsOn(operation, claim);
 	let child;
 	try {
 		child = getExecutor().spawn(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), "device-host-worker.mjs")], {
 			cwd: home,
 			env: {
-				...process.env,
+				...operation?.env ?? process.env,
 				STIM_HOME: home
 			},
 			detached: true,
@@ -1897,6 +1692,8 @@ async function stopHostedDevice(record, claim) {
 			value: null,
 			notice: describeError(error)
 		};
+	} finally {
+		if (operation) stopDeclaringSpawnsOn(operation, claim);
 	}
 	let identity = null;
 	let closed = false;
@@ -1917,6 +1714,7 @@ async function stopHostedDevice(record, claim) {
 			clearTimeout(killTimer);
 			clearTimeout(finishTimer);
 			clearTimeout(groupTimer);
+			operation?.signal.removeEventListener("abort", cancel);
 			const settled = closed && (!child.pid || !(0, ownership_claim_exports.processGroupAlive)(child.pid));
 			if (settled) (0, ownership_claim_exports.clearClaimChild)(claim);
 			let value = null;
@@ -1941,12 +1739,12 @@ async function stopHostedDevice(record, claim) {
 			if (child.pid && identity && ["same", "gone"].includes((0, process_identity_exports.inspectProcessIdentity)(identity))) try {
 				process.kill(-child.pid, name);
 			} catch {}
-			else if (!identity) child.kill(name);
+			else if (!identity) child.stdin?.destroy();
 		};
 		const cancel = () => {
 			if (finished || cancelling) return;
 			cancelling = true;
-			notice ??= "Hosted worker exceeded its deadline.";
+			notice ??= operation?.signal.aborted ? "Hosted cleanup cancelled." : "Hosted worker exceeded its deadline.";
 			signal("SIGTERM");
 			killTimer = setTimeout(() => signal("SIGKILL"), 5e3);
 			finishTimer = setTimeout(finish, 1e4);
@@ -1960,6 +1758,7 @@ async function stopHostedDevice(record, claim) {
 			}
 		};
 		timer = setTimeout(cancel, 9e4);
+		operation?.signal.addEventListener("abort", cancel, { once: true });
 		child.stdout?.on("data", (chunk) => {
 			if (Buffer.byteLength(output) + chunk.length > 16384) {
 				notice = "Hosted worker output exceeded its bound.";
@@ -1992,6 +1791,10 @@ async function stopHostedDevice(record, claim) {
 		};
 		try {
 			(0, ownership_claim_exports.setClaimChild)(claim, identity);
+			if (operation?.signal.aborted) {
+				cancel();
+				return;
+			}
 			child.stdin?.end(JSON.stringify({
 				mode: "stop",
 				platform: record.platform,
@@ -2008,14 +1811,15 @@ async function stopHostedDevice(record, claim) {
 		}
 	});
 }
-async function deleteParkedHostedDevices(devices, { listAvds: list = listAvds } = {}) {
+async function deleteParkedHostedDevices(devices, { listAvds: list, operation } = {}, output = GC_OUTPUT) {
 	let failures = 0;
 	for (const device of devices) {
+		operation?.signal.throwIfAborted();
 		if (device.listed === false) continue;
 		const label = `${device.platform} ${device.name ?? device.session} (hosted session ${device.session})`;
 		const kept = (detail) => {
-			console.log(`Kept ${label}: ${detail}`);
-			recordGcResult("parkedHostedDevice", "kept", label, {
+			output.log(`Kept ${label}: ${detail}`);
+			output.record("parkedHostedDevice", "kept", label, {
 				id: device.id,
 				detail
 			});
@@ -2057,22 +1861,42 @@ async function deleteParkedHostedDevices(devices, { listAvds: list = listAvds }
 				kept(describeError(error));
 				continue;
 			}
-			if (device.platform === "android" && !list().includes(device.id)) {
-				kept("AVD not visible from this shell's Android environment; run gc with the server's ANDROID_AVD_HOME/HOME");
-				continue;
+			if (device.platform === "android") {
+				let avds;
+				if (operation) declareSpawnsOn(operation, claim);
+				try {
+					avds = await (list ? list() : listAvdsAsync({
+						operation,
+						signal: operation?.signal
+					}));
+				} finally {
+					if (operation) stopDeclaringSpawnsOn(operation, claim);
+				}
+				if (!avds.includes(device.id)) {
+					kept("AVD not visible from this shell's Android environment; run gc with the server's ANDROID_AVD_HOME/HOME");
+					continue;
+				}
 			}
+			operation?.signal.throwIfAborted();
 			settled = false;
-			const outcome = await stopHostedDevice(current, claim);
+			const outcome = await stopHostedDevice(current, claim, operation);
 			settled = outcome.settled;
+			if (!settled) throw new WorkspaceProcessCleanupError([claim], outcome.notice ?? "Hosted cleanup could not be verified.", "Verify the hosted worker and its descendants have stopped.");
+			operation?.signal.throwIfAborted();
 			const result = isJsonObject(outcome.value) ? outcome.value : null;
 			const stopped = result && parseHostedPlatformDevice(result.device, device.platform);
-			if (!settled || outcome.notice || result?.state !== "stopped" || !stopped || hostedDeviceId(stopped) !== device.id) throw new Error(outcome.notice ?? (typeof result?.notice === "string" ? result.notice : "Hosted deletion could not be verified."));
-			console.log(`Deleted ${label}`);
-			recordGcResult("parkedHostedDevice", "done", label, { id: device.id });
+			if (outcome.notice || result?.state !== "stopped" || !stopped || hostedDeviceId(stopped) !== device.id) throw new Error(outcome.notice ?? (typeof result?.notice === "string" ? result.notice : "Hosted deletion could not be verified."));
+			output.log(`Deleted ${label}`);
+			output.record("parkedHostedDevice", "done", label, { id: device.id });
 		} catch (error) {
+			if (claim && (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error)) {
+				settled = false;
+				throw Object.assign(new WorkspaceProcessCleanupError([.../* @__PURE__ */ new Set([claim, ...error instanceof WorkspaceProcessCleanupError ? error.claims : []])], error.message, "Verify the hosted device operation and its descendants have stopped."), { reportCleanup: true });
+			}
+			operation?.signal.throwIfAborted();
 			const detail = describeError(error);
-			console.error(`Failed to delete ${label}: ${detail}`);
-			recordGcResult("parkedHostedDevice", "failed", label, {
+			output.error(`Failed to delete ${label}: ${detail}`);
+			output.record("parkedHostedDevice", "failed", label, {
 				id: device.id,
 				detail
 			});
@@ -2085,15 +1909,27 @@ async function deleteParkedHostedDevices(devices, { listAvds: list = listAvds }
 }
 //#endregion
 //#region src/commands/gc.ts
-function removeInvalidProjectEntries(invalidProjects) {
+function readGcReport(options = {}, deps = {}) {
+	return sweep({
+		olderThan: options.olderThan,
+		cache: options.cache,
+		worktrees: options.worktrees,
+		json: true
+	}, deps, {
+		output: GC_OUTPUT,
+		takeResults: () => []
+	}, true);
+}
+function removeInvalidProjectEntries(invalidProjects, output, signal) {
 	for (const path of invalidProjects) {
+		signal?.throwIfAborted();
 		removeProject(path);
-		console.log(chalk.green(`Removed the invalid registry entry ${path}`));
-		recordGcResult("project", "done", path);
+		output.log(chalk.green(`Removed the invalid registry entry ${path}`));
+		output.record("project", "done", path);
 	}
 }
-function collectGcMemory(scope) {
-	return memorySweepIsScoped() ? Promise.resolve(scopedMemoryReport()) : collectMemoryReport(scope, true);
+function collectGcMemory(scope, env, operation) {
+	return memorySweepIsScoped(env) ? Promise.resolve(scopedMemoryReport()) : collectMemoryReport(scope, true, operation);
 }
 function classifyProjectEntries(cfg, mountedVolumes) {
 	const deadProjects = [];
@@ -2125,23 +1961,28 @@ function classifyProjectEntries(cfg, mountedVolumes) {
 	};
 }
 /** The workspace directories an unscoped run removes whole: those of dead projects and orphaned directories. */
-function removedWholeWorkspaceDirs() {
+async function removedWholeWorkspaceDirs(operation) {
 	const mountedVolumes = listMountedVolumes();
 	const cfg = loadConfig$1();
 	const { deadProjects } = classifyProjectEntries(cfg, mountedVolumes);
-	const { orphaned } = collectOrphanedWorkspaces(Object.keys(cfg?.projects ?? {}), mountedVolumes, { measure: false });
+	const { orphaned } = await collectOrphanedWorkspaces(Object.keys(cfg?.projects ?? {}), mountedVolumes, {
+		measure: false,
+		operation
+	});
 	return [...orphaned.map((entry) => entry.dir), ...deadProjects.map(workspaceDir)];
 }
-async function collectGcReport({ olderThan = null, cache = null, worktrees = false, now = Date.now(), lastTouched = workspaceLastUsed } = {}, deps = {}) {
+async function collectGcReport({ olderThan = null, cache = null, worktrees = false, refresh = true, now = Date.now(), lastTouched = workspaceLastUsed } = {}, deps = {}) {
+	const operation = deps.operation;
+	const env = operation?.env ?? process.env;
 	const scope = typeof cache === "string" && cache.trim() ? cache : null;
 	const all = scope !== null && olderThan === null;
 	const withWorkspaces = includesWorkspaceOutputs(scope);
-	const selected = selectCaches(discoverCaches(), scope).filter((c) => !withWorkspaces || !isInsideWorkspaces(c.dir));
-	if (selected.length) phase("caches", `measuring ${plural(selected.length, "shared cache")}`);
-	const sized = sizeCaches(selected);
-	const caches = scope === null ? previewScopedEmptying(sized) : planCacheEmptying(sized, all);
+	const selected = selectCaches(discoverCaches(env, operation?.cwd), scope).filter((c) => !withWorkspaces || !isInsideWorkspaces(c.dir));
+	if (selected.length) phase("caches", `measuring ${plural(selected.length, "shared cache")}`, operation);
+	const sized = await sizeCaches(selected, operation);
+	const caches = scope === null ? previewScopedEmptying(sized, env) : planCacheEmptying(sized, all, env);
 	if (scope) return {
-		archives: includesArchives(scope) ? collectArchives(scope, olderThan, now) : void 0,
+		archives: includesArchives(scope) ? await collectArchives(scope, olderThan, now, operation?.signal) : void 0,
 		skipped: [],
 		deadProjects: [],
 		invalidProjects: [],
@@ -2149,6 +1990,8 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		orphanedDevices: [],
 		unverifiedDevices: [],
 		staleDevices: [],
+		finishedDevices: [],
+		ownedDeviceDisk: [],
 		staleDeviceRecords: [],
 		staleLedgerEntries: [],
 		staleEasLedgerEntries: [],
@@ -2175,45 +2018,65 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			notices: [],
 			deletionSafe: true
 		},
-		parkedSims: includesParkedDevices(scope) ? collectParkedSims(deps, {
+		parkedSims: includesParkedDevices(scope) ? await collectParkedSims(deps, {
 			olderThanDays: olderThan,
 			now
 		}) : [],
-		parkedAvds: includesParkedDevices(scope) ? collectParkedAvds(deps, {
+		parkedAvds: includesParkedDevices(scope) ? await collectParkedAvds(deps, {
 			olderThanDays: olderThan,
 			now
 		}) : [],
 		parkedHostedDevices: [],
 		caches,
-		workspaceOutputs: withWorkspaces ? collectWorkspaceOutputs({
+		workspaceOutputs: withWorkspaces ? await collectWorkspaceOutputs({
 			olderThan,
 			now,
-			exclude: isWorkspacesScope(scope) ? removedWholeWorkspaceDirs() : []
+			exclude: isWorkspacesScope(scope) ? await removedWholeWorkspaceDirs(operation) : [],
+			signal: operation?.signal,
+			operation
 		}) : null,
 		workspaceLogs: [],
-		recordings: includesRecordings(scope) ? collectRecordings({
+		recordings: includesRecordings(scope) ? await collectRecordings({
 			whole: all,
 			olderThan,
 			now
-		}) : [],
+		}, [], operation?.signal) : [],
 		worktreeSweep: null,
-		memory: memoryCacheKind(scope) ? await collectGcMemory(memoryScope(scope)) : null,
+		memory: memoryCacheKind(scope) ? await collectGcMemory(memoryScope(scope), env, operation) : null,
 		agentDeviceUsage: null,
 		swiftpmCacheUsage: null,
+		machineCaches: null,
+		tempLeftovers: null,
+		gradleVersions: includesGradleVersions(scope) ? await collectGradleVersions({
+			olderThanDays: olderThan,
+			now,
+			operation
+		}) : null,
 		cacheScope: scope,
 		olderThan,
 		all
 	};
-	phase("agent-device", "measuring report-only state");
-	const agentDeviceUsage = await getAgentDeviceUsage();
-	phase("SwiftPM cache", "measuring report-only state");
-	const swiftpmCacheUsage = await getSwiftpmCacheUsage();
+	phase("agent-device", "measuring report-only state", operation);
+	const agentDeviceUsage = await getAgentDeviceUsage({ operation });
+	phase("SwiftPM cache", "measuring report-only state", operation);
+	const swiftpmCacheUsage = await getSwiftpmCacheUsage({ operation });
+	phase("machine caches", "measuring report-only state", operation);
+	const machineCaches = await getMachineCacheReport(agentDeviceUsage, { operation });
+	if (!deviceSweepIsScoped(env)) phase("TMPDIR", "checking recognized leftovers", operation);
+	const tempLeftovers = await collectTempLeftovers({
+		now,
+		env,
+		signal: operation?.signal,
+		operation
+	});
 	const mountedVolumes = listMountedVolumes();
 	const cfg = loadConfig$1();
 	let easSessionSweep = deps.precollectedEasSessionSweep;
 	if (!easSessionSweep) try {
-		easSessionSweep = collectEasSessionSweep(cfg, deps);
+		easSessionSweep = await collectEasSessionSweep(cfg, deps);
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
 		easSessionSweep = {
 			projectScope: null,
 			orphaned: [],
@@ -2221,16 +2084,16 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			deletionSafe: false
 		};
 	}
-	const parkedSims = collectParkedSims(deps, {
+	const parkedSims = await collectParkedSims(deps, {
 		olderThanDays: olderThan,
 		now
 	});
-	const parkedAvds = collectParkedAvds(deps, {
+	const parkedAvds = await collectParkedAvds(deps, {
 		olderThanDays: olderThan,
 		now
 	});
 	const { deadProjects, invalidProjects, skipped } = classifyProjectEntries(cfg, mountedVolumes);
-	const workspaceDirs = collectOrphanedWorkspaces(Object.keys(cfg?.projects ?? {}), mountedVolumes);
+	const workspaceDirs = await collectOrphanedWorkspaces(Object.keys(cfg?.projects ?? {}), mountedVolumes, { operation });
 	skipped.push(...workspaceDirs.skipped);
 	const statusCaches = collectStaleStatusCaches(mountedVolumes);
 	skipped.push(...statusCaches.skipped);
@@ -2245,38 +2108,74 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	let staleDeviceRecords = [];
 	let staleLedgerEntries = staleBrowserProfiles(readCreatedDevices$1());
 	let idleDevices = [];
-	const unsweepableReason = cfg === null ? "no Stim config found" : deviceSweepIsScoped() ? "STIM_HOME scopes this config, but simulators and AVDs are machine-global" : null;
-	phase("devices", "listing simulators and emulators");
+	let listed = null;
+	let deviceDisk = [];
+	const avdSizes = /* @__PURE__ */ new Map();
+	const avdSize = (dir, options) => {
+		let bytes = avdSizes.get(dir);
+		if (bytes === void 0) avdSizes.set(dir, bytes = Promise.resolve((deps.directorySize ?? directorySizeAsync)(dir, {
+			...options,
+			operation,
+			signal: operation?.signal
+		})));
+		return bytes;
+	};
+	const unsweepableReason = cfg === null ? "no Stim config found" : deviceSweepIsScoped(env) ? "STIM_HOME scopes this config, but simulators and AVDs are machine-global" : null;
+	phase("devices", "listing simulators and emulators", operation);
 	if (unsweepableReason) {
 		let simNames = [];
 		let avdNames = [];
 		try {
-			simNames = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }).map((s) => s.name);
-		} catch {}
+			simNames = (await listAllIosSimsAsync({
+				timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+				operation,
+				signal: operation?.signal
+			})).map((s) => s.name);
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
+		}
 		try {
-			avdNames = listAvds({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
-		} catch {}
+			avdNames = await listAvdsAsync({
+				timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+				operation,
+				signal: operation?.signal
+			});
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
+		}
 		deviceSweepNotices.push(...describeUnverifiableDevices(simNames, avdNames, { reason: unsweepableReason }));
 	} else {
 		let sims = [];
 		let simsChecked = true;
 		const ledger = readCreatedDevices$1();
 		try {
-			const allSims = listAllIosSims({
+			const allSims = await listAllIosSimsAsync({
 				timeoutMs: DEVICE_LIST_TIMEOUT_MS,
-				includeUnavailable: true
+				includeUnavailable: true,
+				operation,
+				signal: operation?.signal
 			});
 			staleLedgerEntries = [...staleLedgerEntries, ...findStaleLedgerEntries(ledger, allSims)];
 			sims = allSims.filter((sim) => sim.available);
-		} catch {
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
 			simsChecked = false;
 			deviceSweepNotices.push(`ios device sweep skipped: simulator tooling did not answer within ${DEVICE_LIST_TIMEOUT_MS / 1e3}s`);
 		}
 		let avds = [];
 		let avdsChecked = true;
 		try {
-			avds = listAvds({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
-		} catch {
+			avds = await listAvdsAsync({
+				timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+				operation,
+				signal: operation?.signal
+			});
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
 			avdsChecked = false;
 			deviceSweepNotices.push(`android device sweep skipped: emulator tooling did not answer within ${DEVICE_LIST_TIMEOUT_MS / 1e3}s`);
 		}
@@ -2302,14 +2201,31 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			const directories = device.kind === "android" && !registeredAvds.has(device.id) ? orphanedAvdDirectories.filter((entry) => entry.name === device.id) : [];
 			return directories.length ? directories.map(({ directory }) => Object.assign({}, device, { directory })) : [device];
 		});
-		orphanedDevices = withAndroidAvdSizes(found.orphaned.flatMap((device) => {
+		orphanedDevices = await withAndroidAvdSizes(found.orphaned.flatMap((device) => {
 			const directories = device.kind === "android" ? orphanedAvdDirectories.filter((entry) => entry.name === device.name) : [];
 			return directories.length ? directories.map((orphanedDirectory) => Object.assign({}, device, { orphanedDirectory })) : [device];
 		}), {
 			avdDirectory: deps.avdDirectory ?? ownedAvdDirectory,
-			size: deps.directorySize ?? directorySize
+			size: avdSize,
+			operation
 		});
-		idleDevices = collectIdleDevices(cfg, sims, deadProjects, now);
+		idleDevices = operation ? await collectIdleDevicesAsync(cfg, sims, deadProjects, now, env, operation.signal, operation) : collectIdleDevices(cfg, sims, deadProjects, now);
+		if (simsChecked || avdsChecked) {
+			const lists = {
+				sims,
+				avds: [...registeredAvds]
+			};
+			listed = lists;
+			let unmeasured = 0;
+			deviceDisk = ownedDeviceDisk(await ownedDeviceUsage((_target, workspace) => {
+				if (workspace) unmeasured++;
+			}, {
+				sims: () => lists.sims,
+				avds: () => lists.avds,
+				avdDirectory: deps.avdDirectory ?? ownedAvdDirectory,
+				size: async (dir) => await avdSize(dir, { timeoutMs: 5e3 }) || null
+			}), { android: unmeasured });
+		}
 		staleDeviceRecords = findStaleDeviceRecords({
 			config: cfg,
 			sims,
@@ -2318,7 +2234,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			simsChecked,
 			avdsChecked
 		});
-		if (olderThan !== null) staleDevices = withAndroidAvdSizes(findStaleProjectDevices({
+		if (olderThan !== null) staleDevices = await withAndroidAvdSizes(findStaleProjectDevices({
 			config: cfg,
 			sims,
 			avds,
@@ -2328,13 +2244,21 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			deadProjects
 		}), {
 			avdDirectory: deps.avdDirectory ?? ownedAvdDirectory,
-			size: deps.directorySize ?? directorySize
+			size: avdSize,
+			operation
 		});
 	}
 	const locks = listBuildLocks();
 	const slots = listBuildSlots();
 	const goneWorkspaceDirs = [...workspaceDirs.orphaned.map((entry) => entry.dir), ...deadProjects.map(workspaceDir)];
 	const deviceLeases = collectDeviceLeases(now);
+	const worktreeSweep = await measureWorktreeSweep(await collectWorktreeSweep({
+		idle: worktrees,
+		olderThan,
+		now,
+		refresh,
+		operation
+	}), operation);
 	return {
 		skipped,
 		deadProjects,
@@ -2370,58 +2294,79 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		deviceSweepNotices,
 		easSessionSweep,
 		caches,
-		workspaceOutputs: collectWorkspaceOutputs({
+		workspaceOutputs: await collectWorkspaceOutputs({
 			olderThan,
 			now,
-			exclude: goneWorkspaceDirs
+			exclude: goneWorkspaceDirs,
+			signal: operation?.signal,
+			operation
+		}),
+		workspaceLogs: await collectWorkspaceLogs({
+			exclude: goneWorkspaceDirs,
+			operation
 		}),
-		workspaceLogs: collectWorkspaceLogs({ exclude: goneWorkspaceDirs }),
-		recordings: collectRecordings({
+		recordings: await collectRecordings({
 			whole: false,
 			olderThan,
 			now
-		}, goneWorkspaceDirs),
-		worktreeSweep: await collectWorktreeSweep({
-			idle: worktrees,
-			olderThan,
+		}, goneWorkspaceDirs, operation?.signal),
+		worktreeSweep,
+		finishedDevices: listed ? collectFinishedDevices({
+			config: cfg,
+			...listed,
+			sweep: worktreeSweep,
 			now
-		}),
+		}) : [],
+		ownedDeviceDisk: deviceDisk,
 		memory: await collectGcMemory({
 			watchman: true,
 			gradle: true
-		}),
+		}, env, operation),
 		agentDeviceUsage,
 		swiftpmCacheUsage,
+		machineCaches,
+		tempLeftovers,
 		cacheScope: null,
 		olderThan,
 		all
 	};
 }
 async function runGc(opts = {}, deps = {}) {
-	if (!opts.json) {
-		await maintenanceGuardedSweep(opts, deps);
-		return;
-	}
-	const log = console.log;
-	console.log = console.error;
-	let payload;
+	let result;
 	try {
-		payload = await maintenanceGuardedSweep(opts, deps);
-	} finally {
-		console.log = log;
+		result = await withGcMaintenanceClaim(opts, (claim) => executeGc(opts, deps, (stream, line) => {
+			if (stream === "stderr" || opts.json) console.error(line);
+			else console.log(line);
+		}, claim));
+	} catch (error) {
+		const failure = (0, ownership_claim_exports.claimFailure)(error, opts.delete ? "stim gc --delete" : "stim gc --idle <duration>") ?? (deps.operation?.signal.aborted ? {
+			code: "STIM_CANCELLED",
+			message: "GC was cancelled.",
+			remedy: "Retry the same GC command."
+		} : null);
+		if (!failure) throw error;
+		console.error(`${failure.code}: ${failure.message}`);
+		console.error(failure.remedy);
+		result = {
+			payload: failure,
+			exitCode: 1
+		};
 	}
-	console.log(JSON.stringify(payload));
+	if (result.exitCode) process.exitCode = result.exitCode;
+	if (opts.json) console.log(JSON.stringify(result.payload));
 }
-async function maintenanceGuardedSweep(opts, deps) {
-	if (!opts.delete) return sweep(opts, deps);
+/** Runs GC under this home's exclusive maintenance claim, retaining it when owned cleanup is unresolved. */
+async function withGcMaintenanceClaim(opts, work) {
+	if (!opts.delete && opts.idle === void 0) return work(void 0);
 	let claim;
+	let retained = false;
 	try {
 		const root = maintenanceRunClaims();
 		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
 			root,
 			mode: "exclusive",
 			label: "maintenance",
-			details: { trigger: "gc --delete" }
+			details: { trigger: opts.delete ? "gc --delete" : "gc --idle" }
 		});
 		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
 		claim = attempt.acquired;
@@ -2434,27 +2379,58 @@ async function maintenanceGuardedSweep(opts, deps) {
 				reason: `held by pid ${holder?.owner.pid ?? "?"} since ${holder?.startedAt ?? "?"} (${String(holder?.details.trigger ?? "maintenance")})`
 			});
 		}
-		return await sweep(opts, deps);
-	} catch (error) {
-		const failure = (0, ownership_claim_exports.claimFailure)(error, "stim gc --delete");
-		if (!failure) throw error;
-		console.error(`${failure.code}: ${failure.message}`);
-		console.error(failure.remedy);
-		process.exitCode = 1;
-		return failure;
+		return await work(claim);
+	} catch (cause) {
+		if (claim && (cause instanceof WorkspaceProcessCleanupError || cause instanceof Error && "reportCleanup" in cause)) {
+			retained = true;
+			throw Object.assign(new WorkspaceProcessCleanupError([.../* @__PURE__ */ new Set([claim, ...cause instanceof WorkspaceProcessCleanupError ? cause.claims : []])], cause.message, "Verify GC and its owned children have stopped."), { reportCleanup: true });
+		}
+		throw cause;
+	} finally {
+		if (claim && !retained) (0, ownership_claim_exports.releaseClaim)(claim);
+	}
+}
+/** Executes one already-admitted sweep with separate progress, results and exit status. */
+async function executeGc(opts, deps, write, claim) {
+	const results = createGcResults();
+	let failed = false;
+	const output = {
+		log: (line) => write("stdout", line),
+		error: (line) => write("stderr", line),
+		record: results.record,
+		fail: () => {
+			failed = true;
+		}
+	};
+	try {
+		declareSpawnsOn(deps.operation, claim);
+		return {
+			payload: await sweep(opts, deps, {
+				output,
+				takeResults: results.take
+			}),
+			exitCode: failed ? 1 : 0
+		};
 	} finally {
-		if (claim) (0, ownership_claim_exports.releaseClaim)(claim);
+		stopDeclaringSpawnsOn(deps.operation, claim);
 	}
 }
-async function sweep(opts, deps) {
+async function sweep(opts, deps, execution, reportOnly = false) {
+	const { output } = execution;
+	const core = (dependencies) => runGcCore(opts, dependencies, execution, reportOnly);
 	if (opts.cache && (opts.worktrees || opts.idle !== void 0)) {
 		const flag = opts.worktrees ? "--worktrees" : "--idle";
 		const message = opts.worktrees ? "--cache acts only on the named caches, and --worktrees sweeps linked worktrees." : "--cache acts only on the named caches, and --idle shuts down idle owned devices.";
 		const remedy = `Run \`stim gc ${flag}${opts.worktrees ? "" : " <duration>"}\` and \`stim gc --cache <name>\` separately.`;
-		console.error(chalk.red(message));
-		console.error(chalk.dim(remedy));
-		console.error(chalk.red("failed: STIM_BAD_ARG"));
-		process.exitCode = 1;
+		if (reportOnly) return {
+			code: "STIM_BAD_ARG",
+			message,
+			remedy
+		};
+		output.error(chalk.red(message));
+		output.error(chalk.dim(remedy));
+		output.error(chalk.red("failed: STIM_BAD_ARG"));
+		output.fail();
 		return {
 			code: "STIM_BAD_ARG",
 			message,
@@ -2465,10 +2441,15 @@ async function sweep(opts, deps) {
 	if (memoryKind && opts.olderThan !== void 0) {
 		const message = `--older-than does not apply to --cache ${memoryKind}, which acts on running processes.`;
 		const remedy = `Run \`stim gc --cache ${memoryKind}\` without --older-than.`;
-		console.error(chalk.red(message));
-		console.error(chalk.dim(remedy));
-		console.error(chalk.red("failed: STIM_BAD_ARG"));
-		process.exitCode = 1;
+		if (reportOnly) return {
+			code: "STIM_BAD_ARG",
+			message,
+			remedy
+		};
+		output.error(chalk.red(message));
+		output.error(chalk.dim(remedy));
+		output.error(chalk.red("failed: STIM_BAD_ARG"));
+		output.fail();
 		return {
 			code: "STIM_BAD_ARG",
 			message,
@@ -2476,8 +2457,11 @@ async function sweep(opts, deps) {
 		};
 	}
 	const poolError = parkedMaxSetting("ios").error || parkedMaxSetting("android").error;
-	if (poolError) console.error(chalk.yellow(`${poolError} ${POOL_SETTING_REMEDY}`));
-	if (opts.cache) return runGcCore(opts, {
+	if (poolError) {
+		if (reportOnly) phase("note", `${poolError} ${POOL_SETTING_REMEDY}`, deps.operation);
+		else output.error(chalk.yellow(`${poolError} ${POOL_SETTING_REMEDY}`));
+	}
+	if (opts.cache) return core({
 		...deps,
 		precollectedEasSessionSweep: {
 			projectScope: null,
@@ -2488,8 +2472,8 @@ async function sweep(opts, deps) {
 	});
 	let projectRoot = null;
 	try {
-		projectRoot = (deps.findProjectRoot ?? findProjectRoot)(process.cwd());
-		if (!projectRoot) return runGcCore(opts, {
+		projectRoot = (deps.findProjectRoot ?? findProjectRoot$1)(deps.operation?.cwd ?? process.cwd());
+		if (!projectRoot) return core({
 			...deps,
 			precollectedEasSessionSweep: {
 				projectScope: null,
@@ -2498,7 +2482,7 @@ async function sweep(opts, deps) {
 				deletionSafe: false
 			}
 		});
-		if (!(deps.detectIsExpo ?? detectIsExpo)(projectRoot)) return runGcCore(opts, {
+		if (!(deps.detectIsExpo ?? detectIsExpo)(projectRoot)) return core({
 			...deps,
 			precollectedEasSessionSweep: {
 				projectScope: projectRoot,
@@ -2508,7 +2492,7 @@ async function sweep(opts, deps) {
 			}
 		});
 	} catch (error) {
-		return runGcCore(opts, {
+		return core({
 			...deps,
 			precollectedEasSessionSweep: {
 				projectScope: projectRoot,
@@ -2524,13 +2508,19 @@ async function sweep(opts, deps) {
 	try {
 		easSessionSweep = await withProjectLock(projectRoot, () => {
 			sweepStarted = true;
-			return withRemoteSessionGcLocks(projectRoot, deps, (coordinatedDeps) => Promise.resolve(collectEasSessionSweep(loadConfig$1(), coordinatedDeps)));
+			return withRemoteSessionGcLocks(projectRoot, deps, (coordinatedDeps) => collectEasSessionSweep(loadConfig$1(), coordinatedDeps));
 		}, {
 			waitMs: 0,
 			ownerPurpose: "EAS orphan sweep",
-			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();
 		easSessionSweep = {
 			projectScope: projectRoot,
 			orphaned: [],
@@ -2538,49 +2528,53 @@ async function sweep(opts, deps) {
 			deletionSafe: false
 		};
 	}
-	return runGcCore(opts, {
+	return core({
 		...deps,
 		precollectedEasSessionSweep: easSessionSweep
 	});
 }
-async function pruneDeadProjects(deadProjects) {
+async function pruneDeadProjects(deadProjects, output, operation) {
 	let deleteFailures = 0;
 	for (const path of deadProjects) {
+		operation?.signal.throwIfAborted();
 		if (existsSync$1(path) || !isOnMountedVolume(path)) {
-			console.log(chalk.yellow(`Kept ${path}: its absence can no longer be confirmed.`));
-			recordGcResult("project", "kept", path, { detail: "its absence can no longer be confirmed" });
+			output.log(chalk.yellow(`Kept ${path}: its absence can no longer be confirmed.`));
+			output.record("project", "kept", path, { detail: "its absence can no longer be confirmed" });
 			continue;
 		}
 		const result = await reclaimProject(path, {
 			archive: { removedBy: "gc" },
-			stopRequester: { by: "stim gc --delete" }
+			stopRequester: { by: "stim gc --delete" },
+			operation
 		}).catch((error) => {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
 			deleteFailures++;
-			console.log(chalk.red(`Could not prune ${path}; its registry entry was kept: ${error.message}`));
-			recordGcResult("project", "failed", path, { detail: `its registry entry was kept: ${error.message}` });
+			output.log(chalk.red(`Could not prune ${path}; its registry entry was kept: ${error.message}`));
+			output.record("project", "failed", path, { detail: `its registry entry was kept: ${error.message}` });
 			return null;
 		});
 		if (!result) continue;
 		if (result.keptEntry) {
-			console.log(chalk.yellow(`Could not fully prune ${path}; its registry entry was kept.`));
-			recordGcResult("project", "kept", path, { detail: "it could not be fully pruned; its registry entry was kept" });
+			output.log(chalk.yellow(`Could not fully prune ${path}; its registry entry was kept.`));
+			output.record("project", "kept", path, { detail: "it could not be fully pruned; its registry entry was kept" });
 		} else {
-			console.log(chalk.green(`Pruned ${path}`));
-			recordGcResult("project", "done", path);
+			output.log(chalk.green(`Pruned ${path}`));
+			output.record("project", "done", path);
 		}
-		for (const dir of result.removedWorkspaceDirs) console.log(chalk.dim(`  removed workspace output ${dir}`));
+		for (const dir of result.removedWorkspaceDirs) output.log(chalk.dim(`  removed workspace output ${dir}`));
 		for (const dir of result.failedWorkspaceDirs) {
-			console.log(chalk.red(`  could not remove workspace output ${dir}`));
-			recordGcResult("workspaceDirectory", "failed", dir, { detail: `could not remove it while pruning ${path}` });
+			output.log(chalk.red(`  could not remove workspace output ${dir}`));
+			output.record("workspaceDirectory", "failed", dir, { detail: `could not remove it while pruning ${path}` });
 			deleteFailures += 1;
 		}
-		if (result.killedPid) console.log(chalk.dim(`  killed orphaned Metro pid ${result.killedPid}`));
-		if (result.stoppedSession) console.log(chalk.dim(`  stopped remote session ${result.stoppedSession}`));
-		if (result.stoppedTunnel) console.log(chalk.dim(`  stopped ${result.stoppedTunnel} tunnel`));
-		for (const name of result.deletedDevices) recordGcResult("device", "done", name);
+		if (result.killedPid) output.log(chalk.dim(`  killed orphaned Metro pid ${result.killedPid}`));
+		if (result.stoppedSession) output.log(chalk.dim(`  stopped remote session ${result.stoppedSession}`));
+		if (result.stoppedTunnel) output.log(chalk.dim(`  stopped ${result.stoppedTunnel} tunnel`));
+		for (const name of result.deletedDevices) output.record("device", "done", name);
 		for (const s of result.skippedDevices) {
-			console.log(chalk.yellow(`  ${s.name}: ${s.reason}`));
-			recordGcResult("device", result.failedDevices.includes(s) ? "failed" : "kept", s.name, {
+			output.log(chalk.yellow(`  ${s.name}: ${s.reason}`));
+			output.record("device", result.failedDevices.includes(s) ? "failed" : "kept", s.name, {
 				id: s.udid ?? null,
 				detail: s.reason
 			});
@@ -2589,13 +2583,18 @@ async function pruneDeadProjects(deadProjects) {
 	}
 	return deleteFailures;
 }
-async function attachMaintenancePreview(report, deleting, cache) {
-	if (!deleting) report.maintenance = await previewMaintenance({ devices: !cache });
+async function attachMaintenancePreview(report, deleting, cache, refresh, operation) {
+	if (!deleting) report.maintenance = await previewMaintenance({
+		devices: !cache,
+		refresh,
+		operation
+	});
 }
 function scopedDryRunAction(cache) {
 	const memory = memoryCacheKind(cache);
 	if (memory === "watchman") return "remove the stale roots and shut down the unused watchman";
 	if (memory === "gradle-daemons") return "stop the idle daemons";
+	if (includesGradleVersions(cache)) return "delete the Gradle versions marked deletable";
 	return includesParkedDevices(cache) ? "erase the parked devices" : "empty the caches";
 }
 function dryRunHint(cache, all, actionable, caches) {
@@ -2604,45 +2603,72 @@ function dryRunHint(cache, all, actionable, caches) {
 	if (caches) return "Pass --delete --cache all to empty the caches above, or --delete --older-than <days> to trim them.";
 	return null;
 }
-function pruneStatusCaches(report) {
+function scopedWorkPending(cache, report) {
+	return memoryWorkPending(cache, report.memory) || gradleVersionsPending(report.gradleVersions);
+}
+async function pruneStatusCaches(report, output, signal) {
 	if (report.cacheScope !== null) return 0;
-	return deleteStaleStatusCaches(collectStaleStatusCaches(listMountedVolumes()).stale);
+	return deleteStaleStatusCaches(collectStaleStatusCaches(listMountedVolumes()).stale, output, signal);
+}
+async function reclaimParkedDevices(report, deps, output) {
+	return report.cacheScope ? await eraseParkedDevices(report.parkedSims, report.parkedAvds, output, deps.operation) : await deleteParkedSims(report.parkedSims, deps, output) + await deleteParkedAvds(report.parkedAvds, output, deps.operation);
 }
-function reclaimParkedDevices(report, deps) {
-	return report.cacheScope ? eraseParkedDevices(report.parkedSims, report.parkedAvds) : deleteParkedSims(report.parkedSims, deps) + deleteParkedAvds(report.parkedAvds);
+function reportActionable(report) {
+	const { deadProjects, invalidProjects, orphanedDevices, staleDevices, staleDeviceRecords, buildLocks, buildSlots, deviceLeases, easSessionSweep, caches, olderThan, all, cacheScope: cache } = report;
+	return archiveWorkPending(report.archives, deadProjects.length + invalidProjects.length > 0 || report.orphanedWorkspaces.length > 0 || Boolean(report.workspaceOutputs?.workspaces.some((entry) => entry.willClear)) || report.workspaceLogs.some((entry) => entry.willTrim) || report.recordings.some((entry) => entry.willDelete && !entry.withWorkspace) || Boolean(report.tempLeftovers?.entries.some((entry) => entry.willDelete)) || Boolean(report.worktreeSweep?.worktrees.some((entry) => !entry.skipped)) || report.parkedSims.length > 0 || report.parkedAvds.length + report.parkedHostedDevices.filter((device) => device.listed !== false).length > 0 || orphanedDevices.length > 0 || staleDevices.length + report.finishedDevices.length > 0 || staleDeviceRecords.length > 0 || report.staleLedgerEntries.length + report.staleEasLedgerEntries.length > 0 || report.staleStatusCaches.length > 0 || buildLocks.stale.length > 0 || buildSlots.stale.length > 0 || deviceLeases.expired.length > 0 || easSessionSweep.orphaned.length > 0 || (olderThan !== null || all) && caches.length > 0 || scopedWorkPending(cache, report));
 }
-async function runGcCore(opts, deps) {
-	takeGcResults();
+async function runGcCore(opts, deps, execution, reportOnly = false) {
+	const { output, takeResults } = execution;
+	const signal = deps.operation?.signal;
+	throwIfCancelled(signal, "GC");
 	const olderThan = typeof opts.olderThan === "number" ? opts.olderThan : null;
 	const cache = typeof opts.cache === "string" && opts.cache.trim() ? opts.cache : null;
+	const refresh = opts.delete === true;
 	const report = await collectGcReport({
 		olderThan,
 		cache,
-		worktrees: Boolean(opts.worktrees)
+		worktrees: Boolean(opts.worktrees),
+		refresh
 	}, deps);
+	throwIfCancelled(signal, "GC");
 	if (cache && report.caches.length === 0 && report.workspaceOutputs === null && !selectsBeyondCaches(cache)) {
-		const names = [...new Set(discoverCaches().map((c) => c.name))];
+		const names = [...new Set(discoverCaches(deps.operation?.env ?? process.env, deps.operation?.cwd).map((c) => c.name))];
 		const message = `No shared cache carries "${cache}" in its name or directory.`;
-		console.log(chalk.yellow(message));
-		if (names.length) console.log(chalk.dim(`Caches on this machine: ${names.join(", ")}`));
-		if (opts.json) process.exitCode = 1;
+		if (!reportOnly) {
+			output.log(chalk.yellow(message));
+			if (names.length) output.log(chalk.dim(`Caches on this machine: ${names.join(", ")}`));
+			if (opts.json) output.fail();
+		}
 		return {
 			code: "STIM_BAD_ARG",
 			message,
 			remedy: names.length ? `Pass --cache all or a name from: ${names.join(", ")}.` : "No shared cache was found on this machine."
 		};
 	}
-	await attachMaintenancePreview(report, opts.delete === true, cache);
+	await attachMaintenancePreview(report, opts.delete === true, cache, refresh, deps.operation);
 	const refusal = archiveRefusal(report.archives);
-	if (refusal !== null) return refusal;
+	if (refusal !== null) {
+		if (!reportOnly) {
+			output.fail();
+			output.error(chalk.red(refusal.message));
+			output.error(chalk.dim(refusal.remedy));
+			output.error(chalk.red(`failed: ${refusal.code}`));
+		}
+		return refusal;
+	}
 	const all = report.all;
-	for (const line of formatGcReport(report)) console.log(line);
+	if (!reportOnly) for (const line of formatGcReport(report)) output.log(line);
 	const { deadProjects, invalidProjects, orphanedDevices, staleDevices, staleDeviceRecords, buildLocks, buildSlots, deviceLeases, easSessionSweep, caches } = report;
-	const actionable = archiveWorkPending(report.archives, deadProjects.length + invalidProjects.length > 0 || report.orphanedWorkspaces.length > 0 || Boolean(report.workspaceOutputs?.workspaces.some((entry) => entry.willClear)) || report.workspaceLogs.some((entry) => entry.willTrim) || report.recordings.some((entry) => entry.willDelete && !entry.withWorkspace) || Boolean(report.worktreeSweep?.worktrees.some((entry) => !entry.skipped)) || report.parkedSims.length > 0 || report.parkedAvds.length + report.parkedHostedDevices.filter((device) => device.listed !== false).length > 0 || orphanedDevices.length > 0 || staleDevices.length > 0 || staleDeviceRecords.length > 0 || report.staleLedgerEntries.length + report.staleEasLedgerEntries.length > 0 || report.staleStatusCaches.length > 0 || buildLocks.stale.length > 0 || buildSlots.stale.length > 0 || deviceLeases.expired.length > 0 || easSessionSweep.orphaned.length > 0 || (olderThan !== null || all) && caches.length > 0 || memoryWorkPending(cache, report.memory));
+	const actionable = reportActionable(report);
 	const idle = opts.idle ?? null;
-	const idleFailures = idle === null ? 0 : shutDownIdleDevices(report.idleDevices, idle, () => collectIdleDevices(loadConfig$1(), listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }), report.deadProjects)).failures;
-	if (idleFailures) process.exitCode = 1;
-	const inventory = opts.json && !opts.delete && idle === null && report.cacheScope === null ? collectInventory(loadConfig$1(), deadProjects) : null;
+	throwIfCancelled(signal, "GC");
+	const idleFailures = idle === null ? 0 : (await shutDownIdleDevices(report.idleDevices, idle, async () => deps.operation ? collectIdleDevicesAsync(loadConfig$1(), await listAllIosSimsAsync({
+		timeoutMs: DEVICE_LIST_TIMEOUT_MS,
+		operation: deps.operation,
+		signal
+	}), report.deadProjects, Date.now(), deps.operation.env, signal, deps.operation) : collectIdleDevices(loadConfig$1(), listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }), report.deadProjects), output, signal, deps.operation)).failures;
+	if (idleFailures) output.fail();
+	const inventory = opts.json && !opts.delete && idle === null && report.cacheScope === null ? await collectInventory(loadConfig$1(), deadProjects, deps.operation?.env ?? process.env, deps.operation) : null;
 	const payload = (failures) => ({
 		mode: opts.delete ? "delete" : "dry-run",
 		idle,
@@ -2653,42 +2679,70 @@ async function runGcCore(opts, deps) {
 		failures,
 		sections: gcReportSections(report),
 		...report.maintenance ? { maintenance: report.maintenance } : {},
-		results: takeGcResults(),
+		results: reportOnly ? [] : takeResults(),
 		inventory
 	});
 	if (!opts.delete) {
 		const hint = dryRunHint(cache, all, actionable, caches.length > 0);
-		if (hint) console.log(chalk.dim(`\n${hint}`));
+		if (hint && !reportOnly) output.log(chalk.dim(`\n${hint}`));
 		return payload(idle === null ? null : idleFailures);
 	}
 	let deleteFailures = idleFailures;
-	deleteFailures += deleteArchives(report.archives);
-	deleteFailures += report.workspaceOutputs ? (await clearWorkspaceOutputs(report.workspaceOutputs, { olderThan })).failures : 0;
-	deleteFailures += await trimWorkspaceLogs(report.workspaceLogs);
-	deleteFailures += deleteRecordings(report.recordings, {
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await deleteArchives(report.archives, output, signal);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += report.workspaceOutputs ? (await clearWorkspaceOutputs(report.workspaceOutputs, {
+		olderThan,
+		signal,
+		operation: deps.operation
+	}, output)).failures : 0;
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await trimWorkspaceLogs(report.workspaceLogs, output, deps.operation);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await deleteRecordings(report.recordings, {
 		whole: all,
 		olderThan,
 		now: Date.now()
-	});
-	deleteFailures += reclaimParkedDevices(report, deps);
-	deleteFailures += await deleteParkedHostedDevices(report.parkedHostedDevices);
-	deleteFailures += await reclaimMemory(cache, report.memory);
-	removeInvalidProjectEntries(invalidProjects);
-	deleteFailures += await pruneDeadProjects(deadProjects);
-	deleteFailures += await deleteOrphanedWorkspaces(report.orphanedWorkspaces);
-	deleteFailures += deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords);
-	deleteFailures += forgetStaleLedgerEntries(report.staleLedgerEntries);
-	deleteFailures += forgetStaleEasLedgerEntries(report.staleEasLedgerEntries, listMountedVolumes(), deps);
-	deleteFailures += pruneStatusCaches(report);
+	}, output, signal);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await reclaimParkedDevices(report, deps, output);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await deleteParkedHostedDevices(report.parkedHostedDevices, { operation: deps.operation }, output);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await reclaimMemory(cache, report.memory, output, deps.operation);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await deleteGradleVersions(report.gradleVersions, output, deps.operation);
+	throwIfCancelled(signal, "GC");
+	removeInvalidProjectEntries(invalidProjects, output, signal);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await pruneDeadProjects(deadProjects, output, deps.operation);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await deleteOrphanedWorkspaces(report.orphanedWorkspaces, output, deps.operation);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords, output, deps.operation);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await deleteFinishedDevices(report, output, deps.operation);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await forgetStaleLedgerEntries(report.staleLedgerEntries, output, signal);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await forgetStaleEasLedgerEntries(report.staleEasLedgerEntries, listMountedVolumes(), deps, output, signal);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await pruneStatusCaches(report, output, signal);
+	if (report.tempLeftovers) deleteFailures += (await deleteTempLeftovers({
+		env: deps.operation?.env ?? process.env,
+		signal: deps.operation?.signal,
+		operation: deps.operation
+	}, output)).failures;
 	for (const lock of buildLocks.stale) {
+		throwIfCancelled(signal, "GC");
 		const cleared = (0, ownership_claim_exports.clearFreeClaimSet)({
 			root: lock.path,
 			label: `${lock.platform} build`
 		});
 		if (cleared.status === "held") continue;
 		if (cleared.status === "refused") {
-			console.log(chalk.yellow(`Left the build lock at ${lock.path} alone: ${cleared.reason}`));
-			recordGcResult("buildLock", "kept", `${lock.platform} build lock`, {
+			output.log(chalk.yellow(`Left the build lock at ${lock.path} alone: ${cleared.reason}`));
+			output.record("buildLock", "kept", `${lock.platform} build lock`, {
 				id: lock.path,
 				detail: cleared.reason
 			});
@@ -2696,25 +2750,26 @@ async function runGcCore(opts, deps) {
 		}
 		if (cleared.status === "failed") {
 			deleteFailures++;
-			console.log(chalk.red(`Failed to clear the build lock at ${lock.path}: ${cleared.reason}`));
-			recordGcResult("buildLock", "failed", `${lock.platform} build lock`, {
+			output.log(chalk.red(`Failed to clear the build lock at ${lock.path}: ${cleared.reason}`));
+			output.record("buildLock", "failed", `${lock.platform} build lock`, {
 				id: lock.path,
 				detail: cleared.reason
 			});
 			continue;
 		}
-		recordGcResult("buildLock", "done", `${lock.platform} build lock`, { id: lock.path });
-		console.log(chalk.green(`Cleared the ${lock.platform} build lock left by pid ${lock.pid ?? "?"} (${lock.projectRoot || "unrecorded workspace"})`));
+		output.record("buildLock", "done", `${lock.platform} build lock`, { id: lock.path });
+		output.log(chalk.green(`Cleared the ${lock.platform} build lock left by pid ${lock.pid ?? "?"} (${lock.projectRoot || "unrecorded workspace"})`));
 	}
 	for (const slot of buildSlots.stale) {
+		throwIfCancelled(signal, "GC");
 		const cleared = (0, ownership_claim_exports.clearFreeClaimSet)({
 			root: slot.path,
 			label: "build slot"
 		});
 		if (cleared.status === "held") continue;
 		if (cleared.status === "refused") {
-			console.log(chalk.yellow(`Left the build slot at ${slot.path} alone: ${cleared.reason}`));
-			recordGcResult("buildSlot", "kept", `build slot ${slot.index ?? "?"}`, {
+			output.log(chalk.yellow(`Left the build slot at ${slot.path} alone: ${cleared.reason}`));
+			output.record("buildSlot", "kept", `build slot ${slot.index ?? "?"}`, {
 				id: slot.path,
 				detail: cleared.reason
 			});
@@ -2722,47 +2777,53 @@ async function runGcCore(opts, deps) {
 		}
 		if (cleared.status === "failed") {
 			deleteFailures++;
-			console.log(chalk.red(`Failed to clear the build slot at ${slot.path}: ${cleared.reason}`));
-			recordGcResult("buildSlot", "failed", `build slot ${slot.index ?? "?"}`, {
+			output.log(chalk.red(`Failed to clear the build slot at ${slot.path}: ${cleared.reason}`));
+			output.record("buildSlot", "failed", `build slot ${slot.index ?? "?"}`, {
 				id: slot.path,
 				detail: cleared.reason
 			});
 			continue;
 		}
-		recordGcResult("buildSlot", "done", `build slot ${slot.index ?? "?"}`, { id: slot.path });
-		console.log(chalk.green(`Cleared build slot ${slot.index ?? "?"} left by pid ${slot.pid ?? "?"} (${slot.projectRoot || "unrecorded workspace"})`));
-	}
-	for (const entry of deviceLeases.expired) try {
-		if (removeExpiredLease(entry)) {
-			recordGcResult("deviceLease", "done", `${entry.platform} lease on ${entry.id ?? entry.name}`, { id: entry.path });
-			console.log(chalk.green(`Cleared the expired ${entry.platform} device lease on ${entry.id ?? entry.name} (held by ${entry.lease?.holder ?? "an unrecorded workspace"})`));
-		} else console.log(chalk.dim(`${entry.name} is no longer an expired lease; left alone.`));
-	} catch (err) {
-		deleteFailures++;
-		console.log(chalk.red(`Failed to clear the device lease at ${entry.path}: ${err?.message || err}`));
-		recordGcResult("deviceLease", "failed", `${entry.platform} lease on ${entry.id ?? entry.name}`, {
-			id: entry.path,
-			detail: err?.message || String(err)
-		});
+		output.record("buildSlot", "done", `build slot ${slot.index ?? "?"}`, { id: slot.path });
+		output.log(chalk.green(`Cleared build slot ${slot.index ?? "?"} left by pid ${slot.pid ?? "?"} (${slot.projectRoot || "unrecorded workspace"})`));
+	}
+	for (const entry of deviceLeases.expired) {
+		throwIfCancelled(signal, "GC");
+		try {
+			if (removeExpiredLease(entry)) {
+				output.record("deviceLease", "done", `${entry.platform} lease on ${entry.id ?? entry.name}`, { id: entry.path });
+				output.log(chalk.green(`Cleared the expired ${entry.platform} device lease on ${entry.id ?? entry.name} (held by ${entry.lease?.holder ?? "an unrecorded workspace"})`));
+			} else output.log(chalk.dim(`${entry.name} is no longer an expired lease; left alone.`));
+		} catch (err) {
+			deleteFailures++;
+			output.log(chalk.red(`Failed to clear the device lease at ${entry.path}: ${err?.message || err}`));
+			output.record("deviceLease", "failed", `${entry.platform} lease on ${entry.id ?? entry.name}`, {
+				id: entry.path,
+				detail: err?.message || String(err)
+			});
+		}
 	}
-	deleteFailures += await deleteEasSessions(easSessionSweep, deps);
-	if (report.worktreeSweep) deleteFailures += await removeWorktrees(report.worktreeSweep);
+	throwIfCancelled(signal, "GC");
+	deleteFailures += await deleteEasSessions(easSessionSweep, deps, output);
+	throwIfCancelled(signal, "GC");
+	if (report.worktreeSweep) deleteFailures += await removeWorktrees(report.worktreeSweep, { operation: deps.operation }, output);
 	if (deleteFailures) {
-		console.log(chalk.red(`\n${deleteFailures} entr${deleteFailures === 1 ? "y" : "ies"} could not be deleted; see above.`));
-		process.exitCode = 1;
+		output.log(chalk.red(`\n${deleteFailures} entr${deleteFailures === 1 ? "y" : "ies"} could not be deleted; see above.`));
+		output.fail();
 	}
-	if (all) emptyCaches(caches);
+	throwIfCancelled(signal, "GC");
+	if (all) await emptyCaches(caches, output, signal, deps.operation);
 	else if (olderThan === null) {
-		if (caches.length) console.log(chalk.dim("Shared caches left alone: pass --cache all to empty them, or --older-than <days> to trim them."));
-	} else trimCaches(caches, olderThan);
+		if (caches.length) output.log(chalk.dim("Shared caches left alone: pass --cache all to empty them, or --older-than <days> to trim them."));
+	} else await trimCaches(caches, olderThan, output, signal, deps.operation);
 	return payload(deleteFailures);
 }
 function gcCommand(program) {
-	program.command("gc").description("Report what Stim has left behind: dead project entries, orphaned workspace directories, clean Stim-managed linked worktrees whose branch is merged or whose pull request was merged or closed, orphaned owned devices and EAS sessions, records of devices that no longer exist, build locks whose builder is gone, expired physical-device leases, the shared build caches, the build outputs and logs of each workspace, and the memory of watchman and of the Gradle and Kotlin daemons. Reports by default; pass --delete to act.").option("--worktrees", "also remove clean, idle Stim-managed linked worktrees, not only merged ones: with --delete run `stim worktree remove` (never --force) on each; idle means unused for --older-than days, 7 without it").option("--delete", "actually prune the reported entries, reap the reported devices, clear the build outputs of every workspace not in use, and trim its Metro, client and device logs to their newest 8 MiB").option("--older-than <days>", "also reap owned devices whose workspace has not been used this long, trim shared cache entries nothing has used in that time and device recordings made before it, and clear workspace build outputs only for workspaces idle this long and parked devices only once parked this long", (v) => {
+	program.command("gc").description("Report what Stim has left behind: dead project entries, orphaned workspace directories, clean Stim-managed linked worktrees whose branch is merged or whose pull request was merged or closed, orphaned owned devices and EAS sessions, records of devices that no longer exist, build locks whose builder is gone, expired physical-device leases, the shared build caches, the build outputs and logs of each workspace, the memory of watchman and of the Gradle and Kotlin daemons, and recognized leftovers in TMPDIR. Reports by default; pass --delete to act.").option("--worktrees", "also remove clean, idle Stim-managed linked worktrees, not only merged ones: with --delete run `stim worktree remove` (never --force) on each; idle means unused for --older-than days, 7 without it").option("--delete", "actually prune the reported entries, reap the reported devices, clear the build outputs of every workspace not in use, and trim its Metro, client and device logs to their newest 8 MiB").option("--older-than <days>", "also reap owned devices whose workspace has not been used this long, trim shared cache entries nothing has used in that time and device recordings made before it, and clear workspace build outputs only for workspaces idle this long and parked devices only once parked this long", (v) => {
 		const n = parseInt(v, 10);
 		if (!Number.isFinite(n) || String(n) !== String(v).trim()) throw new InvalidArgumentError("must be a whole number of days, e.g. --older-than 30");
 		return n;
-	}).option("--cache <name>", "act on the shared caches whose name or directory contains <name>, every cache, the workspace build outputs and the device recordings with --cache all, only the workspace build outputs with --cache workspaces, only the device recordings with --cache recordings, only the parked simulators and emulators with --cache parked, the watchman daemon and its stale roots with --cache watchman, or the Gradle and Kotlin compile daemons with --cache gradle-daemons; archived, archived:<id>, archived-logs, archived-recordings and archived-agent select archived history explicitly, and the three kind selectors also take :<id> (archived-logs:<id>) to clear one kind of one archive; --cache all excludes archives. all, workspaces, recordings, parked, archived, archived:<id>, archived-logs, archived-recordings, archived-agent, their :<id> forms, watchman and gradle-daemons are reserved names that never select a single cache, and --cache all never includes watchman or gradle-daemons. With --delete they are emptied whole (a parked device is erased and stays parked, watchman loses its stale roots and shuts down only when no client uses it, and only daemons proven idle stop), which is the only way to clear an index-backed cache; add --older-than <days> to trim them by age instead. Archive ids, including the :<id> of a kind selector, ignore --older-than; archived and per-kind archive selectors without an id filter by removal age. Only those caches are reported; other devices and project entries are not inspected. Caches outside the config dir are refused while STIM_HOME is set.", (v) => {
+	}).option("--cache <name>", "act on the shared caches whose name or directory contains <name>, every cache, the workspace build outputs and the device recordings with --cache all, only the workspace build outputs with --cache workspaces, only the device recordings with --cache recordings, only the parked simulators and emulators with --cache parked, the watchman daemon and its stale roots with --cache watchman, the Gradle and Kotlin compile daemons with --cache gradle-daemons, or the Gradle version caches and wrapper distributions no registered project pins with --cache gradle-versions; archived, archived:<id>, archived-logs, archived-recordings and archived-agent select archived history explicitly, and the three kind selectors also take :<id> (archived-logs:<id>) to clear one kind of one archive; --cache all excludes archives. all, workspaces, recordings, parked, archived, archived:<id>, archived-logs, archived-recordings, archived-agent, their :<id> forms, watchman, gradle-daemons and gradle-versions are reserved names that never select a single cache, and --cache all never includes watchman, gradle-daemons or gradle-versions. With --delete they are emptied whole (a parked device is erased and stays parked, watchman loses its stale roots and shuts down only when no client uses it, and only daemons proven idle stop), which is the only way to clear an index-backed cache; add --older-than <days> to trim them by age instead. Archive ids, including the :<id> of a kind selector, ignore --older-than; archived and per-kind archive selectors without an id filter by removal age. Only those caches are reported; other devices and project entries are not inspected. Caches outside the config dir are refused while STIM_HOME is set.", (v) => {
 		if (!v.trim()) throw new InvalidArgumentError("must name a cache, e.g. --cache \"compilation cache\"");
 		return v;
 	}).option("--idle <duration>", "shut down (never delete) owned simulators and emulators that have had no driver, claim, or activity for at least <duration>, such as 30m, 2h, or 1d; acts without --delete", (v) => {
@@ -2770,8 +2831,9 @@ function gcCommand(program) {
 		if (ms === null) throw new InvalidArgumentError("must be a whole number of minutes, hours, or days, e.g. --idle 2h");
 		return ms;
 	}).option("--json", "print the report as JSON on stdout; every other line goes to stderr").action(async (opts) => {
-		await runGc(opts);
+		const { interrupted } = await runProcessOperation(process.cwd(), (operation) => withDrainingCancellation(operation, operation.signal, () => runGc(opts, { operation })));
+		if (interrupted !== null) process.exitCode = interrupted;
 	});
 }
 //#endregion
-export { collectGcReport, gcCommand as default, deleteParkedSims, describeParkedSims, describeUnverifiableDevices, findOrphanedDevices, findStaleDeviceRecords, findStaleProjectDevices, formatGcReport, runGc, selectCaches };
+export { runGc as a, readGcReport as i, executeGc as n, withGcMaintenanceClaim as o, gcCommand as r, formatGcReport as s, collectGcReport as t };