stim 1.21.0 → 1.22.0

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

@@ -1,42 +1,47 @@
-import { f as ownership_claim_exports, p as process_identity_exports, t as getExecutor } from "./exec-_UbtCQcG.mjs";
-import { d as workspaceDir, v as withDirLock$1 } from "./paths-DQtTgsBf.mjs";
-import { D as withConfigLock$1, F as isOnMountedVolume, I as listMountedVolumes, K as projectDeviceSlots, N as directorySizeAsync, P as formatBytes, R as measuredDirectorySizeAsync, S as removeProject, _ as loadConfig$1, j as acquireAvdClaim, z as volumeRootFor } from "./config-CYcBF478.mjs";
-import { h as shortUdid, o as formatLongDuration, u as plural } from "./command-output-B1UrjZHL.mjs";
-import { u as workspaceLastUsed } from "./workspace-state-Cjuigeeu.mjs";
-import { kt as listWorktreesAsync, zt as resolveSourceCheckoutAsync } from "./settings-CsJDEXgK.mjs";
-import { i as findProjectRoot$1, v as detectIsExpo } from "./project-BZNjmW_8.mjs";
-import { a as removeEasSessionClaim, n as easMachineStateRoot$1, r as readEasSessionLedger$1 } from "./eas-session-ledger-op6A54yi.mjs";
-import { $ as includesRecordings, At as unverifiedDeviceCommand, C as collectIdleDevices, D as idleDeviceLines, Dt as findOrphanedDevices, Et as eraseParkedDevices, Ft as withRemoteSessionGcLocks, 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-Bs6SxxzO.mjs";
+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 takeGcResults, I as listBuildSlots, 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, z as recordGcResult } from "./workspaces-BccMFmGQ.mjs";
-import { N as listBuildLocks, k as removeExpiredLease } from "./activity-BzVfHSrY.mjs";
-import { n as readCreatedDevices$1, t as forgetCreatedDevice } from "./created-devices-CqeBlrEn.mjs";
-import { F as listOrphanedAvdDirectories, M as listAvds, N as listAvdsAsync, ht as parkedMaxSetting, lt as POOL_SETTING_REMEDY, m as avdNameAbsent, z as ownedAvdDirectory } from "./android-DUYkNF4u.mjs";
-import { d as listAllIosSims, f as listAllIosSimsAsync } from "./ios-CpByZy12.mjs";
-import { r as readCollectors } from "./ownership-DEmM5vhh.mjs";
-import { _ as describeDereferenced, a as matchWorktreeEntry, b as sweepArchiveStaging, v as reclaimProject, y as deleteSelectedArchives } from "./worktree-DQ6Zi2Mv.mjs";
-import { s as writeCacheFile } from "./warm-progress-BHX5r0Ei.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-DHAw2A2S.mjs";
-import { i as getSwiftpmCacheUsage, n as swiftpmCacheLines, r as getAgentDeviceUsage, t as agentDeviceLines } from "./agent-device-usage-output-zh1vhbLp.mjs";
-import { existsSync, lstatSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
+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, rotatedLogPath } from "@stim-cli/core";
-import { assertHostedDeviceLedger, deviceHostArea, deviceHostRoot, diskUsageCacheFile, hostedDeviceId, isJsonObject, listRecordedDevices, listStatusCacheEntries, maintenanceRunClaims, parseHostedPlatformDevice, readArchives, readDiskUsage, readHostedDevice, readHostedDeviceLedger, readHostedSessions, recordedBytes } from "@stim-cli/core/state";
+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 { setImmediate } from "node:timers/promises";
 import chalk from "chalk";
-import { closeSync as closeSync$1, existsSync as existsSync$1, openSync as openSync$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 { 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
@@ -55,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
@@ -69,29 +74,35 @@ 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;
 }
@@ -127,17 +138,24 @@ 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
@@ -271,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
 				});
@@ -295,9 +316,10 @@ 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
@@ -338,22 +360,25 @@ function finishedDeviceLines(devices = []) {
 	lines.push("              --delete keeps a workspace that is in use, leased, driven, locked or pinned.");
 	return lines;
 }
