stim 1.20.2 → 1.22.0

package/dist/{worktree-CgvJYJ-Q.mjs → worktree-CHecZ4Oq.mjs}

@@ -1,43 +1,209 @@
-import { A as acquireAvdClaim, E as upsertProject, S as removeProject, W as projectDeviceSlots, _ as loadConfig$1, a as clearDevice, d as getConfigDir, g as isPathPrefix, j as ownership_claim_exports, k as process_identity_exports, p as getProject } from "./config-BYDxlMY3.mjs";
-import { n as isTimeoutError, t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { r as gitQuiet, t as git } from "./git-DDfFzkMm.mjs";
-import { At as restoreFile, Ct as locallyKnownUpstream, Et as removeWorktree, G as resolveIosProjectDir, K as resolveProjectSettings, Mt as unpushedCommits, Nt as warmWorktreePaths, Ot as resolveFullRef, Q as settingShapeErrors, R as readCommittedSettings, St as listWorktrees, Tt as readWorktreeExclude, _t as hasPopulatedSubmodules, a as SETTING_SHAPE_REMEDY, bt as isPodInstallChurn, dt as deleteBranch, ft as depsOutOfSync, gt as gitCommonDirOnDisk, ht as gitCommonDir, jt as sourceCheckoutOf, lt as branchExists, mt as dirtyPaths, nt as unknownSettingKeys, q as resolveSettings, ut as cloneIgnoredEntries, vt as hasRemote, wt as podsOutOfSync, yt as hasUncommittedWork } from "./settings-B717odTD.mjs";
-import { u as releaseWorkspaceLeases } from "./device-lease-BX1sJQ2E.mjs";
-import { i as recordWorkspaceUse, r as readWorkspaceState$1, x as workspaceDir, y as workspaceAgentDeviceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { a as formatElapsed, h as shortUdid, i as formatDuration, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-BTy8hZ0F.mjs";
-import { D as clearManagedMetroTunnel, N as readRemoteSession, O as clearRemoteSession, P as readRemoteSessionId, a as isMobileProject, j as readMetroTunnel, r as findProjectRoot, w as MODE_COMMAND } from "./project-_phNIJfs.mjs";
-import { a as workspaceLinks, i as workspaceLinkLine } from "./stim-desktop-BzBN2Em2.mjs";
-import { at as POOL_SETTING_REMEDY, dt as parkedMaxSetting } from "./android-Mz_Inn3w.mjs";
-import { d as signalProcessTree, r as killMetroTree, s as pidExists, u as resolveProjectMetro } from "./metro-DnCEjCxs.mjs";
-import { A as withManagedRemoteWorktreeRemovalLock, D as stopTunnel, M as withManagedTunnelRemovalLock, P as resolveSupervisorTarget, b as teardownOwnedIosSim, d as emptyWorkspaceDir, f as withIdleWorkspace, v as teardownOwnedAvd, y as teardownOwnedBrowser } from "./workspaces-C36s2jb9.mjs";
-import { _t as withdrawDevServerStopRequest, ht as requestDevServerStop, o as machineNumber } from "./budget-f7516Zk0.mjs";
-import { t as clearNamedPorts } from "./named-ports-4WopRPg-.mjs";
-import { f as resolveEasCliBin } from "./remote-cache-OyOyVIS3.mjs";
-import { o as readWebRecord } from "./state-D1Icyjlu.mjs";
-import { t as agentDeviceDaemon } from "./activity-BSV745Kz.mjs";
-import { t as macosAppPresent } from "./state-CG_OFoaA.mjs";
-import { L as podInstallCommand, d as DEPS_ERROR, f as podsAreStale, g as runPodInstall, h as runCaptured, p as readPodState, y as HEARTBEAT_INTERVAL_MS } from "./toolchain-DxSsNssu.mjs";
-import { a as discoverXcodeProject } from "./react-native-build-CtCccJtb.mjs";
-import { i as stopHostedAndroid } from "./hosted-android-C3MHGld1.mjs";
-import { i as endRecordedSession } from "./device-remote-xRT0Vmo9.mjs";
-import { n as verifyCollectorOwnership } from "./ownership-DCtw_2IA.mjs";
-import { r as stopHostedIos } from "./hosted-ios-l-o3iM9J.mjs";
-import { n as stopMacosApp } from "./stop-DPEhunlw.mjs";
-import { a as pullRequestLookup, r as endedPullRequest } from "./pull-request-CQ8sPbZa.mjs";
-import { a as forgetStatusMeasures, s as mergeState, t as startWarmProgress } from "./warm-progress-BuY-Fvfn.mjs";
-import { r as workspaceRecordingEnabled } from "./recordings-D0d5aQt0.mjs";
-import { n as hasInstalledDependencies, r as installedNpmTreeIsValid, t as dependencyState } from "./dependency-state-DG0p31-y.mjs";
-import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative } from "node:path";
-import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
-import { LAST_BUILD_KEYS, archiveDir, archiveEnabled, archiveLock, archiveRoot, archivedUsage, countErrorEntries, endedAgentSessionOf, isJsonObject, listRecordedDevices, loadConfig, queryLogs, readArchives, readBuildHistory, readJsonObject, readLastBuilds, readMacosRecord, readPullRequestCache, readWorkspaceState, recordingEnabled, sortByTs } from "@stim-cli/core/state";
-import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, readlinkSync as readlinkSync$1, realpathSync as realpathSync$1, renameSync as renameSync$1, rmSync as rmSync$1, symlinkSync as symlinkSync$1, unlinkSync as unlinkSync$1, writeFileSync as writeFileSync$1 } from "fs";
-import { withDirLock, workspaceName } from "@stim-cli/core";
+import { c as declareSpawnsOn, f as stopDeclaringSpawnsOn, g as process_identity_exports, m as operationState, n as isTimeoutError, r as WorkspaceProcessCleanupError, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
+import { d as workspaceDir, l as workspaceAgentDeviceDir } from "./paths-DQtTgsBf.mjs";
+import { E as upsertProject, G as projectDeviceSlots, L as measuredDirectorySizeAsync, S as removeProject, _ as loadConfig$1, a as clearDevice, d as getConfigDir, g as isPathPrefix, j as acquireAvdClaim, p as getProject } from "./config-DlrsduwG.mjs";
+import { a as formatElapsed, h as shortUdid, i as formatDuration, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-gwpm28fu.mjs";
+import { c as gitQuiet, o as git, r as childEnvironment, s as gitAsync, t as runOperationFile } from "./operation-exec-BW0em61G.mjs";
+import { i as recordWorkspaceUse, r as readWorkspaceState$1 } from "./workspace-state-U08dEzhG.mjs";
+import { At as readWorktreeExclude, Bt as warmWorktreePaths, Ct as isPodInstallChurn, Dt as locallyKnownUpstream, Et as listWorktreesAsync, Ft as resolveFullRefAsync, K as resolveIosProjectDir, Lt as restoreFileAsync, Pt as resolveFullRef, Rt as sourceCheckoutOf, St as hasUncommittedWorkAsync, Y as resolveSettings, a as SETTING_SHAPE_REMEDY, bt as hasPopulatedSubmodulesAsync, dt as branchExistsAsync, et as settingShapeErrors, ft as cloneIgnoredEntries, gt as dirtyPathsAsync, it as unknownSettingKeys, jt as removeWorktreeAsync, kt as podsOutOfSync, mt as depsOutOfSync, pt as deleteBranchAsync, q as resolveProjectSettings, vt as gitCommonDirAsync, xt as hasRemoteAsync, yt as gitCommonDirOnDisk, z as readCommittedSettings, zt as unpushedCommitsAsync } from "./settings-C7O8A6ZI.mjs";
+import { F as readRemoteSessionId, M as readMetroTunnel, O as clearManagedMetroTunnel, P as readRemoteSession, T as MODE_COMMAND, i as findProjectRoot$1, k as clearRemoteSession, o as isMobileProject } from "./project-wM_XFTvE.mjs";
+import { t as macosAppPresent } from "./state-08I3hw3_.mjs";
+import { c as pidExists, d as resolveProjectMetro, p as signalProcessTreeAsync, r as killMetroTreeAsync } from "./metro-DiXtA3Ty.mjs";
+import { o as readWebRecord } from "./state--smjFSTL.mjs";
+import { In as runProcessOperation, S as withdrawDevServerStopRequest, b as requestDevServerStop, br as discoverCaches, c as readVolumeSpace, l as readVolumeSpaceAsync, nt as planCacheEmptying, o as machineNumber, qn as resolveEasCliBin, u as resolveBudget, zt as endRecordedSession } from "./budget-Cvwn54qV.mjs";
+import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
+import { p as cacheUser } from "./native-run-NwUuxbkg.mjs";
+import { D as teardownOwnedAvd, O as teardownOwnedBrowser, S as withManagedTunnelRemovalLock, _ as stopTunnel, a as collectWorkspaceOutputs, b as withManagedRemoteWorktreeRemovalLock, d as emptyWorkspaceDir, f as withIdleWorkspace, h as resolveSupervisorTarget, k as teardownOwnedIosSim } from "./workspaces-CpANmBlq.mjs";
+import { D as releaseWorkspaceLeases, t as agentDeviceDaemon } from "./activity-CMLmzp7o.mjs";
+import { _t as parkedMaxSetting, dt as POOL_SETTING_REMEDY } from "./android-C7sVmyI9.mjs";
+import { F as readHostMemoryPressureAsync, P as readHostMemoryPressure } from "./ios-hcBpnEGk.mjs";
+import { a as workspaceLinkLine, o as workspaceLinks } from "./stim-desktop-D5OGpYZM.mjs";
+import { t as clearNamedPorts } from "./named-ports-DkEzOfzO.mjs";
+import { r as HEARTBEAT_INTERVAL_MS, x as podInstallCommand } from "./xcode-BXn9-xYx.mjs";
+import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
+import { _ as runCaptured, h as readPodState, m as podsAreStale, p as DEPS_ERROR, v as runPodInstall } from "./toolchain-DpJMHq0n.mjs";
+import { i as stopHostedAndroid } from "./hosted-android-B-9f-jkd.mjs";
+import { r as stopHostedIos } from "./hosted-ios-CsCS21hn.mjs";
+import { n as stopMacosApp } from "./stop-Dky10AEJ.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-C5fo5Edb.mjs";
+import { a as discoverXcodeProject } from "./react-native-build-Dvd8hC21.mjs";
+import { n as hasInstalledDependencies, r as installedNpmTreeIsValid, t as dependencyState } from "./dependency-state-1I9KZT1Y.mjs";
+import { a as forgetStatusMeasures, p as mergeStateAsync, t as startWarmProgress } from "./warm-progress-CA3TgT3-.mjs";
+import { o as pullRequestLookupAsync, r as endedPullRequest } from "./pull-request-W1IuLXDt.mjs";
+import { r as workspaceRecordingEnabled } from "./recordings-CQmfzAh7.mjs";
 import { claimRemoveCommand, clearFreeClaimSet, readClaimSet, releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
 import { createHash, randomUUID } from "node:crypto";
-import { homedir } from "node:os";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { cpus, freemem, homedir, loadavg, totalmem } from "node:os";
+import { basename, dirname, join, relative } from "node:path";
+import { buildCacheRoot, configDir, metroCacheRoot, unitLines, unitWords, withDirLockTransaction, workspaceName } from "@stim-cli/core";
+import { LAST_BUILD_KEYS, archiveDir, archiveEnabled, archiveLock, archiveRoot, archivedUsage, buildWorkerRoot, countErrorEntries, endedAgentSessionOf, isJsonObject, listRecordedDevicesAsync, loadConfig, queryLogs, readArchivesAsync, readBuildHistory, readJsonObject, readLastBuilds, readMacosRecord, readPullRequestCache, readWorkspaceState, recordingEnabled, sharedCcache, sharedCompilationCache, sortByTs } from "@stim-cli/core/state";
+import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import chalk from "chalk";
+import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, readlinkSync as readlinkSync$1, realpathSync as realpathSync$1, renameSync as renameSync$1, rmSync as rmSync$1, symlinkSync as symlinkSync$1, unlinkSync as unlinkSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { chmod, lstat, mkdir, readdir, rename, rm, stat, utimes, writeFile } from "node:fs/promises";
 import { createHash as createHash$1 } from "crypto";
+//#region src/maintenance/pressure.ts
+/**
+* The free-disk floor of each level in MiB. Level 2 has no floor of its own: it runs when level 1 left free disk
+* under the budget floor, and stops once free disk is back above it. Its urgent threshold only sets the reported level.
+*/
+function levelFloors(budget, settings) {
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	return {
+		1: floor,
+		2: floor,
+		3: Math.max(settings.criticalFreeDiskGb * 1024, budget.hardFloorDiskMb),
+		urgent: settings.urgentFreeDiskGb * 1024
+	};
+}
+function diskPressureLevel(freeMb, budget, settings) {
+	const floors = levelFloors(budget, settings);
+	if (freeMb < floors[3]) return 3;
+	if (freeMb < floors.urgent) return 2;
+	return freeMb < floors[1] ? 1 : 0;
+}
+function lowestFree(disk) {
+	return disk.length ? Math.min(...disk.map((volume) => volume.freeMb)) : Infinity;
+}
+/** Whether an action planned at a pressure level may still run with this much free disk. */
+function levelStillShort(action, freeMb, budget, settings) {
+	return action.level === void 0 || freeMb < levelFloors(budget, settings)[action.level];
+}
+/** The protection window in milliseconds: protectRecentHours, or maintenance.pressureProtectMinutes for actions of level 2 and 3. */
+function protectWindowMs(action, settings) {
+	return action.level === void 0 ? settings.protectRecentHours * 36e5 : settings.pressureProtectMinutes * 6e4;
+}
+//#endregion
+//#region src/maintenance/measure.ts
+function measureDisk() {
+	return readVolumeSpace([
+		configDir(),
+		...Object.keys(loadConfig()?.projects ?? {}),
+		buildWorkerRoot(loadConfig())
+	]);
+}
+function measureDiskAsync(operation) {
+	return readVolumeSpaceAsync([
+		configDir(),
+		...Object.keys(loadConfig()?.projects ?? {}),
+		buildWorkerRoot(loadConfig())
+	], operation.signal);
+}
+/** The disk pressure level of the fullest volume Stim writes to, measured now. */
+function currentDiskLevel(disk = measureDisk()) {
+	return diskPressureLevel(lowestFree(disk), resolveBudget().budget, resolveMaintenanceSettings());
+}
+function measurePressure(settings, previous, now) {
+	return pressureFromObservations(settings, previous, now, readHostMemoryPressure(), measureDisk());
+}
+async function measurePressureAsync(settings, previous, now, operation) {
+	return pressureFromObservations(settings, previous, now, await readHostMemoryPressureAsync(void 0, void 0, operation.signal, operation), await readVolumeSpaceAsync([
+		configDir(),
+		...Object.keys(loadConfig()?.projects ?? {}),
+		buildWorkerRoot(loadConfig())
+	], operation.signal));
+}
+function pressureFromObservations(settings, previous, now, level, disk) {
+	const availableBytes = process.platform === "darwin" ? null : freemem();
+	const warningSince = level === "warning" ? previous?.warningSince ?? now : null;
+	return {
+		disk,
+		memory: {
+			level,
+			availableBytes,
+			pressured: settings.memoryPressureLevel !== "off" && (level === "critical" || settings.memoryPressureLevel === "warning" && warningSince !== null && now - warningSince >= settings.memoryWarningMinutes * 6e4 || availableBytes !== null && availableBytes < (settings.minAvailableMemoryGb === void 0 ? totalmem() * .1 : settings.minAvailableMemoryGb * 1024 ** 3))
+		},
+		warningSince
+	};
+}
+function sizeScanDeferred(settings) {
+	return loadavg()[0] / Math.max(1, cpus().length) > settings.maxLoadPerCore;
+}
+function cacheBlocked(entry, discovered = discoverCaches(), env = process.env) {
+	return planCacheEmptying([{
+		...entry,
+		note: "",
+		prune: "entries",
+		...discovered.some((cache) => canonicalPath(cache.dir) === canonicalPath(entry.dir) && cache.source === "registered") ? { source: "registered" } : {}
+	}], false, env)[0]?.machineGlobal ?? (entry.category === "compilation-cache" ? cacheUser(entry.dir) : void 0);
+}
+async function measureSizes(now, failure) {
+	const sizes = [];
+	const outputs = await collectWorkspaceOutputs({
+		olderThan: null,
+		now,
+		sizeTimeoutMs: 12e4
+	});
+	for (const entry of outputs.workspaces) {
+		if (entry.bytes === null) {
+			failure(entry.dir, entry.projectRoot ?? void 0);
+			continue;
+		}
+		sizes.push({
+			name: "workspace build outputs",
+			category: "workspace-outputs",
+			dir: entry.dir,
+			bytes: entry.bytes,
+			measuredAt: now,
+			...entry.projectRoot ? { workspace: canonicalPath(entry.projectRoot) } : {},
+			idleDays: entry.idleDays,
+			...!entry.willClear ? { blocked: entry.keptReason ?? "workspace ownership is unresolved" } : {}
+		});
+	}
+	const known = [
+		{
+			name: "shared build cache",
+			dir: buildCacheRoot(),
+			category: "build-cache"
+		},
+		{
+			name: "Metro transform caches",
+			dir: metroCacheRoot(),
+			category: "metro-cache"
+		},
+		{
+			name: "ccache",
+			dir: sharedCcache(),
+			category: "ccache"
+		},
+		{
+			name: "Swift compilation cache",
+			dir: sharedCompilationCache(),
+			category: "compilation-cache"
+		}
+	];
+	const discovered = discoverCaches();
+	for (const cache of discovered) {
+		if (cache.source !== "registered" && !canonicalPath(cache.dir).startsWith(`${canonicalPath(configDir())}/`)) continue;
+		if (cache.prune === "report-only") continue;
+		const dir = canonicalPath(cache.dir);
+		if (known.some((item) => dir === canonicalPath(item.dir) || dir.startsWith(`${canonicalPath(item.dir)}/`))) continue;
+		const category = cache.name.startsWith("Metro transform cache") ? "metro-cache" : /^(Expo build cache|native build cache|Build cache)$/.test(cache.name) ? "build-cache" : "other";
+		known.push({
+			name: cache.name,
+			dir: cache.dir,
+			category
+		});
+	}
+	for (const entry of known) {
+		if (!existsSync(entry.dir)) continue;
+		const bytes = await measuredDirectorySizeAsync(entry.dir, { timeoutMs: 12e4 });
+		if (bytes === null) {
+			failure(entry.dir);
+			continue;
+		}
+		const blocked = cacheBlocked(entry, discovered);
+		sizes.push({
+			...entry,
+			bytes,
+			measuredAt: now,
+			...blocked ? { blocked } : {}
+		});
+	}
+	return sizes;
+}
+//#endregion
 //#region src/workspace/pods-relocate.ts
 const CHECKSUMS_HEADER = "SPEC CHECKSUMS:\n";
 const GENERATED_DIRS = [
@@ -230,7 +396,7 @@ const KIND_PATH = {
 	recordings: "recordings",
 	agentActions: "agent-device/sessions"
 };
-function archiveSettings() {
+function archiveSettings(env = process.env) {
 	const config = loadConfig();
 	return Object.fromEntries([
 		"maxAgeDays",
@@ -242,57 +408,63 @@ function archiveSettings() {
 		"recordings.maxTotalGb",
 		"agentActions.maxAgeDays"
 	].map((key) => {
-		const result = machineNumber(`archive.${key}`, config, process.env);
+		const result = machineNumber(`archive.${key}`, config, env);
 		if (result.error) throw new Error(result.error);
 		return [key, result.value];
 	}));
 }
-function enabled(root) {
+function enabled(root, env) {
 	const config = loadConfig();
 	const project = config?.projects?.[root];
 	const present = existsSync(root);
 	const common = present ? gitCommonDirOnDisk(root) : null;
 	if (!present && Object.values(config?.repos ?? {}).some((repo) => repo.settings?.archive?.enabled === false)) return false;
-	return archiveEnabled(process.env, [
+	return archiveEnabled(env, [
 		project?.settings,
 		common ? config?.repos?.[common]?.settings : void 0,
 		present ? readCommittedSettings(root) : void 0,
 		config
 	]);
 }
-function files(dir) {
+async function files(dir, signal) {
+	signal?.throwIfAborted();
 	if (!existsSync(dir)) return [];
-	return readdirSync(dir).flatMap((name) => {
+	const found = [];
+	for (const name of await readdir(dir)) {
+		signal?.throwIfAborted();
 		const path = join(dir, name);
-		const stat = lstatSync(path);
-		if (stat.isSymbolicLink()) throw new Error(`refusing symlink ${path}`);
-		return stat.isDirectory() ? files(path) : [{
+		const entry = await lstat(path);
+		if (entry.isSymbolicLink()) throw new Error(`refusing symlink ${path}`);
+		if (entry.isDirectory()) for (const file of await files(path, signal)) found.push(file);
+		else found.push({
 			path,
-			bytes: stat.size,
-			at: stat.mtimeMs
-		}];
-	});
+			bytes: entry.size,
+			at: entry.mtimeMs
+		});
+	}
+	return found;
 }
-function secureTree(dir) {
-	if (lstatSync(dir).isSymbolicLink()) throw new Error(`refusing symlink ${dir}`);
-	chmodSync(dir, 448);
-	for (const name of readdirSync(dir)) {
+async function secureTree(dir) {
+	if ((await lstat(dir)).isSymbolicLink()) throw new Error(`refusing symlink ${dir}`);
+	await chmod(dir, 448);
+	for (const name of await readdir(dir)) {
 		const path = join(dir, name);
-		const stat = lstatSync(path);
-		if (stat.isSymbolicLink()) throw new Error(`refusing symlink ${path}`);
-		if (stat.isDirectory()) secureTree(path);
-		else chmodSync(path, 384);
+		const entry = await lstat(path);
+		if (entry.isSymbolicLink()) throw new Error(`refusing symlink ${path}`);
+		if (entry.isDirectory()) await secureTree(path);
+		else await chmod(path, 384);
 	}
 }
-function writeRecord(dir, record) {
-	const small = [
+async function writeRecord(dir, record) {
+	let small = 0;
+	for (const name of [
 		"state.json",
 		"ended-agents.json",
 		"log-error-index.json"
-	].reduce((sum, name) => {
+	]) {
 		const path = join(dir, name);
-		return sum + (existsSync(path) ? statSync(path).size : 0);
-	}, 0);
+		if (existsSync(path)) small += (await stat(path)).size;
+	}
 	for (let pass = 0; pass < 8; pass++) {
 		record.bytes.total = KINDS.reduce((sum, kind) => sum + record.bytes[kind], record.bytes.record);
 		const bytes = small + Buffer.byteLength(`${JSON.stringify(record)}\n`);
@@ -302,59 +474,70 @@ function writeRecord(dir, record) {
 	record.bytes.total = KINDS.reduce((sum, kind) => sum + record.bytes[kind], record.bytes.record);
 	const tmp = join(dir, `.archive-${randomUUID()}.tmp`);
 	try {
-		writeFileSync(tmp, `${JSON.stringify(record)}\n`, { mode: 384 });
-		renameSync(tmp, join(dir, "archive.json"));
+		await writeFile(tmp, `${JSON.stringify(record)}\n`, { mode: 384 });
+		await rename(tmp, join(dir, "archive.json"));
 	} finally {
-		rmSync(tmp, { force: true });
+		await rm(tmp, { force: true });
 	}
 	const now = /* @__PURE__ */ new Date();
-	utimesSync(archiveRoot(), now, now);
+	await utimes(archiveRoot(), now, now);
 }
-function removeRecord(id) {
+async function removeRecord(id) {
 	const dir = archiveDir(id);
 	if (!existsSync(dir)) return;
 	const removing = join(archiveRoot(), `.removing-${id}`);
-	renameSync(dir, removing);
-	rmSync(removing, {
+	await rename(dir, removing);
+	await rm(removing, {
 		recursive: true,
 		force: true
 	});
 }
-function sweepArchiveStaging(remove, waitMs = 0) {
+async function sweepArchiveStaging(remove, waitMs = 0, signal) {
+	signal?.throwIfAborted();
 	if (!existsSync(archiveRoot())) return [];
-	return withDirLock(archiveLock(), () => readdirSync(archiveRoot()).filter((name) => name.startsWith(".incoming-") && (!name.endsWith(".claims") || !existsSync(join(archiveRoot(), name.slice(0, -7)))) || name.startsWith(".removing-")).flatMap((name) => {
-		const path = join(archiveRoot(), name.endsWith(".claims") ? name.slice(0, -7) : name);
-		const root = `${path}.claims`;
-		const survey = name.startsWith(".incoming-") ? readClaimSet(root) : null;
-		const unresolved = survey?.unresolved[0];
-		const kept = Boolean(survey && (survey.live.length || survey.unresolved.length));
-		const entry = {
-			path,
-			kept,
-			reason: unresolved?.reason ?? (kept ? "live archive writer" : null),
-			removeCommand: unresolved ? claimRemoveCommand(root) : null
-		};
-		if (remove && !kept) {
-			if (!survey || clearFreeClaimSet({
-				root,
-				label: "archive staging"
-			}).status === "cleared") {
-				rmSync(path, {
-					recursive: true,
-					force: true
-				});
-				return [];
+	return withDirLockTransaction(archiveLock(), async () => {
+		const entries = [];
+		for (const name of await readdir(archiveRoot())) {
+			signal?.throwIfAborted();
+			if (!(name.startsWith(".incoming-") && (!name.endsWith(".claims") || !existsSync(join(archiveRoot(), name.slice(0, -7)))) || name.startsWith(".removing-"))) continue;
+			const path = join(archiveRoot(), name.endsWith(".claims") ? name.slice(0, -7) : name);
+			const root = `${path}.claims`;
+			const survey = name.startsWith(".incoming-") ? readClaimSet(root) : null;
+			const unresolved = survey?.unresolved[0];
+			const kept = Boolean(survey && (survey.live.length || survey.unresolved.length));
+			const entry = {
+				path,
+				kept,
+				reason: unresolved?.reason ?? (kept ? "live archive writer" : null),
+				removeCommand: unresolved ? claimRemoveCommand(root) : null
+			};
+			if (remove && !kept) {
+				if (!survey || clearFreeClaimSet({
+					root,
+					label: "archive staging"
+				}).status === "cleared") {
+					signal?.throwIfAborted();
+					await rm(path, {
+						recursive: true,
+						force: true
+					});
+					continue;
+				}
 			}
+			entries.push(entry);
 		}
-		return [entry];
-	}), { waitMs });
+		return entries;
+	}, {
+		waitMs,
+		signal
+	});
 }
 function stripPids(value) {
 	if (Array.isArray(value)) return value.map(stripPids);
 	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).filter(([key]) => !/pids?$/i.test(key)).map(([key, child]) => [key, stripPids(child)]));
 	return value;
 }
-function gitFacts(root) {
+async function gitFacts(root, operation) {
 	const empty = {
 		repository: null,
 		branch: null,
@@ -364,32 +547,55 @@ function gitFacts(root) {
 		pullRequest: null
 	};
 	if (!existsSync(root)) return cachedFacts(root) ?? empty;
-	const run = (args) => gitQuiet(root, args, { timeoutMs: 1e3 });
+	const execution = {
+		...childEnvironment(operation?.env ?? process.env),
+		signal: operation?.signal,
+		declareFor: operation,
+		cwd: operation?.cwd,
+		killSignal: "SIGKILL"
+	};
+	const run = async (args) => {
+		try {
+			const result = await gitAsync(root, args, {
+				...execution,
+				timeoutMs: 1e3
+			});
+			operation?.signal.throwIfAborted();
+			return result;
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError) throw error;
+			operation?.signal.throwIfAborted();
+			return null;
+		}
+	};
 	const common = gitCommonDirOnDisk(root);
-	const summary = run([
+	const summary = (await run([
 		"show",
 		"-s",
 		"--format=%H%n%s",
 		"HEAD"
-	])?.split("\n");
-	const location = run([
+	]))?.split("\n");
+	const location = (await run([
 		"rev-parse",
 		"--show-toplevel",
 		"--abbrev-ref",
 		"HEAD"
-	])?.split("\n");
+	]))?.split("\n");
 	const branch = location?.[1] && location[1] !== "HEAD" ? location[1] : null;
-	const defaultRef = run([
+	const defaultRef = await run([
 		"symbolic-ref",
 		"--quiet",
 		"refs/remotes/origin/HEAD"
 	]);
 	let merged = null;
 	if (defaultRef?.startsWith("refs/remotes/")) {
-		const state = mergeState(root, {
+		const state = await mergeStateAsync(root, {
 			ref: defaultRef,
 			name: defaultRef.slice(13)
-		}, { timeoutMs: 2e3 });
+		}, {
+			...execution,
+			timeoutMs: 2e3
+		});
 		merged = state.merged ? true : state.unknown ? null : false;
 	}
 	let prPath = root;
@@ -430,35 +636,48 @@ function cachedFacts(root) {
 	}
 	return null;
 }
-function archiveWorkspace(root, removedBy, state = readWorkspaceState(root)) {
-	writeArchive(root, removedBy, state);
+function archiveWarning(message, operation) {
+	if (operation) operation.output("stderr", `${message}\n`);
+	else console.error(message);
+}
+/** Publishes history once its first move starts; cancellation then skips retention and further cleanup. */
+async function archiveWorkspace(root, removedBy, state = readWorkspaceState(root), operation) {
+	operation?.signal.throwIfAborted();
+	await writeArchive(root, removedBy, state, operation);
+	operation?.signal.throwIfAborted();
 	try {
-		enforceArchiveRetention();
+		await enforceArchiveRetention(void 0, operation);
 	} catch (error) {
-		console.error(`could not enforce archive retention: ${String(error?.message ?? error).split("\n")[0]}`);
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
+		operation?.signal.throwIfAborted();
+		archiveWarning(`could not enforce archive retention: ${String(error?.message ?? error).split("\n")[0]}`, operation);
 	}
 }
-function writeArchive(root, removedBy, state) {
+async function writeArchive(root, removedBy, state, operation) {
+	const env = operation?.env ?? process.env;
 	let staging = null;
 	let claim;
 	try {
 		const dir = workspaceDir(root);
-		if (!existsSync(dir) || lstatSync(dir).isSymbolicLink()) return;
+		if (!existsSync(dir) || (await lstat(dir)).isSymbolicLink()) return;
 		if (existsSync(root)) root = realpathSync(root);
 		try {
-			sweepArchiveStaging(true, 5e3);
-		} catch {}
-		if (!enabled(root)) return;
-		const limits = archiveSettings();
+			await sweepArchiveStaging(true, 5e3, operation?.signal);
+		} catch {
+			operation?.signal.throwIfAborted();
+		}
+		if (!enabled(root, env)) return;
+		const limits = archiveSettings(env);
 		if (!limits.maxAgeDays || !limits.maxCount) return;
 		const logs = join(dir, "logs");
-		if (!existsSync(join(dir, "state.json")) && !Object.values(readBuildHistory(state)).some((entries) => entries?.length) && (!existsSync(logs) || readdirSync(logs).length === 0)) return;
-		const worktree = gitFacts(root);
-		mkdirSync(archiveRoot(), {
+		if (!existsSync(join(dir, "state.json")) && !Object.values(readBuildHistory(state)).some((entries) => entries?.length) && (!existsSync(logs) || (await readdir(logs)).length === 0)) return;
+		const worktree = await gitFacts(root, operation);
+		operation?.signal.throwIfAborted();
+		await mkdir(archiveRoot(), {
 			recursive: true,
 			mode: 448
 		});
-		chmodSync(archiveRoot(), 448);
+		await chmod(archiveRoot(), 448);
 		const token = randomUUID();
 		staging = join(archiveRoot(), `.incoming-${token}`);
 		const attempt = tryAcquireClaim({
@@ -471,49 +690,56 @@ function writeArchive(root, removedBy, state) {
 			releaseClaim(attempt.pending);
 			throw new Error("archive staging claim is held");
 		}
-		withDirLock(archiveLock(), () => {
-			mkdirSync(staging, { mode: 448 });
+		await withDirLockTransaction(archiveLock(), async () => {
+			operation?.signal.throwIfAborted();
+			let movedHistory = false;
+			const moveHistory = async (from, to) => {
+				if (!movedHistory) operation?.signal.throwIfAborted();
+				await rename(from, to);
+				movedHistory = true;
+			};
+			await mkdir(staging, { mode: 448 });
 			let at = Date.now();
 			const workspace = workspaceName(root);
 			while (existsSync(archiveDir(`${workspace}--${at}`))) at++;
 			const id = `${workspace}--${at}`;
 			if (state) {
 				const { supervisor: _supervisor, collectors: _collectors, warm: _warm, ...stable } = state;
-				writeFileSync(join(staging, "state.json"), `${JSON.stringify(stripPids(stable))}\n`, { mode: 384 });
+				await writeFile(join(staging, "state.json"), `${JSON.stringify(stripPids(stable))}\n`, { mode: 384 });
 			}
 			for (const name of ["ended-agents.json", "log-error-index.json"]) {
 				const data = readJsonObject(join(dir, name));
-				if (data) writeFileSync(join(staging, name), `${JSON.stringify(stripPids(data))}\n`, { mode: 384 });
+				if (data) await writeFile(join(staging, name), `${JSON.stringify(stripPids(data))}\n`, { mode: 384 });
 			}
-			const move = (kind) => {
+			const move = async (kind) => {
 				const from = join(dir, KIND_PATH[kind]);
 				if (!limits[`${kind}.maxAgeDays`] || !existsSync(from)) return;
 				const to = join(staging, KIND_PATH[kind]);
-				mkdirSync(join(to, ".."), {
+				await mkdir(join(to, ".."), {
 					recursive: true,
 					mode: 448
 				});
-				renameSync(from, to);
-				secureTree(to);
+				await moveHistory(from, to);
+				await secureTree(to);
 			};
-			move("logs");
-			move("agentActions");
+			await move("logs");
+			await move("agentActions");
 			const config = loadConfig();
-			if (limits["recordings.maxAgeDays"] && workspaceRecordingEnabled(root, config?.projects?.[root] ?? {}, config, process.env)) {
+			if (limits["recordings.maxAgeDays"] && workspaceRecordingEnabled(root, config?.projects?.[root] ?? {}, config, env)) {
 				const recordingDir = join(dir, "recordings");
-				if (existsSync(recordingDir) && lstatSync(recordingDir).isSymbolicLink()) throw new Error(`refusing symlink ${recordingDir}`);
-				for (const device of listRecordedDevices(recordingDir)) {
-					if (lstatSync(device.dir).isSymbolicLink()) throw new Error(`refusing symlink ${device.dir}`);
+				if (existsSync(recordingDir) && (await lstat(recordingDir)).isSymbolicLink()) throw new Error(`refusing symlink ${recordingDir}`);
+				for (const device of await listRecordedDevicesAsync(recordingDir, false, movedHistory ? void 0 : operation?.signal)) {
+					if ((await lstat(device.dir)).isSymbolicLink()) throw new Error(`refusing symlink ${device.dir}`);
 					const to = join(staging, "recordings", `${device.platform}-${device.slot}`);
 					for (const segment of device.segments.filter((entry) => !entry.open)) {
-						mkdirSync(to, {
+						await mkdir(to, {
 							recursive: true,
 							mode: 448
 						});
 						try {
-							if (lstatSync(segment.file).isSymbolicLink()) throw new Error(`refusing symlink ${segment.file}`);
-							renameSync(segment.file, join(to, basename(segment.file)));
-							chmodSync(join(to, basename(segment.file)), 384);
+							if ((await lstat(segment.file)).isSymbolicLink()) throw new Error(`refusing symlink ${segment.file}`);
+							await moveHistory(segment.file, join(to, basename(segment.file)));
+							await chmod(join(to, basename(segment.file)), 384);
 						} catch (error) {
 							if (error.code !== "ENOENT") throw error;
 						}
@@ -542,7 +768,7 @@ function writeArchive(root, removedBy, state) {
 				record: new Date(at + limits.maxAgeDays * DAY).toISOString()
 			};
 			for (const kind of KINDS) {
-				bytes[kind] = files(join(staging, KIND_PATH[kind])).reduce((sum, file) => sum + file.bytes, 0);
+				bytes[kind] = (await files(join(staging, KIND_PATH[kind]))).reduce((sum, file) => sum + file.bytes, 0);
 				if (bytes[kind]) expires[kind] = new Date(at + limits[`${kind}.maxAgeDays`] * DAY).toISOString();
 			}
 			const record = {
@@ -564,102 +790,144 @@ function writeArchive(root, removedBy, state) {
 				expires,
 				version: 1
 			};
-			writeRecord(staging, record);
-			renameSync(staging, archiveDir(id));
-		}, { waitMs: 3e4 });
+			if (!movedHistory) operation?.signal.throwIfAborted();
+			await writeRecord(staging, record);
+			await rename(staging, archiveDir(id));
+		}, {
+			waitMs: 3e4,
+			signal: operation?.signal
+		});
 		releaseClaim(claim);
 		claim = void 0;
 		staging = null;
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) throw error;
 		if (staging) try {
-			rmSync(staging, {
+			await rm(staging, {
 				recursive: true,
 				force: true
 			});
 		} catch {}
-		console.error(`could not archive: ${String(error?.message ?? error).split("\n")[0]}`);
+		operation?.signal.throwIfAborted();
+		archiveWarning(`could not archive: ${String(error?.message ?? error).split("\n")[0]}`, operation);
 	} finally {
 		releaseClaim(claim);
 	}
 }
-function removeKind(record, kind) {
-	rmSync(join(archiveDir(record.id), KIND_PATH[kind]), {
+async function removeKind(record, kind) {
+	await rm(join(archiveDir(record.id), KIND_PATH[kind]), {
 		recursive: true,
 		force: true
 	});
 	record.bytes[kind] = 0;
 	record.expires[kind] = null;
-	writeRecord(archiveDir(record.id), record);
+	await writeRecord(archiveDir(record.id), record);
 }
 function logRemovalOrder(path) {
 	return /\.ndjson\.\d+$/.test(path) ? 0 : /^build-.*\.ndjson$/.test(basename(path)) ? 1 : 2;
 }
-function enforceArchiveRetention(now = Date.now()) {
+async function enforceArchiveRetention(now = Date.now(), operation) {
+	const signal = operation?.signal;
+	const env = operation?.env ?? process.env;
+	signal?.throwIfAborted();
 	if (!existsSync(archiveRoot())) return;
 	let limits;
 	try {
-		limits = archiveSettings();
+		limits = archiveSettings(env);
 	} catch (error) {
-		console.error(`could not enforce archive retention: ${String(error.message).split("\n")[0]}`);
+		archiveWarning(`could not enforce archive retention: ${String(error.message).split("\n")[0]}`, operation);
 		return;
 	}
-	withDirLock(archiveLock(), () => {
-		const listed = readArchives().toReversed();
+	await withDirLockTransaction(archiveLock(), async () => {
+		const listed = (await readArchivesAsync(signal)).toReversed();
 		const records = listed.filter((record, index) => limits.maxAgeDays > 0 && now - Date.parse(record.removedAt) < limits.maxAgeDays * DAY && index >= listed.length - limits.maxCount);
-		for (const record of listed) if (!records.includes(record)) removeRecord(record.id);
-		const recordings = recordingEnabled(process.env, [loadConfig()]);
+		for (const record of listed) {
+			signal?.throwIfAborted();
+			if (!records.includes(record)) await removeRecord(record.id);
+		}
+		const recordings = recordingEnabled(env, [loadConfig()]);
 		for (const record of records) {
+			signal?.throwIfAborted();
 			for (const kind of [
 				"recordings",
 				"agentActions",
 				"logs"
 			]) {
+				signal?.throwIfAborted();
 				const age = limits[`${kind}.maxAgeDays`];
-				if (record.bytes[kind] && (!age || now - Date.parse(record.removedAt) >= age * DAY || kind === "recordings" && !recordings)) removeKind(record, kind);
+				if (record.bytes[kind] && (!age || now - Date.parse(record.removedAt) >= age * DAY || kind === "recordings" && !recordings)) await removeKind(record, kind);
 			}
 			const cap = limits["logs.maxMbPerWorkspace"] * 1024 ** 2;
 			if (record.bytes.logs > cap) {
-				const entries = files(join(archiveDir(record.id), "logs")).toSorted((a, b) => logRemovalOrder(a.path) - logRemovalOrder(b.path) || (logRemovalOrder(a.path) === 0 ? Number(b.path.split(".").at(-1)) - Number(a.path.split(".").at(-1)) : 0) || a.at - b.at);
-				for (const file of entries) {
-					if (record.bytes.logs <= cap) break;
-					rmSync(file.path);
-					record.bytes.logs = Math.max(0, record.bytes.logs - file.bytes);
+				const entries = (await files(join(archiveDir(record.id), "logs"), signal)).toSorted((a, b) => logRemovalOrder(a.path) - logRemovalOrder(b.path) || (logRemovalOrder(a.path) === 0 ? Number(b.path.split(".").at(-1)) - Number(a.path.split(".").at(-1)) : 0) || a.at - b.at);
+				let removed = false;
+				try {
+					for (const file of entries) {
+						signal?.throwIfAborted();
+						if (record.bytes.logs <= cap) break;
+						await rm(file.path);
+						record.bytes.logs = Math.max(0, record.bytes.logs - file.bytes);
+						removed = true;
+					}
+				} finally {
+					if (removed) {
+						if (!record.bytes.logs) record.expires.logs = null;
+						await writeRecord(archiveDir(record.id), record);
+					}
 				}
-				if (!record.bytes.logs) record.expires.logs = null;
-				writeRecord(archiveDir(record.id), record);
 			}
 		}
 		const totalCap = limits.maxTotalGb * 1024 ** 3;
 		const recordingCap = limits["recordings.maxTotalGb"] * 1024 ** 3;
-		for (const record of records) for (;;) {
-			const usage = archivedUsage(records);
-			const totalOver = usage.bytes > totalCap;
-			const recordingsOver = usage.byKind.recordings > recordingCap;
-			if (!totalOver && !recordingsOver) break;
-			const candidates = KINDS.filter((kind) => record.bytes[kind] > 0 && (totalOver || kind === "recordings")).toSorted((a, b) => record.bytes[b] - record.bytes[a]);
-			if (!candidates.length) break;
-			removeKind(record, candidates[0]);
+		for (const record of records) {
+			signal?.throwIfAborted();
+			for (;;) {
+				signal?.throwIfAborted();
+				const usage = archivedUsage(records);
+				const totalOver = usage.bytes > totalCap;
+				const recordingsOver = usage.byKind.recordings > recordingCap;
+				if (!totalOver && !recordingsOver) break;
+				const candidates = KINDS.filter((kind) => record.bytes[kind] > 0 && (totalOver || kind === "recordings")).toSorted((a, b) => record.bytes[b] - record.bytes[a]);
+				if (!candidates.length) break;
+				await removeKind(record, candidates[0]);
+			}
 		}
 		for (const record of records) {
+			signal?.throwIfAborted();
 			const before = JSON.stringify(record.expires);
 			for (const kind of KINDS) record.expires[kind] = record.bytes[kind] ? new Date(Date.parse(record.removedAt) + limits[`${kind}.maxAgeDays`] * DAY).toISOString() : null;
 			record.expires.record = new Date(Date.parse(record.removedAt) + limits.maxAgeDays * DAY).toISOString();
-			if (JSON.stringify(record.expires) !== before) writeRecord(archiveDir(record.id), record);
+			if (JSON.stringify(record.expires) !== before) await writeRecord(archiveDir(record.id), record);
 		}
-	}, { waitMs: 3e4 });
+	}, {
+		waitMs: 3e4,
+		signal
+	});
 }
-function deleteSelectedArchives(ids, kind) {
-	withDirLock(archiveLock(), () => {
-		for (const record of readArchives().filter((entry) => ids.includes(entry.id))) if (kind) removeKind(record, kind);
-		else removeRecord(record.id);
-	}, { waitMs: 3e4 });
+async function deleteSelectedArchives(ids, kind, signal) {
+	signal?.throwIfAborted();
+	await withDirLockTransaction(archiveLock(), async () => {
+		for (const record of (await readArchivesAsync(signal)).filter((entry) => ids.includes(entry.id))) {
+			signal?.throwIfAborted();
+			if (kind) await removeKind(record, kind);
+			else await removeRecord(record.id);
+		}
+	}, {
+		waitMs: 3e4,
+		signal
+	});
 }
 //#endregion
 //#region src/devices/reclaim.ts
-async function reapCollectors(root, { verify = verifyCollectorOwnership, collectors }) {
+function throwIfCleanupInterrupted(error, operation) {
+	if (error instanceof WorkspaceProcessCleanupError) throw error;
+	operation?.signal.throwIfAborted();
+}
+async function reapCollectors(root, { verify = verifyCollectorOwnership, collectors, operation }) {
 	const skippedDevices = [];
 	const failedDevices = [];
 	for (const [platform, record] of Object.entries(collectors)) {
+		operation?.signal.throwIfAborted();
 		const rec = record;
 		const pid = rec?.pid;
 		if (typeof pid !== "number" || pid <= 0 || pid === process.pid || !pidExists(pid)) continue;
@@ -683,7 +951,7 @@ async function reapCollectors(root, { verify = verifyCollectorOwnership, collect
 		}
 		try {
 			process.kill(pid, "SIGTERM");
-			if (await (0, process_identity_exports.waitForProcessExit)(rec, 5e3)) continue;
+			if (await (0, process_identity_exports.waitForProcessExit)(rec, 5e3, operation?.signal)) continue;
 		} catch (error) {
 			if (error.code === "ESRCH") continue;
 		}
@@ -700,7 +968,7 @@ async function reapCollectors(root, { verify = verifyCollectorOwnership, collect
 		failedDevices
 	};
 }
-function reclaimRemoteSession(root, { stopSession = defaultStopSession } = {}) {
+async function reclaimRemoteSession(root, { stopSession = defaultStopSession, operation } = {}) {
 	const sessionId = readRemoteSessionId(root);
 	if (!sessionId) return {
 		stopped: null,
@@ -708,8 +976,10 @@ function reclaimRemoteSession(root, { stopSession = defaultStopSession } = {}) {
 	};
 	let result;
 	try {
-		result = stopSession(root, sessionId);
+		result = await stopSession(root, sessionId, operation);
+		operation?.signal.throwIfAborted();
 	} catch (err) {
+		throwIfCleanupInterrupted(err, operation);
 		result = {
 			status: "failed",
 			reason: String(err?.message ?? err)
@@ -739,17 +1009,18 @@ function reclaimRemoteSession(root, { stopSession = defaultStopSession } = {}) {
 		}
 	};
 }
-function defaultStopSession(root, sessionId) {
+function defaultStopSession(root, sessionId, operation) {
 	return endRecordedSession({
 		root,
 		sessionId,
-		easBin: resolveEasCliBin(root)?.file ?? null
+		easBin: resolveEasCliBin(root)?.file ?? null,
+		operation
 	});
 }
-function defaultStopMetroTunnel(record) {
-	return stopTunnel(record);
+function defaultStopMetroTunnel(record, operation) {
+	return stopTunnel(record, { operation });
 }
-async function reclaimMetroTunnel(root, { stopMetroTunnel = defaultStopMetroTunnel } = {}) {
+async function reclaimMetroTunnel(root, { stopMetroTunnel = defaultStopMetroTunnel, operation } = {}) {
 	const record = readMetroTunnel(root);
 	if (record?.kind !== "managed") return {
 		stopped: null,
@@ -757,8 +1028,10 @@ async function reclaimMetroTunnel(root, { stopMetroTunnel = defaultStopMetroTunn
 	};
 	let result;
 	try {
-		result = await stopMetroTunnel(record);
+		result = await stopMetroTunnel(record, operation);
+		operation?.signal.throwIfAborted();
 	} catch (err) {
+		throwIfCleanupInterrupted(err, operation);
 		result = {
 			status: "failed",
 			reason: String(err?.message ?? err)
@@ -814,7 +1087,7 @@ function parkRequest(project, projectPath, slot, simslimManaged) {
 		cacheKey: lastBuildCacheKey(projectPath, "ios")
 	};
 }
-function reclaimOwnedDevices(project, projectPath, { park = false } = {}) {
+async function reclaimOwnedDevices(project, projectPath, { park = false, operation } = {}) {
 	const deletedDevices = [];
 	const parkedDevices = [];
 	const evictedDevices = [];
@@ -822,11 +1095,13 @@ function reclaimOwnedDevices(project, projectPath, { park = false } = {}) {
 	const skippedDevices = [];
 	const failedDevices = [];
 	for (const { slot, platforms } of projectDeviceSlots(project)) {
+		operation?.signal.throwIfAborted();
 		const ios = platforms.ios;
 		if (ios?.owned && ios.deviceUdid) {
 			const udid = ios.deviceUdid;
 			const label = ios.deviceName || udid;
-			const r = teardownOwnedIosSim(udid, {
+			const r = await teardownOwnedIosSim(udid, {
+				operation,
 				del: true,
 				label,
 				...park ? { park: parkRequest(project, projectPath, slot, Boolean(ios.simslimManaged)) } : {}
@@ -856,9 +1131,11 @@ function reclaimOwnedDevices(project, projectPath, { park = false } = {}) {
 			}
 		}
 		const android = platforms.android;
+		operation?.signal.throwIfAborted();
 		if (android?.owned && android.avdName) {
 			const bound = parkedMaxSetting("android");
-			const r = teardownOwnedAvd(android.avdName, {
+			const r = await teardownOwnedAvd(android.avdName, {
+				operation,
 				del: true,
 				owner: {
 					projectPath,
@@ -909,6 +1186,7 @@ async function reclaimProject(path, options = {}) {
 	const dir = workspaceDir(path);
 	const existed = existsSync(dir);
 	const run = await withIdleWorkspace(path, () => reclaimIdleProject(path, existed, options), {
+		operation: options.operation,
 		purpose: "workspace removal",
 		hosted: false,
 		supervisor: false,
@@ -939,10 +1217,52 @@ async function reclaimProject(path, options = {}) {
 		failedWorkspaceDirs: []
 	};
 }
-async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwnedDevices = false, parkOwnedDevices = false, preserveProjectRecord = false, stopSession = defaultStopSession, stopMetroTunnel = defaultStopMetroTunnel, releaseLeases = releaseWorkspaceLeases, verifyCollector = verifyCollectorOwnership, teardownBrowser = teardownOwnedBrowser, stopRequester = { by: "stim gc --delete" } }) {
-	await clearNamedPorts(path);
+function verifyAvdClaims(project, operation) {
+	for (const { platforms } of projectDeviceSlots(project)) {
+		operation?.signal.throwIfAborted();
+		if (platforms.android?.owned && platforms.android.avdName) (0, ownership_claim_exports.releaseClaim)(acquireAvdClaim(platforms.android.avdName));
+	}
+}
+async function removeWorkspaceOutput(path, dir, archive, state, operation) {
+	const stateDir = workspaceAgentDeviceDir(path);
+	if (!["none", "dead"].includes(agentDeviceDaemon(stateDir))) {
+		const exec = getExecutor();
+		try {
+			if (!exec.findExecutable("agent-device")) throw new Error("agent-device is not on PATH");
+			await runOperationFile(operation, exec, "agent-device", [
+				"daemon",
+				"stop",
+				"--state-dir",
+				stateDir,
+				"--clean"
+			], {
+				cwd: operation?.cwd,
+				timeoutMs: 2e4,
+				killSignal: "SIGKILL",
+				env: { AGENT_DEVICE_NO_UPDATE_NOTIFIER: "1" }
+			});
+		} catch (error) {
+			throwIfCleanupInterrupted(error, operation);
+			const message = `${phaseLine("agent-device", `daemon could not be stopped: ${error.message}; run agent-device daemon stop --state-dir "${stateDir}" --clean`)}\n`;
+			if (operation) operation.output("stderr", message);
+			else process.stderr.write(message);
+			throw error;
+		}
+	}
+	operation?.signal.throwIfAborted();
+	if (archive) await archiveWorkspace(path, archive.removedBy, state, operation);
+	await emptyWorkspaceDir(dir, operation?.signal);
+}
+async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwnedDevices = false, parkOwnedDevices = false, preserveProjectRecord = false, stopSession = defaultStopSession, stopMetroTunnel = defaultStopMetroTunnel, releaseLeases = releaseWorkspaceLeases, verifyCollector = verifyCollectorOwnership, teardownBrowser = teardownOwnedBrowser, stopRequester = { by: "stim gc --delete" }, operation }) {
+	const signal = operation?.signal;
+	signal?.throwIfAborted();
+	await clearNamedPorts(path, operation ? {
+		signal,
+		log: (line) => operation.output("stderr", `${line}\n`)
+	} : void 0);
+	signal?.throwIfAborted();
 	const project = getProject(path);
-	for (const { platforms } of projectDeviceSlots(project)) if (platforms.android?.owned && platforms.android.avdName) (0, ownership_claim_exports.releaseClaim)(acquireAvdClaim(platforms.android.avdName));
+	verifyAvdClaims(project, operation);
 	const dereferenced = describeDereferenced(project);
 	const initialState = readWorkspaceState$1(path);
 	let killedPid = null;
@@ -960,9 +1280,9 @@ async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwned
 	const orphanIdentity = supervisor.status === "stale" && typeof orphanServer.processToken === "string" ? (0, process_identity_exports.inspectProcessIdentity)(orphanServer) : null;
 	if (supervisor.status === "ours") {
 		requestDevServerStop(path, supervisor.processToken, stopRequester);
-		const signalled = killMetroTree(supervisor.pid, supervisor.processToken);
+		const signalled = await killMetroTreeAsync(supervisor.pid, supervisor.processToken, operation);
 		if (!signalled) withdrawDevServerStopRequest(path, supervisor.processToken);
-		if (signalled && await (0, process_identity_exports.waitForProcessExit)(supervisor, 1e4)) killedPid = supervisor.pid;
+		if (signalled && await (0, process_identity_exports.waitForProcessExit)(supervisor, 1e4, signal)) killedPid = supervisor.pid;
 		else {
 			skippedMetro = `could not confirm supervisor pid ${supervisor.pid} exited`;
 			supervisorHeld = true;
@@ -973,9 +1293,14 @@ async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwned
 	} else if (orphanIdentity === "same") {
 		let signalled = false;
 		try {
-			signalled = signalProcessTree(orphanServer.pid, "SIGTERM", { group: initialState?.supervisor?.mode === MODE_COMMAND });
-		} catch {}
-		if (signalled ? await (0, process_identity_exports.waitForProcessExit)(orphanServer, 1e4) : ["gone", "different"].includes((0, process_identity_exports.inspectProcessIdentity)(orphanServer))) killedPid = orphanServer.pid;
+			signalled = await signalProcessTreeAsync(orphanServer.pid, "SIGTERM", {
+				group: initialState?.supervisor?.mode === MODE_COMMAND,
+				operation
+			});
+		} catch (error) {
+			throwIfCleanupInterrupted(error, operation);
+		}
+		if (signalled ? await (0, process_identity_exports.waitForProcessExit)(orphanServer, 1e4, signal) : ["gone", "different"].includes((0, process_identity_exports.inspectProcessIdentity)(orphanServer))) killedPid = orphanServer.pid;
 		else {
 			skippedMetro = `could not confirm dev server pid ${orphanServer.pid} left by the supervisor exited`;
 			supervisorHeld = true;
@@ -988,9 +1313,15 @@ async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwned
 	}
 	const { skippedDevices: skippedCollectors, failedDevices: failedCollectors } = await reapCollectors(path, {
 		verify: verifyCollector,
-		collectors: initialState?.collectors ?? {}
+		collectors: initialState?.collectors ?? {},
+		operation
 	});
-	const browser = await teardownBrowser(path, { deleteProfile: true });
+	signal?.throwIfAborted();
+	const browser = await teardownBrowser(path, {
+		deleteProfile: true,
+		operation
+	});
+	signal?.throwIfAborted();
 	if (browser.status === "failed" || browser.status === "skipped") {
 		const entry = {
 			name: "owned Chrome",
@@ -1008,7 +1339,10 @@ async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwned
 		}
 	}
 	retainReplacementProcesses();
-	const { deletedDevices, parkedDevices, evictedDevices, poolNotes, skippedDevices, failedDevices } = deleteOwnedDevices && !supervisorHeld && failedCollectors.length === 0 ? reclaimOwnedDevices(project, path, { park: parkOwnedDevices }) : {
+	const { deletedDevices, parkedDevices, evictedDevices, poolNotes, skippedDevices, failedDevices } = deleteOwnedDevices && !supervisorHeld && failedCollectors.length === 0 ? await reclaimOwnedDevices(project, path, {
+		park: parkOwnedDevices,
+		operation
+	}) : {
 		deletedDevices: [],
 		parkedDevices: [],
 		evictedDevices: [],
@@ -1018,27 +1352,37 @@ async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwned
 	};
 	skippedDevices.push(...skippedCollectors);
 	failedDevices.push(...failedCollectors);
-	for (const platform of ["ios", "android"]) try {
-		await (platform === "ios" ? stopHostedIos : stopHostedAndroid)(path);
-	} catch (error) {
-		const failed = {
-			platform,
-			name: `hosted ${platform} device`,
-			reason: error.message
-		};
-		failedDevices.push(failed);
-		skippedDevices.push(failed);
+	for (const platform of ["ios", "android"]) {
+		signal?.throwIfAborted();
+		try {
+			await (platform === "ios" ? stopHostedIos : stopHostedAndroid)(path, void 0, signal);
+		} catch (error) {
+			throwIfCleanupInterrupted(error, operation);
+			const failed = {
+				platform,
+				name: `hosted ${platform} device`,
+				reason: error.message
+			};
+			failedDevices.push(failed);
+			skippedDevices.push(failed);
+		}
 	}
-	const remote = reclaimRemoteSession(path, { stopSession });
+	signal?.throwIfAborted();
+	const remote = await reclaimRemoteSession(path, {
+		stopSession,
+		operation
+	});
 	if (remote.failed) {
 		skippedDevices.push(remote.failed);
 		failedDevices.push(remote.failed);
 	}
 	if (macosAppPresent(path)) {
+		signal?.throwIfAborted();
 		const hosted = readMacosRecord(path)?.host;
 		try {
-			await stopMacosApp(path);
+			await stopMacosApp(path, operation);
 		} catch (error) {
+			throwIfCleanupInterrupted(error, operation);
 			const failed = {
 				name: hosted ? `hosted macOS session ${hosted.session} on ${hosted.machine}` : "macOS app",
 				reason: String(error?.message ?? error)
@@ -1047,52 +1391,39 @@ async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwned
 			failedDevices.push(failed);
 		}
 	}
-	const tunnel = await reclaimMetroTunnel(path, { stopMetroTunnel });
+	signal?.throwIfAborted();
+	const tunnel = await reclaimMetroTunnel(path, {
+		stopMetroTunnel,
+		operation
+	});
 	if (tunnel.failed) {
 		skippedDevices.push(tunnel.failed);
 		failedDevices.push(tunnel.failed);
 	}
 	let releasedLeases = [];
+	signal?.throwIfAborted();
 	try {
 		releasedLeases = releaseLeases(path);
-	} catch {
+	} catch (error) {
+		throwIfCleanupInterrupted(error, operation);
 		releasedLeases = [];
 	}
 	retainReplacementProcesses();
 	const removedWorkspaceDirs = [];
 	const failedWorkspaceDirs = [];
 	if (failedDevices.length === 0 && !supervisorHeld) {
+		signal?.throwIfAborted();
 		const dir = workspaceDir(path);
 		if (existsSync(dir)) try {
-			const stateDir = workspaceAgentDeviceDir(path);
-			if (!["none", "dead"].includes(agentDeviceDaemon(stateDir))) {
-				const exec = getExecutor();
-				try {
-					if (!exec.findExecutable("agent-device")) throw new Error("agent-device is not on PATH");
-					exec.runFile("agent-device", [
-						"daemon",
-						"stop",
-						"--state-dir",
-						stateDir,
-						"--clean"
-					], {
-						timeoutMs: 2e4,
-						killSignal: "SIGKILL",
-						env: { AGENT_DEVICE_NO_UPDATE_NOTIFIER: "1" }
-					});
-				} catch (error) {
-					process.stderr.write(`${phaseLine("agent-device", `daemon could not be stopped: ${error.message}; run agent-device daemon stop --state-dir "${stateDir}" --clean`)}\n`);
-					throw error;
-				}
-			}
-			if (archive) archiveWorkspace(path, archive.removedBy, initialState);
-			emptyWorkspaceDir(dir);
+			await removeWorkspaceOutput(path, dir, archive, initialState, operation);
 			if (workspaceExisted) removedWorkspaceDirs.push(dir);
-		} catch {
+		} catch (error) {
+			throwIfCleanupInterrupted(error, operation);
 			failedWorkspaceDirs.push(dir);
 		}
 	}
 	const keptEntry = supervisorHeld || failedDevices.length > 0 || failedWorkspaceDirs.length > 0;
+	signal?.throwIfAborted();
 	if (project && !keptEntry && !preserveProjectRecord) removeProject(path);
 	return {
 		path,
@@ -1117,11 +1448,14 @@ async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwned
 //#endregion
 //#region src/workspace/service-guard.ts
 const SERVICE_IN_USE = { code: "STIM_WORKTREE_SERVICE" };
+function inside(folder, canonical) {
+	return (value) => typeof value === "string" && value.startsWith("/") && isPathPrefix(folder, canonical(value));
+}
 function serviceUseOf(plist, file, folder, canonical) {
 	if (typeof plist !== "object" || plist === null) return null;
 	const job = plist;
 	if (typeof job.StimService !== "object" || job.StimService === null || !Array.isArray(job.ProgramArguments)) return null;
-	const argument = job.ProgramArguments.find((value) => typeof value === "string" && value.startsWith("/") && isPathPrefix(folder, canonical(value)));
+	const argument = job.ProgramArguments.find(inside(folder, canonical));
 	if (argument === void 0) return null;
 	return {
 		label: typeof job.Label === "string" ? job.Label : file,
@@ -1129,9 +1463,61 @@ function serviceUseOf(plist, file, folder, canonical) {
 		argument
 	};
 }
-/** The first installed stim-server service that runs from inside `folder`, or null. macOS only. */
-function serviceRunningFrom(folder, canonical, agentsDir = join(homedir(), "Library", "LaunchAgents")) {
-	if (process.platform !== "darwin") return null;
+/** The launch argument inside `folder` of a unit `stim-server service install` wrote, or null when it has none. */
+function unitArgument(text, folder, canonical) {
+	const lines = unitLines(text);
+	if (!lines.some((line) => line.section === "X-Stim" && line.key === "Managed" && line.value === "true")) return null;
+	const exec = lines.findLast((line) => line.section === "Service" && line.key === "ExecStart")?.value;
+	const args = exec === void 0 ? null : unitWords(exec, true);
+	if (!args) return void 0;
+	return args.find(inside(folder, canonical)) ?? null;
+}
+function unitRunningFrom(folder, canonical, unitsDir) {
+	let names;
+	try {
+		names = readdirSync(unitsDir).filter((name) => name.endsWith(".service"));
+	} catch (error) {
+		return error instanceof Error && "code" in error && error.code === "ENOENT" ? null : {
+			label: "unknown",
+			plist: unitsDir,
+			argument: null
+		};
+	}
+	for (const name of names) {
+		const file = join(unitsDir, name);
+		const label = name.replace(/\.service$/, "");
+		let text;
+		try {
+			text = readFileSync(file, "utf8");
+		} catch {
+			return {
+				label,
+				plist: file,
+				argument: null
+			};
+		}
+		if (!text.includes("[X-Stim]")) continue;
+		const argument = unitArgument(text, folder, canonical);
+		if (argument === void 0) return {
+			label,
+			plist: file,
+			argument: null
+		};
+		if (argument) return {
+			label,
+			plist: file,
+			argument
+		};
+	}
+	return null;
+}
+/**
+* The first installed stim-server service that runs from inside `folder`, or null: a LaunchAgent on macOS, a systemd
+* user unit on Linux. A service file that cannot be read counts as one, with a null `argument`.
+*/
+function serviceRunningFrom(folder, canonical, agentsDir = join(homedir(), "Library", "LaunchAgents"), unitsDir = join(homedir(), ".config", "systemd", "user"), platform = process.platform) {
+	if (platform === "linux") return unitRunningFrom(folder, canonical, unitsDir);
+	if (platform !== "darwin") return null;
 	let names;
 	try {
 		names = readdirSync(agentsDir).filter((name) => name.endsWith(".plist"));
@@ -1206,7 +1592,7 @@ function warmCommand(phase) {
 function asHolder(holder) {
 	return {
 		pid: holder.owner.pid,
-		phase: holder.mode === "exclusive" ? "refresh" : "copy"
+		phase: holder.details.phase === "copy" ? "copy" : holder.mode === "exclusive" ? "refresh" : "copy"
 	};
 }
 function waitingLine(holder, elapsedMs) {
@@ -1292,7 +1678,7 @@ function timeoutError(holder, elapsedMs, root) {
 	error.code = "STIM_LOCK_TIMEOUT";
 	return error;
 }
-async function acquireWarmClaim({ repositoryRoot, phase, mode = phase === "refresh" ? "exclusive" : "shared", now = Date.now, sleep = defaultSleep, pollMs = WARM_CLAIM_POLL_MS, progressMs = WARM_CLAIM_PROGRESS_MS, ceilingMs = WARM_CLAIM_CEILING_MS, out = () => {} }) {
+async function acquireWarmClaim({ signal, declareSpawnsFor, repositoryRoot, phase, mode = phase === "refresh" ? "exclusive" : "shared", now = Date.now, sleep = (ms) => setTimeout$1(ms, void 0, { signal }), pollMs = WARM_CLAIM_POLL_MS, progressMs = WARM_CLAIM_PROGRESS_MS, ceilingMs = WARM_CLAIM_CEILING_MS, out = () => {} }) {
 	const root = warmClaimPath(repositoryRoot);
 	const started = now();
 	let lastProgress = started;
@@ -1300,26 +1686,31 @@ async function acquireWarmClaim({ repositoryRoot, phase, mode = phase === "refre
 	let pending = null;
 	try {
 		for (;;) {
+			signal?.throwIfAborted();
 			const attempt = pending ? (0, ownership_claim_exports.settleClaim)(pending) : (0, ownership_claim_exports.tryAcquireClaim)({
 				root,
 				mode,
-				label: WARM_CLAIM_LABEL
+				label: WARM_CLAIM_LABEL,
+				details: { phase }
 			});
 			const acquired = attempt.acquired;
 			if (acquired) {
+				if (declareSpawnsFor) declareSpawnsOn(declareSpawnsFor, acquired);
 				const installer = installerClaim(acquired, {
 					now,
 					progressMs,
 					out
 				});
 				return {
+					claim: acquired,
 					wait: {
 						waitedMs: now() - started,
 						holder: waitedOn
 					},
 					installer,
-					release: () => {
-						if (installer.holding()) return;
+					release: (retained = false) => {
+						if (declareSpawnsFor) stopDeclaringSpawnsOn(declareSpawnsFor, acquired);
+						if (retained || installer.holding()) return;
 						(0, ownership_claim_exports.releaseClaim)(acquired);
 					}
 				};
@@ -1348,10 +1739,14 @@ async function acquireWarmClaim({ repositoryRoot, phase, mode = phase === "refre
 }
 async function withWarmClaim(options, fn) {
 	const { release, ...hold } = await acquireWarmClaim(options);
+	let retained = false;
 	try {
 		return await fn(hold);
+	} catch (cause) {
+		retained = cause instanceof WorkspaceProcessCleanupError && cause.claims.includes(hold.claim);
+		throw cause;
 	} finally {
-		release();
+		release(retained);
 	}
 }
 //#endregion
@@ -1880,7 +2275,7 @@ function dependencyInstallCommand(target, dir = ".") {
 	else if (existsSync$1(resolve$1(installRoot, "package-lock.json"))) command = "npm ci";
 	return `cd '${installRoot.replaceAll("'", "'\\''")}' && ${command}`;
 }
-function relocateCarriedPods(root, target, copied) {
+function relocateCarriedPods(root, target, copied, out) {
 	const canRelocate = depsOutOfSync(root, target, copied).length === 0;
 	for (const rel of copied) {
 		if (rel !== "Pods" && !rel.endsWith("/Pods")) continue;
@@ -1893,41 +2288,40 @@ function relocateCarriedPods(root, target, copied) {
 				targetRoot: target,
 				canRelocate
 			});
-			if (result.ok) console.error(chalk.dim(phaseLine("carry", result.pods.length > 0 ? `moved ${rel} to this checkout's path; ${result.pods.join(", ")} checksum depends on the checkout path, so pod install is not needed` : `moved ${rel} to this checkout's path; the locks match, so pod install is not needed`)));
-			else if (result.withheld) console.error(chalk.yellow(phaseLine("carry", `${rel} names the source checkout's path; removed ${rel}/Manifest.lock so pod install runs`)));
+			if (result.ok) out(chalk.dim(phaseLine("carry", result.pods.length > 0 ? `moved ${rel} to this checkout's path; ${result.pods.join(", ")} checksum depends on the checkout path, so pod install is not needed` : `moved ${rel} to this checkout's path; the locks match, so pod install is not needed`)));
+			else if (result.withheld) out(chalk.yellow(phaseLine("carry", `${rel} names the source checkout's path; removed ${rel}/Manifest.lock so pod install runs`)));
 		} catch (error) {
-			console.error(chalk.yellow(phaseLine("carry", `could not move ${rel} to this checkout's path: ${error.message}. pod install will run`)));
+			out(chalk.yellow(phaseLine("carry", `could not move ${rel} to this checkout's path: ${error.message}. pod install will run`)));
 		}
 	}
 }
-function reportCarriedStateHealth(root, target, copied) {
+function reportCarriedStateHealth(root, target, copied, out) {
 	const outOfSync = depsOutOfSync(root, target, copied);
 	for (const d of outOfSync.filter((dependency) => dependency.reason === "installed")) {
 		const where = d.dir === "." ? d.lockfile : `${d.dir}/${d.lockfile}`;
 		const modules = d.dir === "." ? "node_modules" : `${d.dir}/node_modules`;
-		console.error(chalk.yellow(phaseLine("carry", `carried ${modules} was installed from a different ${d.lockfile} than the ${where} on disk here. node_modules is gitignored and cloned from the source checkout; ${d.lockfile} is tracked, so the two can disagree. Run \`${dependencyInstallCommand(target, d.dir)}\` before building, or pod install and native builds see the wrong package versions.`)));
+		out(chalk.yellow(phaseLine("carry", `carried ${modules} was installed from a different ${d.lockfile} than the ${where} on disk here. node_modules is gitignored and cloned from the source checkout; ${d.lockfile} is tracked, so the two can disagree. Run \`${dependencyInstallCommand(target, d.dir)}\` before building, or pod install and native builds see the wrong package versions.`)));
 	}
 	const staleDeps = outOfSync.filter((dependency) => dependency.reason === "lockfile");
 	if (staleDeps.length) {
 		const manifests = staleDeps.map((d) => d.dir === "." ? d.lockfile : `${d.dir}/${d.lockfile}`).join(", ");
 		const remedies = [...new Set(staleDeps.map((dependency) => dependencyInstallCommand(target, dependency.dir)))];
-		console.error(chalk.yellow(phaseLine("carry", `carried dependencies may be stale: they do not match ${manifests}. Run ${remedies.map((command) => `\`${command}\``).join(" and ")} before building.`)));
+		out(chalk.yellow(phaseLine("carry", `carried dependencies may be stale: they do not match ${manifests}. Run ${remedies.map((command) => `\`${command}\``).join(" and ")} before building.`)));
 	}
 	for (const p of podsOutOfSync(target, copied)) {
 		const where = p.dir === "." ? "Podfile.lock" : `${p.dir}/Podfile.lock`;
 		const pod = podInstallCommand(p.dir === "." ? target : resolve$1(target, p.dir, ".."));
-		console.error(chalk.yellow(phaseLine("carry", p.reason === "missing" ? `carried ${p.dir === "." ? "Pods" : `${p.dir}/Pods`} but there is no ${where}. Run \`${pod}\` before building.` : `carried ${p.dir === "." ? "Pods" : `${p.dir}/Pods`} does not match the ${where} on disk here. Pods are gitignored and cloned; Podfile.lock is tracked, so the two can disagree. Run \`${pod}\` before building, or xcodebuild fails with "sandbox is not in sync" only after every pod has compiled.`)));
+		out(chalk.yellow(phaseLine("carry", p.reason === "missing" ? `carried ${p.dir === "." ? "Pods" : `${p.dir}/Pods`} but there is no ${where}. Run \`${pod}\` before building.` : `carried ${p.dir === "." ? "Pods" : `${p.dir}/Pods`} does not match the ${where} on disk here. Pods are gitignored and cloned; Podfile.lock is tracked, so the two can disagree. Run \`${pod}\` before building, or xcodebuild fails with "sandbox is not in sync" only after every pod has compiled.`)));
 	}
 }
-function reportRefreshFailure(failure) {
-	console.error(chalk.red(failure.message));
-	for (const line of failure.lines) console.error(chalk.dim(`  ${line}`));
-	if (failure.remedy) console.error(chalk.dim(failure.remedy));
-	console.error(chalk.red(`failed: ${failure.code}`));
-	process.exitCode = 1;
+function reportRefreshFailure(failure, out) {
+	out(chalk.red(failure.message));
+	for (const line of failure.lines) out(chalk.dim(`  ${line}`));
+	if (failure.remedy) out(chalk.dim(failure.remedy));
+	out(chalk.red(`failed: ${failure.code}`));
 }
-function mainCheckoutAppDir(root, target) {
-	const app = findProjectRoot(process.cwd());
+function mainCheckoutAppDir(root, target, cwd) {
+	const app = findProjectRoot$1(cwd);
 	if (!app) return root;
 	const rel = relative$1(target, app);
 	if (!rel || rel.startsWith("..") || isAbsolute$1(rel)) return root;
@@ -1939,7 +2333,7 @@ function mainCheckoutAppDir(root, target) {
 * root can declare react-native without being the app.
 */
 function warmedWorkspace(root, target, cwd) {
-	const nearest = findProjectRoot(cwd);
+	const nearest = findProjectRoot$1(cwd);
 	const app = nearest && isPathPrefix(target, nearest) && isMobileProject(nearest) ? nearest : null;
 	if (app && app !== target) return app;
 	const apps = /* @__PURE__ */ new Set();
@@ -1951,150 +2345,204 @@ function warmedWorkspace(root, target, cwd) {
 	}
 	return apps.size === 1 ? [...apps][0] : app;
 }
-function registerWarmedWorkspace(workspace) {
+function registerWarmedWorkspace(workspace, out) {
 	try {
 		if (!getProject(workspace)) upsertProject(workspace, {});
 	} catch (error) {
-		console.error(chalk.yellow(`Could not register ${workspace} for status: ${error?.message || String(error)}`));
+		out(chalk.yellow(`Could not register ${workspace} for status: ${error?.message || String(error)}`));
 	}
 }
 function registerWarm(worktree) {
 	worktree.command("warm").description("Copy missing ignored paths from the source checkout into the current linked worktree.").option("--refresh", "Before copying, fast-forward the source checkout to its upstream and install what the new commits moved.").action(async (opts) => {
-		let progress = null;
-		let workspace = null;
-		try {
-			const { root, target, common } = warmWorktreePaths(process.cwd());
-			const app = findProjectRoot(process.cwd());
-			if (app) recordWorkspaceUse(app);
-			workspace = warmedWorkspace(root, target, process.cwd());
-			if (workspace && workspace !== app) recordWorkspaceUse(workspace);
-			if (!workspace) console.error(chalk.dim(phaseLine("project", "no single app to register here; run warm from the app directory to list it in status while it warms")));
-			else {
-				registerWarmedWorkspace(workspace);
-				progress = startWarmProgress(workspace, opts.refresh ? "refresh" : "copy", { note: (line) => console.error(chalk.yellow(line)) });
-			}
-			const readSettings = () => {
-				const settings = resolveSettings({
-					gitCommonDir: common,
-					repoRoot: root
-				});
-				const shapeErrors = settingShapeErrors(settings);
-				if (shapeErrors.length) {
-					for (const message of shapeErrors) console.error(chalk.red(message));
-					console.error(chalk.dim(SETTING_SHAPE_REMEDY));
-					return null;
-				}
-				for (const key of unknownSettingKeys(settings)) console.error(chalk.yellow(`Warning: setting "${key}" is not read by Stim and will be ignored.`));
-				return settings;
-			};
-			const copy = (wait) => {
-				progress?.step("copy");
-				if (wait?.holder) console.error(warmClaimAcquiredLine(wait));
-				const incomplete = incompleteInstallRefusal(root, mainCheckoutAppDir(root, target));
-				if (incomplete) {
-					reportRefreshFailure(incomplete);
-					return;
-				}
-				const settings = readSettings();
-				if (!settings) {
-					process.exitCode = 1;
-					return;
-				}
-				const excluded = readWorktreeExclude(root);
-				const patterns = excluded?.length ? excluded : settings.worktree?.exclude || [];
-				const result = cloneIgnoredEntries({
-					root,
-					target,
-					patterns
+		const { value, interrupted } = await runProcessOperation(process.cwd(), async (operation) => {
+			try {
+				return await warmWorktreeTarget({
+					cwd: operation.cwd,
+					refresh: opts.refresh,
+					operation
 				});
-				for (const entry of result.skipped) console.error(chalk.dim(phaseLine("carry", `kept ${entry.file} (${entry.reason})`)));
-				for (const entry of result.failed) console.error(chalk.yellow(phaseLine("carry", `could not copy ${entry.file}: ${entry.error}`)));
-				if (result.copied.length) {
-					console.error(chalk.dim(phaseLine("carry", `copied ${carriedFileList(result.copied)} from ${root}`)));
-					relocateCarriedPods(root, target, result.copied);
-					reportCarriedStateHealth(root, target, result.copied);
+			} catch (error) {
+				if (!operation.signal.aborted || error instanceof WorkspaceProcessCleanupError) {
+					const code = error?.code;
+					console.error(chalk.red(`Could not warm this worktree: ${error.message}`));
+					const claim = (0, ownership_claim_exports.claimFailure)(error, `stim worktree warm${opts.refresh ? " --refresh" : ""}`);
+					if (claim) console.error(chalk.dim(claim.remedy));
+					if (typeof code === "string" && code.startsWith("STIM_")) console.error(chalk.red(`failed: ${code}`));
 				}
-				console.error(phaseLine("carry", `${result.failed.length ? "incomplete" : "complete"}: ${result.copied.length} ignored entries copied, ${result.skipped.length} kept, ${result.failed.length} failed`));
-				if (result.failed.length) process.exitCode = 1;
-			};
-			if (opts.refresh) {
-				const inspect = await acquireWarmClaim({
-					repositoryRoot: root,
-					phase: "refresh",
-					mode: "shared",
-					out: console.error
-				});
-				let mutation;
-				try {
+				return { exitCode: 1 };
+			}
+		});
+		if (interrupted !== null) process.exitCode = interrupted;
+		else if (value.exitCode) process.exitCode = 1;
+	});
+}
+async function warmWorktreeTarget(opts) {
+	let exitCode = 0;
+	const operation = opts.operation;
+	const out = (line) => operation.output("stderr", `${line}\n`);
+	let progress = null;
+	let workspace = null;
+	try {
+		const { root, target, common } = await warmWorktreePaths(opts.cwd, operation);
+		operation.signal.throwIfAborted();
+		const app = findProjectRoot$1(opts.cwd);
+		workspace = warmedWorkspace(root, target, opts.cwd);
+		const scope = /* @__PURE__ */ new Set([
+			...reclaimKeys(target),
+			...app ? [app] : [],
+			...workspace ? [workspace] : []
+		]);
+		for (const key of scope) opts.beforeWarm?.(nativeCanonicalPath(key));
+		if (app) recordWorkspaceUse(app, /* @__PURE__ */ new Date(), operation.env, opts.cwd);
+		if (workspace && workspace !== app) recordWorkspaceUse(workspace, /* @__PURE__ */ new Date(), operation.env, opts.cwd);
+		if (!workspace) out(chalk.dim(phaseLine("project", "no single app to register here; run warm from the app directory to list it in status while it warms")));
+		else {
+			registerWarmedWorkspace(workspace, out);
+			progress = startWarmProgress(workspace, opts.refresh ? "refresh" : "copy", { note: (line) => out(chalk.yellow(line)) });
+		}
+		const readSettings = () => {
+			const settings = resolveSettings({
+				gitCommonDir: common,
+				repoRoot: root
+			});
+			const shapeErrors = settingShapeErrors(settings);
+			if (shapeErrors.length) {
+				for (const message of shapeErrors) out(chalk.red(message));
+				out(chalk.dim(SETTING_SHAPE_REMEDY));
+				return null;
+			}
+			for (const key of unknownSettingKeys(settings)) out(chalk.yellow(`Warning: setting "${key}" is not read by Stim and will be ignored.`));
+			return settings;
+		};
+		const copy = async (wait) => {
+			const state = operationState(operation);
+			const wasDraining = state.draining;
+			state.draining = true;
+			try {
+				await withWarmClaim({
+					repositoryRoot: target,
+					phase: "copy",
+					mode: "exclusive",
+					out,
+					signal: operation.signal,
+					declareSpawnsFor: operation
+				}, async (hold) => {
+					if (hold.wait.holder) out(warmClaimAcquiredLine(hold.wait));
+					operation.signal.throwIfAborted();
+					progress?.step("copy");
+					if (wait?.holder) out(warmClaimAcquiredLine(wait));
+					const incomplete = incompleteInstallRefusal(root, mainCheckoutAppDir(root, target, opts.cwd));
+					if (incomplete) {
+						reportRefreshFailure(incomplete, out);
+						exitCode = 1;
+						return;
+					}
 					const settings = readSettings();
 					if (!settings) {
-						process.exitCode = 1;
+						exitCode = 1;
 						return;
 					}
-					const lines = [];
-					const result = await refreshMainCheckout({
+					const excluded = readWorktreeExclude(root);
+					const patterns = excluded?.length ? excluded : settings.worktree?.exclude || [];
+					const result = await cloneIgnoredEntries({
 						root,
-						appDir: mainCheckoutAppDir(root, target),
-						settings,
-						iosProject: appIosProjectDir(mainCheckoutAppDir(root, target)),
-						emit: (line) => lines.push(line),
-						inspectOnly: true
+						target,
+						patterns,
+						operation
 					});
-					if (!result || !("mutation" in result)) {
-						console.error(warmClaimAcquiredLine(inspect.wait, result ? "shared" : "shared (seed current)"));
-						for (const line of lines) console.error(line);
-						if (result) reportRefreshFailure(result);
-						else copy(null);
-						return;
+					for (const entry of result.skipped) out(chalk.dim(phaseLine("carry", `kept ${entry.file} (${entry.reason})`)));
+					for (const entry of result.failed) out(chalk.yellow(phaseLine("carry", `could not copy ${entry.file}: ${entry.error}`)));
+					if (result.copied.length) {
+						out(chalk.dim(phaseLine("carry", `copied ${carriedFileList(result.copied)} from ${root}`)));
+						relocateCarriedPods(root, target, result.copied, out);
+						reportCarriedStateHealth(root, target, result.copied, out);
 					}
-					mutation = result.mutation;
-				} finally {
-					inspect.release();
+					out(phaseLine("carry", `${result.failed.length ? "incomplete" : "complete"}: ${result.copied.length} ignored entries copied, ${result.skipped.length} kept, ${result.failed.length} failed`));
+					if (result.failed.length) exitCode = 1;
+				});
+			} finally {
+				state.draining = wasDraining;
+			}
+		};
+		if (opts.refresh) {
+			const mutation = await withWarmClaim({
+				repositoryRoot: root,
+				phase: "refresh",
+				mode: "shared",
+				signal: operation.signal,
+				declareSpawnsFor: operation,
+				out
+			}, async (hold) => {
+				const settings = readSettings();
+				if (!settings) {
+					exitCode = 1;
+					return null;
 				}
-				const failure = await withWarmClaim({
-					repositoryRoot: root,
-					phase: "refresh",
-					out: console.error
-				}, async (hold) => {
-					console.error(warmClaimAcquiredLine(hold.wait, `exclusive (${mutation})`));
-					const settings = readSettings();
-					if (!settings) {
-						process.exitCode = 1;
-						return null;
-					}
-					return refreshMainCheckout({
-						root,
-						appDir: mainCheckoutAppDir(root, target),
-						settings,
-						iosProject: appIosProjectDir(mainCheckoutAppDir(root, target)),
-						emit: (line) => console.error(line),
-						installer: hold.installer
-					});
+				const lines = [];
+				const result = await refreshMainCheckout({
+					root,
+					appDir: mainCheckoutAppDir(root, target, opts.cwd),
+					settings,
+					iosProject: appIosProjectDir(mainCheckoutAppDir(root, target, opts.cwd)),
+					emit: (line) => lines.push(line),
+					inspectOnly: true
 				});
-				if (failure) {
-					reportRefreshFailure(failure);
-					return;
+				if (!result || !("mutation" in result)) {
+					out(warmClaimAcquiredLine(hold.wait, result ? "shared" : "shared (seed current)"));
+					for (const line of lines) out(line);
+					if (result) {
+						reportRefreshFailure(result, out);
+						exitCode = 1;
+					} else await copy(null);
+					return null;
 				}
-				if (process.exitCode) return;
-			}
-			await withWarmClaim({
+				return result.mutation;
+			});
+			if (mutation === null) return { exitCode };
+			const failure = await withWarmClaim({
 				repositoryRoot: root,
-				phase: "copy",
-				out: console.error
-			}, (hold) => copy(hold.wait));
-		} catch (error) {
-			const code = error?.code;
-			console.error(chalk.red(`Could not warm this worktree: ${error.message}`));
-			const claim = (0, ownership_claim_exports.claimFailure)(error, `stim worktree warm${opts.refresh ? " --refresh" : ""}`);
-			if (claim) console.error(chalk.dim(claim.remedy));
-			if (typeof code === "string" && code.startsWith("STIM_")) console.error(chalk.red(`failed: ${code}`));
-			process.exitCode = 1;
-		} finally {
-			progress?.finish(!process.exitCode);
-			const links = workspace && !process.exitCode ? workspaceLinks(workspace) : void 0;
-			if (links) console.error(chalk.dim(workspaceLinkLine(links)));
+				phase: "refresh",
+				out,
+				signal: operation.signal
+			}, async (hold) => {
+				out(warmClaimAcquiredLine(hold.wait, `exclusive (${mutation})`));
+				const settings = readSettings();
+				if (!settings) {
+					exitCode = 1;
+					return null;
+				}
+				return refreshMainCheckout({
+					root,
+					appDir: mainCheckoutAppDir(root, target, opts.cwd),
+					settings,
+					iosProject: appIosProjectDir(mainCheckoutAppDir(root, target, opts.cwd)),
+					emit: (line) => out(line),
+					installer: hold.installer
+				});
+			});
+			if (failure) {
+				reportRefreshFailure(failure, out);
+				exitCode = 1;
+				return { exitCode };
+			}
+			if (exitCode) return { exitCode };
 		}
-	});
+		await withWarmClaim({
+			repositoryRoot: root,
+			phase: "copy",
+			out,
+			signal: operation.signal,
+			declareSpawnsFor: operation
+		}, (hold) => copy(hold.wait));
+	} catch (error) {
+		exitCode = 1;
+		throw error;
+	} finally {
+		progress?.finish(!exitCode && !operation.signal.aborted);
+		const links = workspace && !exitCode && !operation.signal.aborted ? await workspaceLinks(workspace) : void 0;
+		if (links) out(chalk.dim(workspaceLinkLine(links)));
+	}
+	return { exitCode };
 }
 function carriedFileList(files) {
 	const shown = files.slice(0, 3).join(", ");
@@ -2180,6 +2628,11 @@ function nativeCanonicalPath(path) {
 		missing.unshift(basename$1(existing));
 	}
 }
+/** Other worktrees git lists inside `path`, which removing `path` would delete with it. */
+function nestedWorktrees(entries, path) {
+	const root = nativeCanonicalPath(path);
+	return entries.filter((candidate) => !candidate.bare && nativeCanonicalPath(candidate.path) !== root).filter((candidate) => isPathPrefix(root, nativeCanonicalPath(candidate.path))).map((candidate) => candidate.path);
+}
 function matchWorktreeEntry(entries, path) {
 	let best = null;
 	const target = nativeCanonicalPath(path);
@@ -2239,12 +2692,16 @@ function reclaimKeys(rootPath) {
 	}
 	return [...keys].toSorted();
 }
-async function withReclaimLocks(rootPath, fn) {
+async function withReclaimLocks(rootPath, fn, operation, beforeRemove) {
 	const keys = reclaimKeys(rootPath);
-	const acquire = (index) => index === keys.length ? fn(keys) : withManagedTunnelRemovalLock(keys[index], () => acquire(index + 1));
+	for (const key of keys) beforeRemove?.(nativeCanonicalPath(key));
+	const acquire = (index) => index === keys.length ? fn(keys) : withManagedTunnelRemovalLock(keys[index], () => acquire(index + 1), {
+		signal: operation?.signal,
+		declareSpawnsFor: operation
+	});
 	return acquire(0);
 }
-async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRootProject = false, removedBy } = {}) {
+async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRootProject = false, removedBy, operation } = {}) {
 	const dereferenced = [];
 	const killedPids = [];
 	const deletedDevices = [];
@@ -2259,17 +2716,23 @@ async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRoot
 	const releasedLeases = [];
 	const removedWorkspaceDirs = [];
 	const failedWorkspaceDirs = [];
+	operation?.signal.throwIfAborted();
+	const pressure = currentDiskLevel(operation ? await measureDiskAsync(operation) : void 0);
 	for (const key of keys) {
+		operation?.signal.throwIfAborted();
 		let r;
 		try {
 			r = await reclaimProject(key, {
 				archive: removedBy ? { removedBy } : void 0,
 				deleteOwnedDevices: true,
-				parkOwnedDevices: true,
+				parkOwnedDevices: pressure < 2,
 				preserveProjectRecord: preserveRootProject && key === rootPath,
-				stopRequester: { by: "stim worktree remove" }
+				stopRequester: { by: "stim worktree remove" },
+				operation
 			});
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			operation?.signal.throwIfAborted();
 			keptEntries.push(key);
 			retainedResources.push({
 				name: "ownership state",
@@ -2298,6 +2761,7 @@ async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRoot
 			});
 		}
 	}
+	if (pressure >= 2 && deletedDevices.length) poolNotes.push(`disk pressure level ${pressure}: deleted the owned devices instead of parking them`);
 	for (const key of keys) {
 		if (keptEntries.includes(key)) continue;
 		const tunnel = readMetroTunnel(key);
@@ -2350,18 +2814,18 @@ function poolLines(result) {
 	for (const note of result.poolNotes) lines.push(chalk.yellow(phaseLine("device", note)));
 	return lines;
 }
-function reportRetainedResources(root, result) {
-	console.error(chalk.red(`Refusing to remove ${root}: Stim could not release owned resources.`));
+function reportRetainedResources(root, result, output) {
+	output.error(chalk.red(`Refusing to remove ${root}: Stim could not release owned resources.`));
 	for (const resource of result.retainedResources) {
-		console.error(chalk.yellow(`  - Stim still tracks ${describeKeptDevice(resource)} for ${resource.project}`));
-		console.error(chalk.dim(`    ${resource.reason}`));
+		output.error(chalk.yellow(`  - Stim still tracks ${describeKeptDevice(resource)} for ${resource.project}`));
+		output.error(chalk.dim(`    ${resource.reason}`));
 	}
 	for (const kept of result.keptEntries) {
 		if (result.retainedResources.some((resource) => resource.project === kept)) continue;
-		console.error(chalk.yellow(`  - retained Stim ownership state for ${kept}`));
+		output.error(chalk.yellow(`  - retained Stim ownership state for ${kept}`));
 	}
-	console.error(chalk.dim("Fix the reported cause, then run `stim worktree remove` again."));
-	process.exitCode = 1;
+	output.error(chalk.dim("Fix the reported cause, then run `stim worktree remove` again."));
+	output.fail();
 }
 function hasRegisteredProjectUnder(rootPath) {
 	const cfg = loadConfig$1();
@@ -2371,28 +2835,40 @@ function projectAtOrAbove(root, path) {
 	const here = nativeCanonicalPath(path);
 	return Object.keys(loadConfig$1()?.projects ?? {}).filter((key) => isPathPrefix(nativeCanonicalPath(root), nativeCanonicalPath(key)) && isPathPrefix(nativeCanonicalPath(key), here)).toSorted((a, b) => b.length - a.length)[0] ?? null;
 }
-async function reclaimEnvironment(root, why) {
+async function reclaimEnvironment(root, why, output, operation, beforeRemove) {
 	await withManagedRemoteWorktreeRemovalLock(root, () => withReclaimLocks(root, async (lockedKeys) => {
-		const result = await reclaimAll(root, lockedKeys, { removedBy: "worktree-remove" });
-		for (const line of poolLines(result)) console.error(line);
-		for (const device of result.deletedDevices) console.error(chalk.dim(phaseLine("device", `deleted ${device}`)));
-		for (const session of result.stoppedSessions) console.error(chalk.dim(phaseLine("device", `stopped remote session ${session}`)));
-		for (const tunnel of result.stoppedTunnels) console.error(chalk.dim(phaseLine("lan", `stopped the ${tunnel} tunnel`)));
-		for (const lease of result.releasedLeases) console.error(chalk.dim(phaseLine("lease", releasedLeaseFact(lease))));
-		for (const pid of result.killedPids) console.error(chalk.dim(phaseLine("metro", `killed pid ${pid}`)));
-		for (const dir of result.removedWorkspaceDirs) console.error(chalk.dim(phaseLine("workspace", `removed ${dir}`)));
-		for (const dir of result.failedWorkspaceDirs) console.error(chalk.yellow(phaseLine("workspace", `could not remove ${dir}`)));
-		if (result.dereferenced.length) console.error(chalk.dim(phaseLine("workspace", `no longer referenced: ${result.dereferenced.join(", ")}`)));
+		const result = await reclaimAll(root, lockedKeys, {
+			removedBy: "worktree-remove",
+			operation
+		});
+		for (const line of poolLines(result)) output.error(line);
+		for (const device of result.deletedDevices) output.error(chalk.dim(phaseLine("device", `deleted ${device}`)));
+		for (const session of result.stoppedSessions) output.error(chalk.dim(phaseLine("device", `stopped remote session ${session}`)));
+		for (const tunnel of result.stoppedTunnels) output.error(chalk.dim(phaseLine("lan", `stopped the ${tunnel} tunnel`)));
+		for (const lease of result.releasedLeases) output.error(chalk.dim(phaseLine("lease", releasedLeaseFact(lease))));
+		for (const pid of result.killedPids) output.error(chalk.dim(phaseLine("metro", `killed pid ${pid}`)));
+		for (const dir of result.removedWorkspaceDirs) output.error(chalk.dim(phaseLine("workspace", `removed ${dir}`)));
+		for (const dir of result.failedWorkspaceDirs) output.error(chalk.yellow(phaseLine("workspace", `could not remove ${dir}`)));
+		if (result.dereferenced.length) output.error(chalk.dim(phaseLine("workspace", `no longer referenced: ${result.dereferenced.join(", ")}`)));
 		if (result.keptEntries.length) {
-			reportRetainedResources(root, result);
+			reportRetainedResources(root, result, output);
 			return;
 		}
-		for (const s of result.skippedDevices) console.error(chalk.yellow(phaseLine("device", `kept ${describeKeptDevice(s)} (${s.reason})`)));
-		console.error(chalk.green(`Reclaimed the environment; the working tree stays (${why}).`));
-	}));
+		for (const s of result.skippedDevices) output.error(chalk.yellow(phaseLine("device", `kept ${describeKeptDevice(s)} (${s.reason})`)));
+		output.error(chalk.green(`Reclaimed the environment; the working tree stays (${why}).`));
+	}, operation, beforeRemove), {
+		signal: operation?.signal,
+		declareSpawnsFor: operation
+	});
 }
-function removalPath(target) {
-	return canonicalExistingPath(target ?? process.cwd());
+const REMOVAL_OUTPUT = {
+	error: (line) => console.error(line),
+	fail: () => {
+		process.exitCode = 1;
+	}
+};
+function removalPath(target, cwd = process.cwd()) {
+	return canonicalExistingPath(target ?? cwd);
 }
 function canonicalExistingPath(target) {
 	const resolved = resolve$1(target);
@@ -2406,9 +2882,9 @@ function canonicalExistingPath(target) {
 	}
 	return resolve$1(realpathSync$1(existing), ...missing);
 }
-function inspectRemoval(path, mergedHead) {
+async function inspectRemoval(path, mergedHead, operation) {
 	try {
-		return inspectGit(path, mergedHead);
+		return await inspectGit(path, mergedHead, operation);
 	} catch (error) {
 		if (!isTimeoutError(error)) throw error;
 		return timedOutInspection(error);
@@ -2424,18 +2900,24 @@ function timedOutInspection(error) {
 		timedOut: true
 	};
 }
-function inspectGit(path, mergedHead) {
-	const gitAnswered = hasUncommittedWork(path);
-	const allDirty = gitAnswered ? dirtyPaths(path, { limit: Infinity }) : [];
+async function inspectGit(path, mergedHead, operation) {
+	const options = {
+		removal: true,
+		env: operation?.env,
+		signal: operation?.signal,
+		declareFor: operation
+	};
+	const gitAnswered = await hasUncommittedWorkAsync(path, options);
+	const allDirty = gitAnswered ? await dirtyPathsAsync(path, { limit: Infinity }, options) : [];
 	const { lines: withoutCookies, cookies } = excludeWatchmanCookies(allDirty ?? []);
 	const { lines: dirtyLines, restore: podChurn } = excludePodChurn(withoutCookies, customIosDirs(path));
 	const dirty = gitAnswered === null || allDirty === null ? null : dirtyLines.length > 0;
-	const unpushed = unpushedCommits(path);
+	const unpushed = await unpushedCommitsAsync(path, options);
 	const blockers = removalBlockers({
 		dirty,
-		unpushed: Boolean(mergedHead) && resolveFullRef(path, "HEAD", { removal: true }) === mergedHead && unpushed ? [] : unpushed
+		unpushed: Boolean(mergedHead) && await resolveFullRefAsync(path, "HEAD", options) === mergedHead && unpushed ? [] : unpushed
 	});
-	const submodules = hasPopulatedSubmodules(path);
+	const submodules = await hasPopulatedSubmodulesAsync(path, options);
 	if (submodules === null) blockers.push("could not check for initialized submodules; re-run with --force to override");
 	else if (submodules) blockers.push("initialized submodules, which git removes only with --force");
 	return {
@@ -2446,43 +2928,50 @@ function inspectGit(path, mergedHead) {
 		blockers
 	};
 }
-function printRemovalRefusal(path, inspection) {
+async function printRemovalRefusal(path, inspection, output, operation) {
 	const { blockers, dirtyLines, unpushed } = inspection;
-	console.error(chalk.red(`Refusing to remove ${path}:`));
-	for (const blocker of blockers) console.error(chalk.red(`  - ${blocker}`));
+	output.error(chalk.red(`Refusing to remove ${path}:`));
+	for (const blocker of blockers) output.error(chalk.red(`  - ${blocker}`));
 	if (inspection.timedOut) {
-		console.error(chalk.dim("Git did not answer in time, so Stim cannot tell whether the worktree holds unsaved work."));
-		console.error(chalk.dim(`Retry once git responds; check with: git -C ${path} status`));
-		process.exitCode = 1;
+		output.error(chalk.dim("Git did not answer in time, so Stim cannot tell whether the worktree holds unsaved work."));
+		output.error(chalk.dim(`Retry once git responds; check with: git -C ${path} status`));
+		output.fail();
 		return;
 	}
-	if (unpushed && unpushed.length && !hasRemote(path)) console.error(chalk.dim("  (no remote is configured for this worktree, so every commit no other local branch reaches counts as unpushed)"));
-	for (const line of dirtyLines.slice(0, 10)) console.error(chalk.dim(`      ${line}`));
-	if (dirtyLines.length) console.error(chalk.dim(`  (git -C ${path} status -s for the full list)`));
-	for (const line of removalRemedy(dirtyLines, { worktree: path })) console.error(chalk.dim(line));
-	console.error(chalk.dim("Otherwise: commit or push the branch (only commits found nowhere else are counted,"));
-	console.error(chalk.dim("so pushing publishes nothing but this worktree's own work). --force is a last"));
-	console.error(chalk.dim("resort -- it discards uncommitted changes and untracked files permanently; committed"));
-	console.error(chalk.dim("work stays on the branch."));
-	process.exitCode = 1;
+	if (unpushed && unpushed.length && !await hasRemoteAsync(path, {
+		env: operation?.env,
+		signal: operation?.signal
+	})) output.error(chalk.dim("  (no remote is configured for this worktree, so every commit no other local branch reaches counts as unpushed)"));
+	for (const line of dirtyLines.slice(0, 10)) output.error(chalk.dim(`      ${line}`));
+	if (dirtyLines.length) output.error(chalk.dim(`  (git -C ${path} status -s for the full list)`));
+	for (const line of removalRemedy(dirtyLines, { worktree: path })) output.error(chalk.dim(line));
+	output.error(chalk.dim("Otherwise: commit or push the branch (only commits found nowhere else are counted,"));
+	output.error(chalk.dim("so pushing publishes nothing but this worktree's own work). --force is a last"));
+	output.error(chalk.dim("resort -- it discards uncommitted changes and untracked files permanently; committed"));
+	output.error(chalk.dim("work stays on the branch."));
+	output.fail();
 }
 function deleteWatchmanCookies(path, cookies) {
 	for (const cookie of cookies) rmSync$1(join$1(path, cookie), { force: true });
 }
-function restorePodChurn(path, files) {
-	for (const file of files) if (restoreFile(path, file)) console.error(chalk.dim(`  restored ${file} (pod install churn; the worktree is being removed)`));
-	else console.error(chalk.yellow(`  could not restore ${file}; git may refuse to remove the worktree`));
-}
-function printRemovalCleanup(result, failed) {
-	for (const line of poolLines(result)) console.error(line);
-	for (const device of result.deletedDevices) console.error(chalk.dim(phaseLine("device", `deleted ${device}`)));
-	for (const session of result.stoppedSessions) console.error(chalk.dim(phaseLine("device", `stopped remote session ${session}`)));
-	for (const tunnel of result.stoppedTunnels) console.error(chalk.dim(phaseLine("lan", `stopped the ${tunnel} tunnel`)));
-	for (const lease of result.releasedLeases) console.error(chalk.dim(phaseLine("lease", releasedLeaseFact(lease))));
-	for (const pid of result.killedPids) console.error(chalk.dim(phaseLine("metro", `killed pid ${pid}`)));
-	if (!failed) for (const dir of result.removedWorkspaceDirs) console.error(chalk.dim(phaseLine("workspace", `removed ${dir}`)));
-	if (result.dereferenced.length) console.error(chalk.dim(phaseLine("workspace", `no longer referenced: ${result.dereferenced.join(", ")}`)));
-	for (const skipped of result.skippedDevices) console.error((failed ? chalk.dim : chalk.yellow)(phaseLine("device", `kept ${describeKeptDevice(skipped)} (${skipped.reason})`)));
+async function restorePodChurn(path, files, output, operation) {
+	for (const file of files) if (await restoreFileAsync(path, file, {
+		env: operation?.env,
+		signal: operation?.signal,
+		declareFor: operation
+	})) output.error(chalk.dim(`  restored ${file} (pod install churn; the worktree is being removed)`));
+	else output.error(chalk.yellow(`  could not restore ${file}; git may refuse to remove the worktree`));
+}
+function printRemovalCleanup(result, failed, output) {
+	for (const line of poolLines(result)) output.error(line);
+	for (const device of result.deletedDevices) output.error(chalk.dim(phaseLine("device", `deleted ${device}`)));
+	for (const session of result.stoppedSessions) output.error(chalk.dim(phaseLine("device", `stopped remote session ${session}`)));
+	for (const tunnel of result.stoppedTunnels) output.error(chalk.dim(phaseLine("lan", `stopped the ${tunnel} tunnel`)));
+	for (const lease of result.releasedLeases) output.error(chalk.dim(phaseLine("lease", releasedLeaseFact(lease))));
+	for (const pid of result.killedPids) output.error(chalk.dim(phaseLine("metro", `killed pid ${pid}`)));
+	if (!failed) for (const dir of result.removedWorkspaceDirs) output.error(chalk.dim(phaseLine("workspace", `removed ${dir}`)));
+	if (result.dereferenced.length) output.error(chalk.dim(phaseLine("workspace", `no longer referenced: ${result.dereferenced.join(", ")}`)));
+	for (const skipped of result.skippedDevices) output.error((failed ? chalk.dim : chalk.yellow)(phaseLine("device", `kept ${describeKeptDevice(skipped)} (${skipped.reason})`)));
 }
 async function removeWorktreeTarget(target, opts = {}) {
 	let removed = false;
@@ -2492,200 +2981,245 @@ async function removeWorktreeTarget(target, opts = {}) {
 	return removed;
 }
 async function runRemove(target, opts, onRemoved) {
+	const output = opts.output ?? REMOVAL_OUTPUT;
 	try {
-		await removeOrRefuse(target, opts, onRemoved);
+		await removeOrRefuse(target, opts, onRemoved, output);
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		opts.operation?.signal.throwIfAborted();
 		if (!isTimeoutError(error)) throw error;
-		printRemovalRefusal(removalPath(target), timedOutInspection(error));
+		await printRemovalRefusal(removalPath(target, opts.operation?.cwd), timedOutInspection(error), output, opts.operation);
 	}
 }
-async function removeOrRefuse(target, opts, onRemoved) {
+async function removeOrRefuse(target, opts, onRemoved, output) {
+	const options = {
+		removal: true,
+		env: opts.operation?.env,
+		signal: opts.operation?.signal,
+		declareFor: opts.operation
+	};
+	options.signal?.throwIfAborted();
 	const poolError = parkedMaxSetting("ios").error || parkedMaxSetting("android").error;
 	if (poolError) {
-		console.error(chalk.red(poolError));
-		console.error(chalk.dim(POOL_SETTING_REMEDY));
-		process.exitCode = 1;
+		output.error(chalk.red(poolError));
+		output.error(chalk.dim(POOL_SETTING_REMEDY));
+		output.fail();
 		return;
 	}
-	let path = removalPath(target);
+	let path = removalPath(target, opts.operation?.cwd);
 	if (!existsSync$1(path)) {
+		opts.beforeRemove?.(path);
 		const pending = getProject(path);
 		if (pending?.worktreeRemovalComplete === true && pending.worktreeBranchOwned === true && pending.worktreeBranch && pending.worktreeMainRoot && pending.worktreePendingBranchSha) {
 			const branch = pending.worktreeBranch;
 			const mainRoot = pending.worktreeMainRoot;
 			if (!existsSync$1(mainRoot)) {
-				console.error(chalk.red(`Cannot finish branch cleanup for ${path}: source checkout ${mainRoot} is missing.`));
-				console.error(chalk.dim(`Delete ${branch} from the repository, then run \`stim gc --delete\`.`));
-				process.exitCode = 1;
+				output.error(chalk.red(`Cannot finish branch cleanup for ${path}: source checkout ${mainRoot} is missing.`));
+				output.error(chalk.dim(`Delete ${branch} from the repository, then run \`stim gc --delete\`.`));
+				output.fail();
 				return;
 			}
-			if (!branchExists(mainRoot, branch, { removal: true })) {
+			opts.beforeRemove?.(removalPath(mainRoot));
+			if (!await branchExistsAsync(mainRoot, branch, options)) {
 				removeProject(path);
-				console.error(chalk.dim(phaseLine("branch", `${branch} is already absent; cleared its pending cleanup record`)));
+				output.error(chalk.dim(phaseLine("branch", `${branch} is already absent; cleared its pending cleanup record`)));
 				return;
 			}
-			const checkedOutAt = listWorktrees(mainRoot, { removal: true }).find((candidate) => candidate.branch === branch && resolve$1(candidate.path) !== resolve$1(path))?.path;
+			const checkedOutAt = (await listWorktreesAsync(mainRoot, options)).find((candidate) => candidate.branch === branch && resolve$1(candidate.path) !== resolve$1(path))?.path;
 			if (checkedOutAt) {
-				console.error(chalk.red(`Refusing pending cleanup for ${branch}: it is checked out at ${checkedOutAt}.`));
-				console.error(chalk.dim("Switch that worktree to another branch, then retry this command."));
-				process.exitCode = 1;
+				output.error(chalk.red(`Refusing pending cleanup for ${branch}: it is checked out at ${checkedOutAt}.`));
+				output.error(chalk.dim("Switch that worktree to another branch, then retry this command."));
+				output.fail();
 				return;
 			}
-			const currentSha = resolveFullRef(mainRoot, branch, { removal: true });
+			const currentSha = await resolveFullRefAsync(mainRoot, branch, options);
 			if (currentSha !== pending.worktreePendingBranchSha) {
-				console.error(chalk.red(`Refusing pending cleanup for ${branch}: its tip changed from ${pending.worktreePendingBranchSha} to ${currentSha || "an unknown commit"}.`));
-				console.error(chalk.dim("The branch can contain new work. Inspect it and delete it manually if appropriate."));
-				process.exitCode = 1;
+				output.error(chalk.red(`Refusing pending cleanup for ${branch}: its tip changed from ${pending.worktreePendingBranchSha} to ${currentSha || "an unknown commit"}.`));
+				output.error(chalk.dim("The branch can contain new work. Inspect it and delete it manually if appropriate."));
+				output.fail();
 				return;
 			}
 			try {
-				deleteBranch(mainRoot, branch, pending.worktreePendingBranchSha);
+				await deleteBranchAsync(mainRoot, branch, pending.worktreePendingBranchSha, options);
 				removeProject(path);
-				console.error(chalk.dim(phaseLine("branch", `deleted ${branch}; cleared its pending cleanup record`)));
+				output.error(chalk.dim(phaseLine("branch", `deleted ${branch}; cleared its pending cleanup record`)));
 			} catch (error) {
-				console.error(chalk.red(`Could not delete branch ${branch}: ${String(error?.message || error)}`));
-				console.error(chalk.dim(`Retry with: stim worktree remove ${path}`));
-				process.exitCode = 1;
+				if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+				output.error(chalk.red(`Could not delete branch ${branch}: ${String(error?.message || error)}`));
+				output.error(chalk.dim(`Retry with: stim worktree remove ${path}`));
+				output.fail();
 			}
 			return;
 		}
-		console.error(chalk.red(`No such worktree: ${path}`));
-		process.exitCode = 1;
+		output.error(chalk.red(`No such worktree: ${path}`));
+		output.fail();
 		return;
 	}
-	const worktrees = listWorktrees(path, { removal: true });
+	const worktrees = await listWorktreesAsync(path, options);
 	const entry = matchWorktreeEntry(worktrees, path);
 	if (!entry) {
-		if (!opts.linkedOnly && gitCommonDir(path, { removal: true }) === null && hasRegisteredProjectUnder(path)) {
-			await reclaimEnvironment(path, "it is not a git repository");
+		if (!opts.linkedOnly && await gitCommonDirAsync(path, options) === null && hasRegisteredProjectUnder(path)) {
+			await reclaimEnvironment(path, "it is not a git repository", output, opts.operation, opts.beforeRemove);
 			return;
 		}
-		console.error(chalk.red(`Refusing to remove ${path}: it is not inside any worktree known to git.`));
-		console.error(chalk.dim("  Run it from inside the worktree, or pass the worktree root path, e.g. as printed by `git worktree list`."));
-		process.exitCode = 1;
+		output.error(chalk.red(`Refusing to remove ${path}: it is not inside any worktree known to git.`));
+		output.error(chalk.dim("  Run it from inside the worktree, or pass the worktree root path, e.g. as printed by `git worktree list`."));
+		output.fail();
 		return;
 	}
 	if (entry.bare) {
-		console.error(chalk.red(`Refusing to remove ${path}: ${entry.path} is the bare repository, not a worktree.`));
-		console.error(chalk.dim("  Pass a worktree path, e.g. as printed by `git worktree list`."));
-		process.exitCode = 1;
+		output.error(chalk.red(`Refusing to remove ${path}: ${entry.path} is the bare repository, not a worktree.`));
+		output.error(chalk.dim("  Pass a worktree path, e.g. as printed by `git worktree list`."));
+		output.fail();
 		return;
 	}
 	const source = sourceCheckoutOf(worktrees);
 	if ("refusal" in source) {
-		console.error(chalk.red(`Refusing to remove ${path}: ${source.refusal}`));
-		process.exitCode = 1;
+		output.error(chalk.red(`Refusing to remove ${path}: ${source.refusal}`));
+		output.fail();
 		return;
 	}
 	if (entry.path === source.path && opts.linkedOnly) {
-		console.error(chalk.red(`Refusing to remove ${path}: ${entry.path} is the source checkout.`));
-		process.exitCode = 1;
+		output.error(chalk.red(`Refusing to remove ${path}: ${entry.path} is the source checkout.`));
+		output.fail();
 		return;
 	}
 	if (entry.path === source.path) {
 		if (nativeCanonicalPath(entry.path) !== nativeCanonicalPath(path)) {
 			const project = projectAtOrAbove(entry.path, path);
 			if (!project) {
-				console.error(chalk.red(`Refusing to reclaim from ${path}: no Stim project is registered at or above it.`));
-				console.error(chalk.dim(`  Run it from the project folder, or from ${entry.path} to reclaim every project under it.`));
-				process.exitCode = 1;
+				output.error(chalk.red(`Refusing to reclaim from ${path}: no Stim project is registered at or above it.`));
+				output.error(chalk.dim(`  Run it from the project folder, or from ${entry.path} to reclaim every project under it.`));
+				output.fail();
 				return;
 			}
-			console.error(chalk.dim(`${path} is inside the source checkout ${entry.path}; reclaiming only the project ${project}.`));
-			await reclaimEnvironment(project, "it is the source checkout");
+			output.error(chalk.dim(`${path} is inside the source checkout ${entry.path}; reclaiming only the project ${project}.`));
+			await reclaimEnvironment(project, "it is the source checkout", output, opts.operation, opts.beforeRemove);
 			return;
 		}
-		await reclaimEnvironment(entry.path, "it is the source checkout");
+		await reclaimEnvironment(entry.path, "it is the source checkout", output, opts.operation, opts.beforeRemove);
 		return;
 	}
 	if (entry.path !== path) {
-		console.error(chalk.dim(`${path} is inside the worktree ${entry.path}; removing that.`));
+		output.error(chalk.dim(`${path} is inside the worktree ${entry.path}; removing that.`));
 		path = entry.path;
 	}
 	if (entry.locked) {
-		console.error(chalk.red(`Refusing to remove ${path}: git has it locked.`));
-		console.error(chalk.dim(`Unlock it, then retry: git -C ${source.path} worktree unlock ${path}`));
-		process.exitCode = 1;
+		output.error(chalk.red(`Refusing to remove ${path}: git has it locked.`));
+		output.error(chalk.dim(`Unlock it, then retry: git -C ${source.path} worktree unlock ${path}`));
+		output.fail();
+		return;
+	}
+	const nested = nestedWorktrees(worktrees, entry.path);
+	if (nested.length) {
+		output.error(chalk.red(`Refusing to remove ${path}: it contains the worktree ${nested.join(", ")}.`));
+		output.error(chalk.dim("Remove the nested worktree first, then retry."));
+		output.fail();
 		return;
 	}
 	const service = serviceRunningFrom(path, nativeCanonicalPath);
 	if (service) {
-		console.error(chalk.red(service.argument ? `Refusing to remove ${path}: it runs the stim-server service ${service.label} (${service.argument}). ${SERVICE_IN_USE.code}` : `Refusing to remove ${path}: could not read ${service.plist} to check whether the stim-server service ${service.label} runs from it. ${SERVICE_IN_USE.code}`));
-		console.error(chalk.dim(`Reinstall the service from another build with \`stim-server service install --label ${service.label}\`, or remove it with \`stim-server service uninstall --label ${service.label}\`, then retry.`));
-		process.exitCode = 1;
+		output.error(chalk.red(service.argument ? `Refusing to remove ${path}: it runs the stim-server service ${service.label} (${service.argument}). ${SERVICE_IN_USE.code}` : `Refusing to remove ${path}: could not read ${service.plist} to check whether the stim-server service ${service.label} runs from it. ${SERVICE_IN_USE.code}`));
+		output.error(chalk.dim(`Reinstall the service from another build with \`stim-server service install --label ${service.label}\`, or remove it with \`stim-server service uninstall --label ${service.label}\`, then retry.`));
+		output.fail();
 		return;
 	}
 	const project = getProject(path);
 	const branch = entry.branch;
 	const ownsBranch = Boolean(branch && project?.worktreeBranchOwned === true && project.worktreeBranch === branch);
-	const approvedBranchSha = ownsBranch ? resolveFullRef(path, "HEAD", { removal: true }) : null;
+	const approvedBranchSha = ownsBranch ? await resolveFullRefAsync(path, "HEAD", options) : null;
 	let mergedHead = opts.mergedHead;
-	let inspection = inspectRemoval(path, mergedHead);
+	let inspection = await inspectRemoval(path, mergedHead, opts.operation);
 	if (inspection.blockers.length && !opts.force && !mergedHead && branch && inspection.unpushed?.length && !inspection.dirtyLines.length) {
-		const head = resolveFullRef(path, "HEAD", { removal: true });
-		const pr = head ? endedPullRequest(pullRequestLookup()(path, branch, head)) : null;
+		const head = await resolveFullRefAsync(path, "HEAD", options);
+		const pr = head ? endedPullRequest(await pullRequestLookupAsync(opts.operation)(path, branch, head)) : null;
 		if (head && pr?.state === "merged") {
 			mergedHead = head;
-			inspection = inspectRemoval(path, mergedHead);
-			console.error(chalk.dim(`HEAD is in the merged PR #${pr.number} (${pr.url}); its local-only commits stay on GitHub.`));
+			inspection = await inspectRemoval(path, mergedHead, opts.operation);
+			output.error(chalk.dim(`HEAD is in the merged PR #${pr.number} (${pr.url}); its local-only commits stay on GitHub.`));
 		}
 	}
 	if (inspection.blockers.length && !opts.force) {
-		printRemovalRefusal(path, inspection);
+		await printRemovalRefusal(path, inspection, output, opts.operation);
 		return;
 	}
 	const deleteOwnedBranch = Boolean(ownsBranch && approvedBranchSha && inspection.unpushed?.length === 0);
 	const retainedBranchReason = !branch ? null : !ownsBranch ? "Stim did not create it" : inspection.unpushed === null ? "Stim could not verify whether it has unique commits" : inspection.unpushed.length > 0 ? `it has ${plural(inspection.unpushed.length, "unique commit")}` : null;
 	const branchDeleteCwd = source.path;
 	await withManagedRemoteWorktreeRemovalLock(path, () => withReclaimLocks(path, async (lockedKeys) => {
-		if (opts.guard?.(lockedKeys).length) return;
-		const inspectedHead = resolveFullRef(path, "HEAD", { removal: true });
-		const current = inspectRemoval(path, mergedHead);
+		options.signal?.throwIfAborted();
+		if ((await opts.guard?.(lockedKeys))?.length) return;
+		options.signal?.throwIfAborted();
+		const inspectedHead = await resolveFullRefAsync(path, "HEAD", options);
+		if (opts.expectedHead && inspectedHead !== opts.expectedHead) {
+			output.error(chalk.red(`Refusing to remove ${path}: its HEAD moved since it was checked.`));
+			output.fail();
+			return;
+		}
+		const current = await inspectRemoval(path, mergedHead, opts.operation);
 		if (current.blockers.length && !opts.force) {
-			printRemovalRefusal(path, current);
+			await printRemovalRefusal(path, current, output, opts.operation);
 			return;
 		}
 		const result = await reclaimAll(path, lockedKeys, {
 			preserveRootProject: true,
-			removedBy: opts.removedBy ?? "worktree-remove"
+			removedBy: opts.removedBy ?? "worktree-remove",
+			operation: opts.operation
 		});
 		if (result.keptEntries.length) {
-			reportRetainedResources(path, result);
+			reportRetainedResources(path, result, output);
+			return;
+		}
+		let headMoved = false;
+		if (!opts.force) try {
+			headMoved = await resolveFullRefAsync(path, "HEAD", options) !== inspectedHead;
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			opts.operation?.signal.throwIfAborted();
+			if (!isTimeoutError(error)) throw error;
+			await printRemovalRefusal(path, timedOutInspection(error), output, opts.operation);
+			output.error(chalk.dim(`The directory and Stim ownership record for ${path} were kept.`));
+			printRemovalCleanup(result, true, output);
 			return;
 		}
-		if (!opts.force && resolveFullRef(path, "HEAD", { removal: true }) !== inspectedHead) {
-			console.error(chalk.red(`Refusing to remove ${path}: its HEAD moved while its environment was reclaimed.`));
-			console.error(chalk.dim(`The directory and Stim ownership record for ${path} were kept.`));
-			printRemovalCleanup(result, true);
-			process.exitCode = 1;
+		if (headMoved) {
+			output.error(chalk.red(`Refusing to remove ${path}: its HEAD moved while its environment was reclaimed.`));
+			output.error(chalk.dim(`The directory and Stim ownership record for ${path} were kept.`));
+			printRemovalCleanup(result, true, output);
+			output.fail();
 			return;
 		}
-		restorePodChurn(path, current.podChurn);
+		await restorePodChurn(path, current.podChurn, output, opts.operation);
+		options.signal?.throwIfAborted();
 		deleteWatchmanCookies(path, current.cookies);
 		try {
-			removeWorktree(path, {
+			await removeWorktreeAsync(path, {
 				from: source.path,
-				force: opts.force
+				force: opts.force,
+				env: options.env,
+				signal: options.signal,
+				declareFor: opts.operation
 			});
 		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
 			const message = String(error?.message || error);
-			console.error(chalk.red(`git worktree remove failed: ${message}`));
-			if (process.platform === "win32" && /Permission denied/i.test(message)) console.error(chalk.dim("Another process holds a file or directory inside the worktree. An adb server or emulator started from it keeps its working directory open; `adb kill-server` releases the server, and Sysinternals handle.exe lists other holders."));
-			console.error(chalk.dim(`The directory and Stim ownership record for ${path} were kept.`));
-			printRemovalCleanup(result, true);
-			process.exitCode = 1;
+			output.error(chalk.red(`git worktree remove failed: ${message}`));
+			if (process.platform === "win32" && /Permission denied/i.test(message)) output.error(chalk.dim("Another process holds a file or directory inside the worktree. An adb server or emulator started from it keeps its working directory open; `adb kill-server` releases the server, and Sysinternals handle.exe lists other holders."));
+			output.error(chalk.dim(`The directory and Stim ownership record for ${path} were kept.`));
+			printRemovalCleanup(result, true, output);
+			output.fail();
 			return;
 		}
 		onRemoved();
 		forgetStatusMeasures(path, result.reclaimedKeys);
 		const finish = () => {
-			printRemovalCleanup(result, false);
-			console.error(chalk.dim(phaseLine("removed", path)));
+			printRemovalCleanup(result, false, output);
+			output.error(chalk.dim(phaseLine("removed", path)));
 		};
 		if (deleteOwnedBranch && branch) {
 			if (!approvedBranchSha) {
-				console.error(chalk.yellow(phaseLine("branch", `kept ${branch} (Stim could not record its commit before removal)`)));
-				process.exitCode = 1;
+				output.error(chalk.yellow(phaseLine("branch", `kept ${branch} (Stim could not record its commit before removal)`)));
+				output.fail();
 				finish();
 				return;
 			}
@@ -2693,28 +3227,44 @@ async function removeOrRefuse(target, opts, onRemoved) {
 				worktreeRemovalComplete: true,
 				worktreePendingBranchSha: approvedBranchSha
 			});
-			const checkedOutAt = listWorktrees(branchDeleteCwd).find((candidate) => candidate.branch === branch && resolve$1(candidate.path) !== resolve$1(path))?.path;
+			let checkedOutAt;
+			try {
+				checkedOutAt = (await listWorktreesAsync(branchDeleteCwd, options)).find((candidate) => candidate.branch === branch && resolve$1(candidate.path) !== resolve$1(path))?.path;
+			} catch (error) {
+				if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+				opts.operation?.signal.throwIfAborted();
+				if (!isTimeoutError(error)) throw error;
+				output.error(chalk.yellow(phaseLine("branch", `kept ${branch} (git did not list the worktrees in time to check it)`)));
+				output.error(chalk.dim(`  Retry: stim worktree remove ${path}`));
+				output.fail();
+				finish();
+				return;
+			}
 			if (checkedOutAt) {
-				console.error(chalk.yellow(phaseLine("branch", `kept ${branch} (it is checked out at ${checkedOutAt})`)));
-				console.error(chalk.dim(`  Switch that worktree to another branch, then retry: stim worktree remove ${path}`));
-				process.exitCode = 1;
+				output.error(chalk.yellow(phaseLine("branch", `kept ${branch} (it is checked out at ${checkedOutAt})`)));
+				output.error(chalk.dim(`  Switch that worktree to another branch, then retry: stim worktree remove ${path}`));
+				output.fail();
 				finish();
 				return;
 			}
 			try {
-				deleteBranch(branchDeleteCwd, branch, approvedBranchSha);
-				console.error(chalk.dim(phaseLine("branch", `deleted ${branch}`)));
+				await deleteBranchAsync(branchDeleteCwd, branch, approvedBranchSha, options);
+				output.error(chalk.dim(phaseLine("branch", `deleted ${branch}`)));
 			} catch (error) {
-				console.error(chalk.yellow(phaseLine("branch", `kept ${branch} (${String(error?.message || error)})`)));
-				console.error(chalk.dim(`  Retry with: git -C ${branchDeleteCwd} branch -D -- ${branch}`));
-				process.exitCode = 1;
+				if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+				output.error(chalk.yellow(phaseLine("branch", `kept ${branch} (${String(error?.message || error)})`)));
+				output.error(chalk.dim(`  Retry with: git -C ${branchDeleteCwd} branch -D -- ${branch}`));
+				output.fail();
 				finish();
 				return;
 			}
-		} else if (branch && retainedBranchReason) console.error(chalk.dim(phaseLine("branch", `kept ${branch} (${retainedBranchReason})`)));
+		} else if (branch && retainedBranchReason) output.error(chalk.dim(phaseLine("branch", `kept ${branch} (${retainedBranchReason})`)));
 		removeProject(path);
 		finish();
-	}));
+	}, opts.operation, opts.beforeRemove), {
+		signal: opts.operation?.signal,
+		declareSpawnsFor: opts.operation
+	});
 }
 function registerRemove(worktree) {
 	worktree.command("remove [target]").description("Remove a worktree, its unused Stim-created branch, build artifacts, owned devices, and Metro port. Defaults to the current workspace. On the source checkout it reclaims the environment only and leaves the tree in place; from a subfolder it reclaims only the project at or above that folder, with the projects nested under it.").option("--force", "remove even when the worktree holds uncommitted or unpushed work or initialized submodules").action(async (target, opts) => {
@@ -2727,4 +3277,4 @@ function worktreeCommand(program) {
 	registerRemove(worktree);
 }
 //#endregion
-export { reclaimProject as _, matchWorktreeEntry as a, registerRemove as c, removalPath as d, removalRemedy as f, describeDereferenced as g, worktreeCommand as h, excludeWatchmanCookies as i, registerWarm as l, warmedWorkspace as m, dependencyInstallCommand as n, porcelainPath as o, removeWorktreeTarget as p, excludePodChurn as r, reclaimKeys as s, customIosDirs as t, removalBlockers as u, deleteSelectedArchives as v, sweepArchiveStaging as y };
+export { levelFloors as A, measureDisk as C, measureSizes as D, measurePressureAsync as E, lowestFree as M, protectWindowMs as N, sizeScanDeferred as O, cacheBlocked as S, measurePressure as T, worktreeCommand as _, matchWorktreeEntry as a, deleteSelectedArchives as b, reclaimKeys as c, removalBlockers as d, removalPath as f, warmedWorkspace as g, warmWorktreeTarget as h, excludeWatchmanCookies as i, levelStillShort as j, diskPressureLevel as k, registerRemove as l, removeWorktreeTarget as m, dependencyInstallCommand as n, nestedWorktrees as o, removalRemedy as p, excludePodChurn as r, porcelainPath as s, customIosDirs as t, registerWarm as u, describeDereferenced as v, measureDiskAsync as w, sweepArchiveStaging as x, reclaimProject as y };