-async function deleteFinishedDevices({ finishedDevices: devices, worktreeSweep }) {
+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(),
-			purpose: "stim gc --delete"
+			protectedRoot: triggeringRoot(operation),
+			purpose: "stim gc --delete",
+			operation,
+			output
 		});
 		if (outcome.status === "kept") {
-			console.log(chalk.yellow(`Kept the owned devices of ${project}: ${outcome.detail}`));
-			recordGcResult("device", "kept", project, { detail: outcome.detail });
+			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++;
-			console.log(chalk.red(`Could not delete the owned devices of ${project}: ${outcome.detail}`));
-			recordGcResult("device", "failed", project, { detail: outcome.detail });
+			output.log(chalk.red(`Could not delete the owned devices of ${project}: ${outcome.detail}`));
+			output.record("device", "failed", project, { detail: outcome.detail });
 		}
 	}
 	return failures;
@@ -421,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
 				});
@@ -447,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) {
@@ -1126,8 +1172,12 @@ function inside(root, path) {
 	const rel = relative(root, path);
 	return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
 }
-async function buildStateDirs(path, keys) {
-	const entries = await listWorktreesAsync(path);
+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 = {
@@ -1156,14 +1206,18 @@ function cachedSize(dir, now) {
 		return null;
 	}
 }
-async function duSize(dir) {
+async function duSize(dir, operation) {
 	let out;
 	try {
-		out = await getExecutor().runFileAsync("du", ["-sk", dir], {
+		out = await runOperationFile(operation, getExecutor(), "du", ["-sk", dir], {
 			timeoutMs: BUILD_STATE_TIMEOUT_MS,
-			killSignal: "SIGKILL"
+			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 : "";
 	}
@@ -1180,16 +1234,19 @@ async function eachLimited(items, limit, run) {
 /**
 * 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, at most 4 at once and 10 seconds each, so a
+* 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);
+		const dirs = await buildStateDirs(candidate.path, candidate.keys, operation);
 		pending.push({
 			candidate,
 			root: canonicalPath(candidate.path),
@@ -1203,9 +1260,10 @@ async function measureWorktreeSweep(sweep, operation) {
 	}] : []));
 	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, BUILD_STATE_CONCURRENCY, async ({ dir, sizes }) => {
+	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);
+		const bytes = await duSize(dir, operation);
 		if (bytes === null) return;
 		sizes.set(dir, bytes);
 		operation?.signal.throwIfAborted();
@@ -1225,7 +1283,7 @@ async function measureWorktreeSweep(sweep, operation) {
 			dirs: entries.toSorted((a, b) => (b.bytes ?? 0) - (a.bytes ?? 0))
 		};
 	}
-	sweep.unlisted = await unlistedWorktreeDirs();
+	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. */
@@ -1241,15 +1299,22 @@ function hasLiveGitDir(path) {
 	const gitdir = /^gitdir:\s*(.+)$/m.exec(text)?.[1]?.trim();
 	return Boolean(gitdir) && existsSync(resolve(dirname(dotGit), gitdir ?? ""));
 }
-async function unlistedWorktreeDirs() {
+async function unlistedWorktreeDirs(operation) {
 	const repositories = /* @__PURE__ */ new Map();
-	for (const root of await candidateRootsAsync()) {
-		const { entries, ...source } = await resolveSourceCheckoutAsync(root);
+	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 {
@@ -1258,6 +1323,7 @@ async function unlistedWorktreeDirs() {
 			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);
@@ -1265,7 +1331,11 @@ async function unlistedWorktreeDirs() {
 			found.push({
 				path,
 				repository,
-				bytes: await measuredDirectorySizeAsync(path, { timeoutMs: SIZE_TIMEOUT_MS })
+				bytes: await measuredDirectorySizeAsync(path, {
+					timeoutMs: SIZE_TIMEOUT_MS,
+					operation,
+					signal: operation?.signal
+				})
 			});
 		}
 	}
@@ -1302,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);
 	}
@@ -1337,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
@@ -1364,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;
 	}
 }
@@ -1387,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) {
@@ -1417,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";
@@ -1438,70 +1531,89 @@ 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
@@ -1553,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,
@@ -1578,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;
@@ -1598,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;
@@ -1622,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);
@@ -1641,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.";
@@ -1673,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,
@@ -1689,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
 			});
@@ -1738,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
 			});
@@ -1772,13 +1915,17 @@ function readGcReport(options = {}, deps = {}) {
 		cache: options.cache,
 		worktrees: options.worktrees,
 		json: true
-	}, deps, true);
+	}, deps, {
+		output: GC_OUTPUT,
+		takeResults: () => []
+	}, true);
 }
-function removeInvalidProjectEntries(invalidProjects) {
+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, env, operation) {
@@ -1814,11 +1961,14 @@ 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, refresh = true, now = Date.now(), lastTouched = workspaceLastUsed } = {}, deps = {}) {
@@ -1829,10 +1979,10 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	const withWorkspaces = includesWorkspaceOutputs(scope);
 	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);
+	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: [],
@@ -1881,14 +2031,16 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		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), env, operation) : null,
 		agentDeviceUsage: null,
@@ -1914,7 +2066,8 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	const tempLeftovers = await collectTempLeftovers({
 		now,
 		env,
-		signal: operation?.signal
+		signal: operation?.signal,
+		operation
 	});
 	const mountedVolumes = listMountedVolumes();
 	const cfg = loadConfig$1();
@@ -1922,6 +2075,8 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	if (!easSessionSweep) try {
 		easSessionSweep = await collectEasSessionSweep(cfg, deps);
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
 		easSessionSweep = {
 			projectScope: null,
 			orphaned: [],
@@ -1938,7 +2093,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		now
 	});
 	const { deadProjects, invalidProjects, skipped } = classifyProjectEntries(cfg, mountedVolumes);
-	const workspaceDirs = await 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);
@@ -1958,7 +2113,11 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	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)));
+		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;
@@ -1967,11 +2126,25 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		let simNames = [];
 		let avdNames = [];
 		try {
-			simNames = (await listAllIosSimsAsync({ 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 = await listAvdsAsync({ 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 = [];
@@ -1980,19 +2153,29 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		try {
 			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 = await listAvdsAsync({ 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`);
 		}
@@ -2023,9 +2206,10 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			return directories.length ? directories.map((orphanedDirectory) => Object.assign({}, device, { orphanedDirectory })) : [device];
 		}), {
 			avdDirectory: deps.avdDirectory ?? ownedAvdDirectory,
-			size: avdSize
+			size: avdSize,
+			operation
 		});
-		idleDevices = operation ? await collectIdleDevicesAsync(cfg, sims, deadProjects, now, env) : 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,
@@ -2060,7 +2244,8 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			deadProjects
 		}), {
 			avdDirectory: deps.avdDirectory ?? ownedAvdDirectory,
-			size: avdSize
+			size: avdSize,
+			operation
 		});
 	}
 	const locks = listBuildLocks();
@@ -2112,14 +2297,19 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		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),
+		}, goneWorkspaceDirs, operation?.signal),
 		worktreeSweep,
 		finishedDevices: listed ? collectFinishedDevices({
 			config: cfg,
@@ -2142,30 +2332,41 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	};
 }
 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;
@@ -2178,20 +2379,45 @@ 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, reportOnly = false) {
-	const core = (dependencies) => runGcCore(opts, dependencies, reportOnly);
+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.";
@@ -2201,10 +2427,10 @@ async function sweep(opts, deps, reportOnly = false) {
 			message,
 			remedy
 		};
-		console.error(chalk.red(message));
-		console.error(chalk.dim(remedy));
-		console.error(chalk.red("failed: STIM_BAD_ARG"));
-		process.exitCode = 1;
+		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,
@@ -2220,10 +2446,10 @@ async function sweep(opts, deps, reportOnly = false) {
 			message,
 			remedy
 		};
-		console.error(chalk.red(message));
-		console.error(chalk.dim(remedy));
-		console.error(chalk.red("failed: STIM_BAD_ARG"));
-		process.exitCode = 1;
+		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,
@@ -2233,7 +2459,7 @@ async function sweep(opts, deps, reportOnly = false) {
 	const poolError = parkedMaxSetting("ios").error || parkedMaxSetting("android").error;
 	if (poolError) {
 		if (reportOnly) phase("note", `${poolError} ${POOL_SETTING_REMEDY}`, deps.operation);
-		else console.error(chalk.yellow(`${poolError} ${POOL_SETTING_REMEDY}`));
+		else output.error(chalk.yellow(`${poolError} ${POOL_SETTING_REMEDY}`));
 	}
 	if (opts.cache) return core({
 		...deps,
@@ -2286,9 +2512,15 @@ async function sweep(opts, deps, reportOnly = false) {
 		}, {
 			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: [],
@@ -2301,44 +2533,48 @@ async function sweep(opts, deps, reportOnly = false) {
 		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
 			});
@@ -2370,19 +2606,21 @@ function dryRunHint(cache, all, actionable, caches) {
 function scopedWorkPending(cache, report) {
 	return memoryWorkPending(cache, report.memory) || gradleVersionsPending(report.gradleVersions);
 }
-function pruneStatusCaches(report) {
+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) {
-	return report.cacheScope ? await eraseParkedDevices(report.parkedSims, report.parkedAvds) : await deleteParkedSims(report.parkedSims, deps) + await deleteParkedAvds(report.parkedAvds);
+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 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, reportOnly = false) {
-	if (!reportOnly) 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;
@@ -2392,13 +2630,14 @@ async function runGcCore(opts, deps, reportOnly = false) {
 		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(deps.operation?.env ?? process.env, deps.operation?.cwd).map((c) => c.name))];
 		const message = `No shared cache carries "${cache}" in its name or directory.`;
 		if (!reportOnly) {
-			console.log(chalk.yellow(message));
-			if (names.length) console.log(chalk.dim(`Caches on this machine: ${names.join(", ")}`));
-			if (opts.json) process.exitCode = 1;
+			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",
@@ -2410,21 +2649,26 @@ async function runGcCore(opts, deps, reportOnly = false) {
 	const refusal = archiveRefusal(report.archives);
 	if (refusal !== null) {
 		if (!reportOnly) {
-			process.exitCode = 1;
-			console.error(chalk.red(refusal.message));
-			console.error(chalk.dim(refusal.remedy));
-			console.error(chalk.red(`failed: ${refusal.code}`));
+			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;
-	if (!reportOnly) 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 = reportActionable(report);
 	const idle = opts.idle ?? null;
-	const idleFailures = idle === null ? 0 : (await 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 ? await collectInventory(loadConfig$1(), deadProjects, deps.operation?.env ?? process.env) : 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,
@@ -2435,48 +2679,70 @@ async function runGcCore(opts, deps, reportOnly = false) {
 		failures,
 		sections: gcReportSections(report),
 		...report.maintenance ? { maintenance: report.maintenance } : {},
-		results: reportOnly ? [] : takeGcResults(),
+		results: reportOnly ? [] : takeResults(),
 		inventory
 	});
 	if (!opts.delete) {
 		const hint = dryRunHint(cache, all, actionable, caches.length > 0);
-		if (hint && !reportOnly) 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 += await reclaimParkedDevices(report, deps);
-	deleteFailures += await deleteParkedHostedDevices(report.parkedHostedDevices);
-	deleteFailures += await reclaimMemory(cache, report.memory);
-	deleteFailures += await deleteGradleVersions(report.gradleVersions);
-	removeInvalidProjectEntries(invalidProjects);
-	deleteFailures += await pruneDeadProjects(deadProjects);
-	deleteFailures += await deleteOrphanedWorkspaces(report.orphanedWorkspaces);
-	deleteFailures += await deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords);
-	deleteFailures += await deleteFinishedDevices(report);
-	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
-	})).failures;
+		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
 			});
@@ -2484,25 +2750,26 @@ async function runGcCore(opts, deps, reportOnly = false) {
 		}
 		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
 			});
@@ -2510,39 +2777,45 @@ async function runGcCore(opts, deps, reportOnly = false) {
 		}
 		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) {
@@ -2558,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 { formatGcReport as a, runGc as i, gcCommand as n, readGcReport as r, collectGcReport as t };
+export { runGc as a, readGcReport as i, executeGc as n, withGcMaintenanceClaim as o, gcCommand as r, formatGcReport as s, collectGcReport as t };