stim 1.20.2 → 1.21.0

package/dist/{gc-qWOMdnER.mjs → gc-_-dCXdyL.mjs}

@@ -1,30 +1,32 @@
-import { A as acquireAvdClaim, D as withConfigLock$1, F as listMountedVolumes, L as volumeRootFor, M as directorySize, N as formatBytes, P as isOnMountedVolume, S as removeProject, W as projectDeviceSlots, _ as loadConfig$1, j as ownership_claim_exports, k as process_identity_exports } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { d as removeExpiredLease, h as listBuildLocks } from "./device-lease-BX1sJQ2E.mjs";
-import { D as withDirLock$1, E as workspaceStateFile, s as workspaceLastUsed, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { h as shortUdid, o as formatLongDuration, u as plural } from "./command-output-BTy8hZ0F.mjs";
-import { _ as detectIsExpo, r as findProjectRoot } from "./project-_phNIJfs.mjs";
-import { A as listAvds, H as parseAvdSystemImage, I as ownedAvdDirectory, M as listOrphanedAvdDirectories, V as parseAvdDeviceProfile, _ as avdStorageRoots, at as POOL_SETTING_REMEDY, d as androidToolPath, dt as parkedMaxSetting, ft as readParked, it as isStimOwnedSim, j as listInstalledSystemImages, m as avdNameAbsent, o as androidHome, p as avdIniPaths, rt as isStimOwnedAvd } from "./android-Mz_Inn3w.mjs";
-import { n as readCreatedDevices$1, t as forgetCreatedDevice } from "./created-devices-Dzd5C2LF.mjs";
-import { C as recordGcResult, I as listBuildSlots, T as canonicalPath, a as collectWorkspaceOutputs, c as listWorkspaceDirs, f as withIdleWorkspace, i as collectOrphanedWorkspaces, l as rootPresence, n as WORKSPACE_OUTPUT_DIRS, o as deleteOrphanedWorkspaces, p as workspaceInUse, r as clearWorkspaceOutputs, s as isInsideWorkspaces, t as REBUILD_COST, u as sizeText, w as takeGcResults } from "./workspaces-C36s2jb9.mjs";
-import { $ as memoryWorkPending, A as findStaleProjectDevices, B as previewScopedEmptying, C as deleteProjectDevices, D as eraseParkedDevices, E as deviceSweepIsScoped, F as includesParkedDevices, H as selectsBeyondCaches, I as includesRecordings, L as includesWorkspaceOutputs, M as withAndroidAvdSizes, N as emptyCaches, O as findOrphanedDevices, P as includesArchives, Q as memorySweepIsScoped, R as isWorkspacesScope, S as deleteParkedSims, T as describeUnverifiableDevices, U as trimCaches, V as selectCaches, W as parseArchiveSelector, X as memoryLines, Y as memoryCacheKind, Z as memoryScope, _ as DEVICE_LIST_TIMEOUT_MS, at as discoverCaches, b as collectParkedSims, d as collectIdleDevices, et as reclaimMemory, h as shutDownIdleDevices, j as unverifiedDeviceCommand, k as findStaleDeviceRecords, m as parseIdleDuration, nt as phase, p as idleDeviceLines, q as collectMemoryReport, st as sizeCaches, tt as scopedMemoryReport, v as collectDeviceLeases, w as describeParkedSims, x as deleteParkedAvds, y as collectParkedAvds, z as planCacheEmptying } from "./budget-f7516Zk0.mjs";
-import { f as resolveEasCliBin } from "./remote-cache-OyOyVIS3.mjs";
-import { d as listAllIosSims } from "./ios-RkW4pnQf.mjs";
-import { C as parseSessionListPage, T as verifyStoppedSession, _ as findOrphanedOwnedSessions, b as isDefinitiveMissingSessionError, d as withRemoteSessionLock, f as withEasProjectLock, v as getSessionArgs, w as stopSessionArgs, x as listOwnedSessionsArgs, y as inspectSessionForTeardown } from "./device-remote-xRT0Vmo9.mjs";
-import { a as removeEasSessionClaim, n as easMachineStateRoot$1, r as readEasSessionLedger$1 } from "./eas-session-ledger-Cm0Gwq2F.mjs";
-import { r as readCollectors } from "./ownership-DCtw_2IA.mjs";
-import { c as removeWorktrees, l as worktreePullRequestNote, n as previewMaintenance, s as collectWorktreeSweep, u as worktreeRemovalReason } from "./preview-78a9kR_-.mjs";
-import { _ as reclaimProject, g as describeDereferenced, v as deleteSelectedArchives, y as sweepArchiveStaging } from "./worktree-CgvJYJ-Q.mjs";
-import { i as getSwiftpmCacheUsage, n as swiftpmCacheLines, r as getAgentDeviceUsage, t as agentDeviceLines } from "./agent-device-usage-output-Dzgv6lgR.mjs";
+import { f as ownership_claim_exports, p as process_identity_exports, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { d as workspaceDir, v as withDirLock$1 } from "./paths-DQtTgsBf.mjs";
+import { D as withConfigLock$1, F as isOnMountedVolume, I as listMountedVolumes, K as projectDeviceSlots, N as directorySizeAsync, P as formatBytes, R as measuredDirectorySizeAsync, S as removeProject, _ as loadConfig$1, j as acquireAvdClaim, z as volumeRootFor } from "./config-CYcBF478.mjs";
+import { h as shortUdid, o as formatLongDuration, u as plural } from "./command-output-B1UrjZHL.mjs";
+import { u as workspaceLastUsed } from "./workspace-state-Cjuigeeu.mjs";
+import { kt as listWorktreesAsync, zt as resolveSourceCheckoutAsync } from "./settings-CsJDEXgK.mjs";
+import { i as findProjectRoot$1, v as detectIsExpo } from "./project-BZNjmW_8.mjs";
+import { a as removeEasSessionClaim, n as easMachineStateRoot$1, r as readEasSessionLedger$1 } from "./eas-session-ledger-op6A54yi.mjs";
+import { $ as includesRecordings, At as unverifiedDeviceCommand, C as collectIdleDevices, D as idleDeviceLines, Dt as findOrphanedDevices, Et as eraseParkedDevices, Ft as withRemoteSessionGcLocks, Kt as withEasProjectLock, Mt as collectEasSessionSweep, Nt as deleteEasSessions, O as parseIdleDuration, Ot as findStaleDeviceRecords, Pt as describeError, Q as includesParkedDevices, Sr as sizeCaches, St as deleteProjectDevices, Tt as deviceSweepIsScoped, X as emptyCaches, Z as includesArchives, _r as phase, _t as collectDeviceLeases, at as selectsBeyondCaches, br as discoverCaches, bt as deleteParkedAvds, dr as memoryScope, dt as gradleVersionsPending, et as includesWorkspaceOutputs, fr as memorySweepIsScoped, ft as includesGradleVersions, gt as DEVICE_LIST_TIMEOUT_MS, hr as scopedMemoryReport, ht as collectInventory, ir as parseArchiveSelector, it as selectCaches, jt as withAndroidAvdSizes, k as shutDownIdleDevices, kt as findStaleProjectDevices, lr as memoryCacheKind, lt as deleteGradleVersions, mr as reclaimMemory, mt as getMachineCacheReport, nt as planCacheEmptying, ot as trimCaches, pr as memoryWorkPending, rt as previewScopedEmptying, sr as collectMemoryReport, st as collectGradleVersions, tt as isWorkspacesScope, ur as memoryLines, ut as gradleVersionLines, vt as collectParkedAvds, w as collectIdleDevicesAsync, wt as describeUnverifiableDevices, xt as deleteParkedSims, yt as collectParkedSims } from "./budget-Bs6SxxzO.mjs";
+import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
+import { B as takeGcResults, I as listBuildSlots, a as collectWorkspaceOutputs, c as listWorkspaceDirs, f as withIdleWorkspace, i as collectOrphanedWorkspaces, l as rootPresence, n as WORKSPACE_OUTPUT_DIRS, o as deleteOrphanedWorkspaces, p as workspaceInUse, r as clearWorkspaceOutputs, s as isInsideWorkspaces, t as REBUILD_COST, u as sizeText, z as recordGcResult } from "./workspaces-BccMFmGQ.mjs";
+import { N as listBuildLocks, k as removeExpiredLease } from "./activity-BzVfHSrY.mjs";
+import { n as readCreatedDevices$1, t as forgetCreatedDevice } from "./created-devices-CqeBlrEn.mjs";
+import { F as listOrphanedAvdDirectories, M as listAvds, N as listAvdsAsync, ht as parkedMaxSetting, lt as POOL_SETTING_REMEDY, m as avdNameAbsent, z as ownedAvdDirectory } from "./android-DUYkNF4u.mjs";
+import { d as listAllIosSims, f as listAllIosSimsAsync } from "./ios-CpByZy12.mjs";
+import { r as readCollectors } from "./ownership-DEmM5vhh.mjs";
+import { _ as describeDereferenced, a as matchWorktreeEntry, b as sweepArchiveStaging, v as reclaimProject, y as deleteSelectedArchives } from "./worktree-DQ6Zi2Mv.mjs";
+import { s as writeCacheFile } from "./warm-progress-BHX5r0Ei.mjs";
+import { _ as collectWorktreeSweep, a as previewMaintenance, b as worktreeRemovalReason, c as deleteTempLeftovers, d as ARTIFACT_DIRS, f as appRoots, g as candidateRootsAsync, h as ownedDeviceUsage, l as tempLeftoverLines, o as triggeringRoot, p as finishedWorkspaces, s as collectTempLeftovers, t as deleteIdleWorkspaceDevices, u as tempLeftoverSection, v as removeWorktrees, y as worktreePullRequestNote } from "./act-DHAw2A2S.mjs";
+import { i as getSwiftpmCacheUsage, n as swiftpmCacheLines, r as getAgentDeviceUsage, t as agentDeviceLines } from "./agent-device-usage-output-zh1vhbLp.mjs";
 import { existsSync, lstatSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
-import { basename, dirname, isAbsolute, join } from "node:path";
-import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1 } from "path";
-import { assertHostedDeviceLedger, deviceHostArea, deviceHostRoot, hostedDeviceId, isJsonObject, listRecordedDevices, listStatusCacheEntries, maintenanceRunClaims, parseHostedPlatformDevice, readArchives, readHostedDevice, readHostedDeviceLedger, readHostedSessions, recordedBytes } from "@stim-cli/core/state";
-import { fileURLToPath } from "node:url";
-import { closeSync as closeSync$1, existsSync as existsSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readSync as readSync$1, readdirSync as readdirSync$1, renameSync as renameSync$1, rmSync as rmSync$1, statSync as statSync$1, utimesSync as utimesSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { LOG_ROTATE_BYTES, rotatedLogPath } from "@stim-cli/core";
-import { InvalidArgumentError } from "commander";
+import { assertHostedDeviceLedger, deviceHostArea, deviceHostRoot, diskUsageCacheFile, hostedDeviceId, isJsonObject, listRecordedDevices, listStatusCacheEntries, maintenanceRunClaims, parseHostedPlatformDevice, readArchives, readDiskUsage, readHostedDevice, readHostedDeviceLedger, readHostedSessions, recordedBytes } from "@stim-cli/core/state";
+import { isAbsolute as isAbsolute$1, join as join$1 } from "path";
+import { fileURLToPath } from "node:url";
 import chalk from "chalk";
+import { closeSync as closeSync$1, existsSync as existsSync$1, openSync as openSync$1, readSync as readSync$1, readdirSync as readdirSync$1, renameSync as renameSync$1, rmSync as rmSync$1, statSync as statSync$1, utimesSync as utimesSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { InvalidArgumentError } from "commander";
 //#region src/commands/gc/archives.ts
 function stagingOrNone() {
 	try {
@@ -95,439 +97,16 @@ function deleteArchives(selection) {
 }
 function archiveRefusal(selection) {
 	if (selection?.unknownId === void 0 || selection.unknownId === null) return null;
-	process.exitCode = 1;
-	const message = `Unknown archive "${selection.unknownId}".`;
-	const remedy = `Known archive ids: ${selection.knownIds.join(", ") || "(none)"}`;
-	console.error(chalk.red(message));
-	console.error(chalk.dim(remedy));
-	console.error(chalk.red("failed: STIM_BAD_ARG"));
 	return {
 		code: "STIM_BAD_ARG",
-		message,
-		remedy
+		message: `Unknown archive "${selection.unknownId}".`,
+		remedy: `Known archive ids: ${selection.knownIds.join(", ") || "(none)"}`
 	};
 }
 function archiveWorkPending(selection, otherWork) {
 	return otherWork || Boolean(selection?.records.some((record) => record.willDelete) || selection?.staging.some((entry) => !entry.kept));
 }
 //#endregion
-//#region src/commands/gc/eas-sessions.ts
-const EAS_OPERATION_TIMEOUT_MS = 3e4;
-const EAS_COLLECTION_TIMEOUT_MS = 6e4;
-const EAS_MAX_LIST_PAGES = 100;
-const EAS_LOCK_WAIT_MS = 0;
-const EAS_LOCK_SNAPSHOT_RETRIES = 3;
-const PROXY_CREDENTIAL_ENV = ["AGENT_DEVICE_DAEMON_BASE_URL", "AGENT_DEVICE_DAEMON_AUTH_TOKEN"];
-function describeError(error) {
-	const candidate = error;
-	if (typeof candidate?.stderr === "string" && candidate.stderr.trim()) return candidate.stderr.trim();
-	if (typeof candidate?.message === "string" && candidate.message.trim()) return candidate.message.trim();
-	return String(error);
-}
-function readRecordedRemoteSessionIds(roots) {
-	const ids = /* @__PURE__ */ new Set();
-	const notices = [];
-	let safe = true;
-	for (const root of new Set(roots)) {
-		try {
-			if (!statSync$1(root).isDirectory()) throw new Error("path is not a directory");
-			readdirSync$1(root);
-		} catch (error) {
-			safe = false;
-			notices.push(`${root} is not available as a readable workspace directory: ${describeError(error)}`);
-			continue;
-		}
-		const path = workspaceStateFile(root);
-		if (!existsSync$1(path)) continue;
-		let state;
-		try {
-			state = JSON.parse(readFileSync$1(path, "utf-8"));
-		} catch (error) {
-			safe = false;
-			notices.push(`${path} could not be read as valid JSON: ${describeError(error)}`);
-			continue;
-		}
-		if (!state || typeof state !== "object" || Array.isArray(state)) {
-			safe = false;
-			notices.push(`${path} does not contain a valid workspace state object.`);
-			continue;
-		}
-		const remote = state.remoteDevice;
-		if (remote === void 0) continue;
-		if (!remote || typeof remote !== "object" || Array.isArray(remote)) {
-			safe = false;
-			notices.push(`${path} has a malformed remote session record.`);
-			continue;
-		}
-		const id = remote.sessionId;
-		if (typeof id !== "string" || id.length === 0) {
-			safe = false;
-			notices.push(`${path} has a remote session record with no valid session id.`);
-			continue;
-		}
-		ids.add(id);
-	}
-	return {
-		ids: [...ids],
-		notices,
-		safe
-	};
-}
-function claimStateAbsence(claim) {
-	const stateDir = dirname$1(claim.stateFile);
-	let entries;
-	try {
-		if (!statSync$1(stateDir).isDirectory()) throw new Error("path is not a directory");
-		entries = readdirSync$1(stateDir);
-	} catch (error) {
-		return {
-			absent: false,
-			notice: `${stateDir} is not available for EAS ownership verification: ${describeError(error)}`
-		};
-	}
-	if (!entries.includes(basename$1(claim.stateFile))) return {
-		absent: true,
-		notice: null
-	};
-	let state;
-	try {
-		state = JSON.parse(readFileSync$1(claim.stateFile, "utf-8"));
-	} catch (error) {
-		return {
-			absent: false,
-			notice: `${claim.stateFile} could not be read as valid JSON: ${describeError(error)}`
-		};
-	}
-	if (!state || typeof state !== "object" || Array.isArray(state)) return {
-		absent: false,
-		notice: `${claim.stateFile} does not contain a valid workspace state object.`
-	};
-	const remote = state.remoteDevice;
-	if (remote === void 0) return {
-		absent: true,
-		notice: null
-	};
-	if (!remote || typeof remote !== "object" || Array.isArray(remote)) return {
-		absent: false,
-		notice: `${claim.stateFile} has a malformed remote session record.`
-	};
-	const sessionId = remote.sessionId;
-	if (typeof sessionId !== "string" || !sessionId) return {
-		absent: false,
-		notice: `${claim.stateFile} has a remote session record with no valid session id.`
-	};
-	return {
-		absent: sessionId !== claim.sessionId,
-		notice: null
-	};
-}
-function collectEasSessionSweep(config, deps) {
-	const projectRoot = (deps.findProjectRoot ?? findProjectRoot)(process.cwd());
-	const empty = (notices = []) => ({
-		projectScope: projectRoot,
-		orphaned: [],
-		notices,
-		deletionSafe: notices.length === 0
-	});
-	if (!projectRoot || !(deps.detectIsExpo ?? detectIsExpo)(projectRoot)) return empty();
-	if (deps.easSweepBlockedNotice) return empty([deps.easSweepBlockedNotice]);
-	const eas = (deps.resolveEasCliBin ?? resolveEasCliBin)(projectRoot);
-	if (!eas) return empty(["EAS session sweep skipped: eas-cli is not available for the current Expo project."]);
-	const recorded = readRecordedRemoteSessionIds([...Object.keys(config?.projects ?? {}), projectRoot]);
-	const ledgerRoot = deps.easLedgerRoot ?? easMachineStateRoot$1();
-	const ledger = readEasSessionLedger$1(ledgerRoot);
-	const run = deps.runEasFile ?? ((file, args, options) => getExecutor().runFile(file, args, options));
-	const sessions = [];
-	const seenCursors = /* @__PURE__ */ new Set();
-	const now = deps.easNow ?? Date.now;
-	const collectionTimeoutMs = deps.easCollectionTimeoutMs ?? EAS_COLLECTION_TIMEOUT_MS;
-	const maxPages = deps.easMaxPages ?? EAS_MAX_LIST_PAGES;
-	const deadline = now() + collectionTimeoutMs;
-	let pageCount = 0;
-	let after = null;
-	while (true) {
-		if (pageCount >= maxPages) return empty([...recorded.notices, `EAS session list exceeded the maximum page limit of ${maxPages} for ${projectRoot}.`]);
-		const remainingMs = deadline - now();
-		if (remainingMs <= 0) return empty([...recorded.notices, `EAS session list exceeded its total time limit for ${projectRoot}.`]);
-		let stdout;
-		try {
-			stdout = run(eas.file, listOwnedSessionsArgs(after), {
-				cwd: projectRoot,
-				timeoutMs: Math.min(EAS_OPERATION_TIMEOUT_MS, remainingMs),
-				omitEnv: PROXY_CREDENTIAL_ENV
-			});
-		} catch (error) {
-			return empty([...recorded.notices, `EAS session list failed for ${projectRoot}: ${describeError(error)}`]);
-		}
-		pageCount++;
-		if (now() > deadline) return empty([...recorded.notices, `EAS session list exceeded its total time limit for ${projectRoot}.`]);
-		const parsed = parseSessionListPage(stdout);
-		if (!parsed.ok) return empty([...recorded.notices, parsed.reason]);
-		sessions.push(...parsed.page.sessions);
-		if (!parsed.page.hasNextPage) break;
-		const cursor = parsed.page.endCursor?.trim();
-		if (!cursor) return empty([...recorded.notices, "EAS session list has a next page but returned no pagination cursor."]);
-		if (seenCursors.has(cursor)) return empty([...recorded.notices, `EAS session list repeated pagination cursor ${cursor}.`]);
-		seenCursors.add(cursor);
-		after = cursor;
-	}
-	const lockedRoots = deps.easLockedRoots;
-	if (lockedRoots) {
-		if (easLockRoots(projectRoot, loadConfig$1()).some((root) => !lockedRoots.includes(root))) return empty([...recorded.notices, "EAS session sweep skipped: registered workspace roots changed after remote-session locks were acquired."]);
-	}
-	const compared = findOrphanedOwnedSessions({
-		sessions,
-		recordedSessionIds: recorded.ids,
-		projectScope: projectRoot
-	});
-	const notices = [...recorded.notices, ...compared.notices];
-	if (ledger.notice) notices.push(ledger.notice);
-	const orphaned = [];
-	if (ledger.safe && recorded.safe) for (const session of compared.orphaned) {
-		const claim = ledger.claims.get(session.id);
-		if (!claim || claim.name !== session.name || claim.platform !== session.platform) {
-			notices.push(`EAS session ${session.id} (${session.name}) is unclaimed or its fixed ownership record does not match; it was not selected for deletion.`);
-			continue;
-		}
-		const state = claimStateAbsence(claim);
-		if (state.notice) {
-			notices.push(state.notice);
-			continue;
-		}
-		if (state.absent) orphaned.push(session);
-	}
-	return {
-		projectScope: projectRoot,
-		orphaned,
-		notices,
-		deletionSafe: recorded.safe && ledger.safe
-	};
-}
-function easLockRoots(projectRoot, config) {
-	return [...new Set([...Object.keys(config?.projects ?? {}), projectRoot].map(canonicalPath))].toSorted();
-}
-function unavailableLockRootNotice(roots) {
-	for (const root of roots) try {
-		if (!statSync$1(root).isDirectory()) throw new Error("path is not a directory");
-		readdirSync$1(root);
-	} catch (error) {
-		return `EAS session sweep skipped: ${root} is not available for remote-session lock inspection: ${describeError(error)}`;
-	}
-	return null;
-}
-function malformedRemoteSessionLockNotice(roots) {
-	for (const root of roots) {
-		const lockPath = join$1(workspaceDir(root), "remote-session.lock");
-		if (!existsSync$1(lockPath)) continue;
-		if ((0, ownership_claim_exports.readClaimSet)(lockPath).unresolved.length === 0) continue;
-		return `EAS session sweep skipped: the remote-session lock at ${lockPath} has a malformed owner record.`;
-	}
-	return null;
-}
-async function withRemoteSessionGcLocks(projectRoot, deps, fn) {
-	const withLock = deps.withRemoteSessionLock ?? withRemoteSessionLock;
-	const waitMs = deps.easLockWaitMs ?? EAS_LOCK_WAIT_MS;
-	const maxSnapshots = deps.easLockSnapshotRetries ?? EAS_LOCK_SNAPSHOT_RETRIES;
-	for (let attempt = 0; attempt < maxSnapshots; attempt++) {
-		const roots = easLockRoots(projectRoot, loadConfig$1());
-		const unavailable = unavailableLockRootNotice(roots);
-		if (unavailable) return fn({
-			...deps,
-			easSweepBlockedNotice: unavailable
-		});
-		const malformed = malformedRemoteSessionLockNotice(roots);
-		if (malformed) return fn({
-			...deps,
-			easSweepBlockedNotice: malformed
-		});
-		let expanded = false;
-		let coreStarted = false;
-		const acquire = (index) => index === roots.length ? (async () => {
-			if (easLockRoots(projectRoot, loadConfig$1()).some((root) => !roots.includes(root))) {
-				expanded = true;
-				return null;
-			}
-			coreStarted = true;
-			return fn({
-				...deps,
-				easSweepBlockedNotice: void 0,
-				easLockedRoots: roots
-			});
-		})() : withLock(roots[index], () => acquire(index + 1), { waitMs });
-		try {
-			const result = await acquire(0);
-			if (!expanded) return result;
-		} catch (error) {
-			if (coreStarted) throw error;
-			return fn({
-				...deps,
-				easSweepBlockedNotice: `EAS session sweep skipped: remote-session lock acquisition failed: ${describeError(error)}`
-			});
-		}
-	}
-	return fn({
-		...deps,
-		easSweepBlockedNotice: `EAS session sweep skipped: registered workspace roots kept changing during remote-session lock acquisition.`
-	});
-}
-async function deleteEasSessions(easSessionSweep, deps) {
-	let deleteFailures = 0;
-	const refuseAll = (detail) => {
-		deleteFailures += easSessionSweep.orphaned.length;
-		for (const session of easSessionSweep.orphaned) recordGcResult("easSession", "failed", session.name, {
-			id: session.id,
-			detail
-		});
-	};
-	if (easSessionSweep.orphaned.length && easSessionSweep.deletionSafe && easSessionSweep.projectScope) {
-		const projectScope = easSessionSweep.projectScope;
-		const withProjectLock = deps.withEasProjectLock ?? withEasProjectLock;
-		let finalSweepStarted = false;
-		try {
-			await withProjectLock(projectScope, () => {
-				finalSweepStarted = true;
-				return withRemoteSessionGcLocks(projectScope, deps, async (lockedDeps) => {
-					if (lockedDeps.easSweepBlockedNotice) {
-						refuseAll(`EAS session deletion refused: ${lockedDeps.easSweepBlockedNotice}`);
-						console.log(chalk.red(`EAS session deletion refused: ${lockedDeps.easSweepBlockedNotice}`));
-						return;
-					}
-					const coordinatedDeps = lockedDeps;
-					const currentConfig = loadConfig$1();
-					const currentRoots = easLockRoots(projectScope, currentConfig);
-					const registryExpanded = coordinatedDeps.easLockedRoots && currentRoots.some((root) => !coordinatedDeps.easLockedRoots.includes(root));
-					const currentRecords = registryExpanded ? null : readRecordedRemoteSessionIds([...Object.keys(currentConfig?.projects ?? {}), projectScope]);
-					const ledgerRoot = coordinatedDeps.easLedgerRoot ?? easMachineStateRoot$1();
-					const ledger = readEasSessionLedger$1(ledgerRoot);
-					const removeClaim = coordinatedDeps.removeEasSessionClaim ?? removeEasSessionClaim;
-					const reconcileClaim = (sessionId) => {
-						let detail = "the claim store did not remove it";
-						try {
-							if (removeClaim(sessionId, ledgerRoot)) return;
-						} catch (error) {
-							detail = describeError(error);
-						}
-						deleteFailures++;
-						console.log(chalk.red(`EAS session ${sessionId} is resolved, but its ownership claim could not be removed: ${detail}. The claim was retained for reconciliation.`));
-					};
-					if (registryExpanded) {
-						refuseAll("EAS session deletion refused: registered workspace roots changed after classification.");
-						console.log(chalk.red("EAS session deletion refused: registered workspace roots changed after classification."));
-					} else if (!currentRecords?.safe || !ledger.safe) {
-						refuseAll("EAS session deletion refused: the session records could not be read safely.");
-						for (const notice of [...currentRecords?.notices ?? [], ...ledger.notice ? [ledger.notice] : []]) console.log(chalk.red(`EAS session deletion refused: ${notice}`));
-					} else {
-						const recorded = new Set(currentRecords.ids);
-						const eas = (coordinatedDeps.resolveEasCliBin ?? resolveEasCliBin)(projectScope);
-						const run = coordinatedDeps.runEasFile ?? ((file, args, options) => getExecutor().runFile(file, args, options));
-						for (const session of easSessionSweep.orphaned) {
-							if (recorded.has(session.id)) {
-								console.log(chalk.dim(`EAS session ${session.id} has a workspace record and was left running.`));
-								recordGcResult("easSession", "kept", session.name, {
-									id: session.id,
-									detail: "it has a workspace record and was left running"
-								});
-								continue;
-							}
-							const claim = ledger.claims.get(session.id);
-							const claimState = claim ? claimStateAbsence(claim) : null;
-							if (!claim || claim.name !== session.name || claim.platform !== session.platform || !claimState?.absent || claimState.notice) {
-								deleteFailures++;
-								console.log(chalk.red(`Could not verify fixed ownership for EAS session ${session.id}: ${claimState?.notice ?? "the claim is missing, mismatched, or still recorded in workspace state"}.`));
-								recordGcResult("easSession", "failed", session.name, {
-									id: session.id,
-									detail: `Could not verify fixed ownership for EAS session ${session.id}: ${claimState?.notice ?? "the claim is missing, mismatched, or still recorded in workspace state"}.`
-								});
-								continue;
-							}
-							if (!eas) {
-								deleteFailures++;
-								console.log(chalk.red(`Could not verify EAS session ${session.id}: eas-cli is not available.`));
-								recordGcResult("easSession", "failed", session.name, {
-									id: session.id,
-									detail: `Could not verify EAS session ${session.id}: eas-cli is not available.`
-								});
-								continue;
-							}
-							const options = {
-								cwd: session.projectScope,
-								timeoutMs: EAS_OPERATION_TIMEOUT_MS,
-								omitEnv: PROXY_CREDENTIAL_ENV
-							};
-							let live;
-							try {
-								live = run(eas.file, getSessionArgs(session.id), options);
-							} catch (error) {
-								if (isDefinitiveMissingSessionError(error, session.id)) {
-									console.log(chalk.dim(`EAS session ${session.id} is already gone.`));
-									reconcileClaim(session.id);
-								} else {
-									deleteFailures++;
-									console.log(chalk.red(`Could not verify EAS session ${session.id}: ${describeError(error)}`));
-									recordGcResult("easSession", "failed", session.name, {
-										id: session.id,
-										detail: `Could not verify EAS session ${session.id}: ${describeError(error)}`
-									});
-								}
-								continue;
-							}
-							const inspection = inspectSessionForTeardown(live, session.id);
-							if (inspection.action === "already-stopped") {
-								console.log(chalk.dim(`EAS session ${session.id} is already stopped (${inspection.status}).`));
-								reconcileClaim(session.id);
-								continue;
-							}
-							if (inspection.action === "refused") {
-								deleteFailures++;
-								console.log(chalk.red(`Could not stop EAS session ${session.id}: ${inspection.reason}`));
-								recordGcResult("easSession", "failed", session.name, {
-									id: session.id,
-									detail: `Could not stop EAS session ${session.id}: ${inspection.reason}`
-								});
-								continue;
-							}
-							let stopped;
-							try {
-								stopped = run(eas.file, stopSessionArgs(session.id), options);
-							} catch (error) {
-								deleteFailures++;
-								console.log(chalk.red(`Could not stop EAS session ${session.id}: ${describeError(error)}`));
-								recordGcResult("easSession", "failed", session.name, {
-									id: session.id,
-									detail: `Could not stop EAS session ${session.id}: ${describeError(error)}`
-								});
-								continue;
-							}
-							const verified = verifyStoppedSession(stopped, session.id);
-							if (!verified.ok) {
-								deleteFailures++;
-								console.log(chalk.red(`Could not verify EAS session ${session.id} stopped: ${verified.reason}`));
-								recordGcResult("easSession", "failed", session.name, {
-									id: session.id,
-									detail: `Could not verify EAS session ${session.id} stopped: ${verified.reason}`
-								});
-								continue;
-							}
-							console.log(chalk.green(`Stopped EAS session ${session.id} (${session.name})`));
-							recordGcResult("easSession", "done", session.name, { id: session.id });
-							reconcileClaim(session.id);
-						}
-					}
-				});
-			}, {
-				waitMs: 0,
-				ownerPurpose: "EAS orphan deletion",
-				machineRoot: deps.easLedgerRoot
-			});
-		} catch (error) {
-			const phase = finalSweepStarted ? "failed" : "lock acquisition failed";
-			refuseAll(`EAS session deletion ${phase}: ${describeError(error)}`);
-			console.log(chalk.red(`EAS session deletion ${phase}: ${describeError(error)}`));
-		}
-	}
-	return deleteFailures;
-}
-//#endregion
 //#region src/commands/gc/eas-ledger.ts
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 /**
@@ -562,6 +141,71 @@ function forgetStaleEasLedgerEntries(entries, mountedVolumes, deps = {}) {
 	return failures;
 }
 //#endregion
+//#region src/devices/machine-cache-usage-output.ts
+const size = (bytes) => bytes === null ? "unknown" : formatBytes(bytes);
+function total(values) {
+	const known = values.reduce((sum, value) => sum + (value ?? 0), 0);
+	return `${values.some((value) => value === null) ? "at least " : ""}${formatBytes(known)}`;
+}
+function machineCacheLines(report, now = Date.now()) {
+	if (!report) return [];
+	const { gradle, simRuntimes, deviceSupport, runnerBuilds } = report;
+	const body = [];
+	if (gradle.unusedVersions.length) {
+		body.push(`  Gradle versions no registered project pins (${total(gradle.unusedVersions.map((entry) => entry.bytes))}):`);
+		for (const entry of gradle.unusedVersions) {
+			body.push(`    ${entry.version}: ${size(entry.bytes)}`);
+			for (const dir of entry.dirs) body.push(`      ${dir.dir}`);
+			if (entry.remedy) body.push(chalk.dim(`      remedy: ${entry.remedy}`));
+		}
+		if (gradle.unreadableProjects.length) body.push(chalk.dim(`    ${gradle.unreadableProjects.length} registered project${gradle.unreadableProjects.length === 1 ? " is" : "s are"} missing or unreadable, so a version listed here may still be in use: ${gradle.unreadableProjects.join(", ")}`));
+	}
+	if (gradle.modules) {
+		body.push(`  Gradle dependency cache: ${size(gradle.modules.bytes)}`, `    ${gradle.modules.dir}`);
+		body.push(chalk.dim(`    remedy: ${gradle.modules.remedy}`));
+	}
+	if (!simRuntimes.checked) body.push(chalk.dim("  Simulator runtimes: not checked, simctl did not answer"));
+	else if (simRuntimes.runtimes.length) {
+		body.push(`  Simulator runtimes (${total(simRuntimes.runtimes.map((entry) => entry.bytes))}):`);
+		for (const runtime of simRuntimes.runtimes) {
+			const details = [
+				runtime.devices ? `${runtime.devices} simulator${runtime.devices === 1 ? "" : "s"}` : "no simulator uses it",
+				runtime.lastUsedAt ? `last used ${runtime.lastUsedAt.slice(0, 10)}` : null,
+				runtime.deletable ? null : "not deletable"
+			].filter(Boolean);
+			body.push(`    ${runtime.runtimeIdentifier.replace(/^com\.apple\.CoreSimulator\.SimRuntime\./, "")}${runtime.build ? ` (${runtime.build})` : ""}: ${size(runtime.bytes)}, ${details.join(", ")}`);
+			if (runtime.remedy) body.push(chalk.dim(`      remedy: ${runtime.remedy}`));
+		}
+	}
+	if (deviceSupport.entries.length) {
+		body.push(`  Xcode device support (${total(deviceSupport.entries.map((entry) => entry.bytes))}):`);
+		for (const entry of deviceSupport.entries) body.push(`    ${entry.dir}: ${size(entry.bytes)}`);
+		body.push(chalk.dim(`    remedy: ${deviceSupport.remedy}`));
+	}
+	if (runnerBuilds.groups.length) {
+		const currentVersions = runnerBuilds.agentDeviceVersion && runnerBuilds.xcodeBuildVersion ? `current: agent-device ${runnerBuilds.agentDeviceVersion}, Xcode ${runnerBuilds.xcodeBuildVersion}` : "current versions unknown";
+		body.push(`  agent-device runner builds by version (${currentVersions}):`);
+		for (const group of runnerBuilds.groups) {
+			const details = [
+				`${group.entries} entr${group.entries === 1 ? "y" : "ies"}`,
+				size(group.bytes),
+				group.oldestUseAt ? `oldest use ${group.oldestUseAt.slice(0, 10)}` : null,
+				group.inUse ? `${group.inUse} in use` : null,
+				group.current ? "current" : group.current === false ? "older toolchain" : null
+			].filter(Boolean);
+			body.push(`    agent-device ${group.packageVersion ?? "unknown"}, Xcode ${group.xcodeBuildVersion ?? "unknown"}: ${details.join(", ")}`);
+		}
+		body.push(chalk.dim(`    remedy: ${runnerBuilds.remedy}`));
+	}
+	for (const notice of report.notices) body.push(chalk.dim(`  ${notice}`));
+	if (!body.length) return [];
+	return [
+		`Other tools' machine-wide caches${report.complete ? "" : " (incomplete)"} - measured ${formatLongDuration(Math.max(0, now - Date.parse(report.measuredAt)))} ago`,
+		...body,
+		chalk.dim("  Stim reports these and never deletes them; use each tool's own cleanup.")
+	];
+}
+//#endregion
 //#region src/commands/gc/status-caches.ts
 const KINDS = ["disk-usage", "pull-request"];
 const KEPT_REASON = {
@@ -657,6 +301,81 @@ function deleteStaleStatusCaches(stale) {
 	return failures;
 }
 //#endregion
+//#region src/commands/gc/finished-devices.ts
+/** The owned devices of workspaces whose linked worktree is finished but kept, such as a dirty one. */
+function collectFinishedDevices({ config, sims, avds, sweep, now = Date.now() }) {
+	const keys = Object.keys(config?.projects ?? {});
+	const devices = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const { root, reason } of finishedWorkspaces(sweep, now)) {
+		const key = keys.find((candidate) => canonicalPath(candidate) === root);
+		const project = key ? config?.projects[key] : void 0;
+		if (!config || !key || !project || seen.has(key)) continue;
+		seen.add(key);
+		for (const { idleDays: _idleDays, ...device } of findStaleProjectDevices({
+			config: {
+				...config,
+				projects: { [key]: project }
+			},
+			sims,
+			avds,
+			olderThanDays: 0,
+			lastTouched: () => 0
+		})) devices.push({
+			...device,
+			reason
+		});
+	}
+	return devices;
+}
+function finishedDeviceLines(devices = []) {
+	if (!devices.length) return [];
+	const lines = [`Owned devices of finished worktrees (${devices.length}) - the worktree is kept, its devices are not:`];
+	for (const device of devices) {
+		lines.push(`  ${device.kind} ${device.name} (${device.id})${device.bytes ? ` ${formatBytes(device.bytes)}` : ""}`);
+		lines.push(`              ${device.project}: ${device.reason}`);
+	}
+	lines.push("              --delete keeps a workspace that is in use, leased, driven, locked or pinned.");
+	return lines;
+}
+async function deleteFinishedDevices({ finishedDevices: devices, worktreeSweep }) {
+	const graceMs = worktreeSweep?.graceMs ?? 0;
+	let failures = 0;
+	for (const project of new Set(devices.map((device) => device.project))) {
+		const outcome = await deleteIdleWorkspaceDevices(canonicalPath(project), {
+			windowMs: graceMs,
+			protectedRoot: triggeringRoot(),
+			purpose: "stim gc --delete"
+		});
+		if (outcome.status === "kept") {
+			console.log(chalk.yellow(`Kept the owned devices of ${project}: ${outcome.detail}`));
+			recordGcResult("device", "kept", project, { detail: outcome.detail });
+		} else if (outcome.status === "failed") {
+			failures++;
+			console.log(chalk.red(`Could not delete the owned devices of ${project}: ${outcome.detail}`));
+			recordGcResult("device", "failed", project, { detail: outcome.detail });
+		}
+	}
+	return failures;
+}
+/** Owned simulator and emulator disk of registered workspaces, by platform. */
+function ownedDeviceDisk(usage, unmeasured = {}) {
+	return ["ios", "android"].flatMap((kind) => {
+		const owned = usage.filter((device) => device.kind === kind && device.workspace);
+		const missing = unmeasured[kind] ?? 0;
+		return owned.length || missing ? [{
+			kind,
+			count: owned.length,
+			bytes: owned.reduce((sum, device) => sum + device.bytes, 0),
+			unmeasured: missing
+		}] : [];
+	});
+}
+function ownedDeviceDiskLines(disk = []) {
+	if (!disk.length) return [];
+	return [`Owned device disk: ${disk.map(({ kind, count, bytes, unmeasured }) => `${count} ${kind === "ios" ? "simulators" : "emulators"} ${formatBytes(bytes)}${unmeasured ? ` (${unmeasured} not measured)` : ""}`).join(", ")}`];
+}
+//#endregion
 //#region src/commands/gc/recordings.ts
 const DAY_MS = 864e5;
 function oldSegments(devices, olderThan, now) {
@@ -850,7 +569,7 @@ function staleEasLedgerLines(entries = []) {
 		"              --delete forgets the LEDGER ENTRY only; no EAS session is contacted."
 	];
 }
-function formatGcReport({ maintenance, archives, skipped = [], deadProjects = [], orphanedPorts, invalidProjects = [], orphanedWorkspaces = [], parkedSims = [], parkedAvds = [], parkedHostedDevices, orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], staleLedgerEntries = [], staleEasLedgerEntries, staleStatusCaches = [], buildLocks = {
+function formatGcReport({ maintenance, archives, skipped = [], deadProjects = [], orphanedPorts, invalidProjects = [], orphanedWorkspaces = [], parkedSims = [], parkedAvds = [], parkedHostedDevices, orphanedDevices = [], unverifiedDevices = [], staleDevices = [], finishedDevices, ownedDeviceDisk, staleDeviceRecords = [], staleLedgerEntries = [], staleEasLedgerEntries, staleStatusCaches = [], buildLocks = {
 	stale: [],
 	live: [],
 	unresolved: []
@@ -866,10 +585,11 @@ function formatGcReport({ maintenance, archives, skipped = [], deadProjects = []
 	orphaned: [],
 	notices: [],
 	deletionSafe: true
-}, agentDeviceUsage = null, swiftpmCacheUsage, caches = [], workspaceOutputs = null, workspaceLogs = [], recordings = [], worktreeSweep = null, memory, cacheScope = null, olderThan = null }, { now = Date.now() } = {}) {
+}, agentDeviceUsage = null, swiftpmCacheUsage, machineCaches, tempLeftovers, gradleVersions, caches = [], workspaceOutputs = null, workspaceLogs = [], recordings = [], worktreeSweep = null, memory, cacheScope = null, olderThan = null }, { now = Date.now() } = {}) {
 	const lines = archiveLines(archives);
 	const parkedHostedLines = formatParkedHostedDeviceReport(parkedHostedDevices, now);
 	const easLedgerLines = staleEasLedgerLines(staleEasLedgerEntries);
+	const finishedLines = finishedDeviceLines(finishedDevices);
 	const staleLocks = buildLocks?.stale ?? [];
 	const liveLocks = buildLocks?.live ?? [];
 	const staleSlots = buildSlots?.stale ?? [];
@@ -884,6 +604,7 @@ function formatGcReport({ maintenance, archives, skipped = [], deadProjects = []
 		parkedHostedLines,
 		orphanedDevices,
 		staleDevices,
+		finishedLines,
 		staleDeviceRecords,
 		staleLedgerEntries,
 		easLedgerLines,
@@ -908,6 +629,7 @@ function formatGcReport({ maintenance, archives, skipped = [], deadProjects = []
 	lines.push(...namedPortLines(orphanedPorts));
 	lines.push(...orphanedWorkspaceLines(orphanedWorkspaces));
 	lines.push(...worktreeSweepLines(worktreeSweep));
+	lines.push(...unlistedWorktreeLines(worktreeSweep));
 	lines.push(...formatParkedSimReport(parkedSims, now, cacheScope !== null));
 	lines.push(...formatParkedAvdReport(parkedAvds, now, cacheScope !== null));
 	lines.push(...parkedHostedLines);
@@ -930,6 +652,7 @@ function formatGcReport({ maintenance, archives, skipped = [], deadProjects = []
 			lines.push(`              ${d.project} (idle ${d.idleDays}d)`);
 		}
 	}
+	lines.push(...finishedLines, ...ownedDeviceDiskLines(ownedDeviceDisk));
 	lines.push(...idleDeviceLines(idleDevices));
 	if (staleDeviceRecords.length) {
 		lines.push(`Stale device records (${staleDeviceRecords.length}) - the device is gone, the project is not:`);
@@ -995,6 +718,9 @@ function formatGcReport({ maintenance, archives, skipped = [], deadProjects = []
 	lines.push(...cacheLines(caches, workspaceOutputs));
 	lines.push(...agentDeviceLines(agentDeviceUsage, true, now));
 	lines.push(...swiftpmCacheLines(swiftpmCacheUsage, now));
+	lines.push(...machineCacheLines(machineCaches, now));
+	lines.push(...tempLeftoverLines(tempLeftovers));
+	lines.push(...gradleVersionLines(gradleVersions));
 	lines.push(...memoryLines(memory, memoryCacheKind(cacheScope), now));
 	lines.push(...maintenanceReportLines(maintenance));
 	return lines;
@@ -1072,18 +798,20 @@ function cacheLines(caches, workspaceOutputs) {
 		if (outputs) lines.push(...workspaceOutputLines(outputs, outputBytes));
 		for (const c of caches) {
 			const tag = c.source ? ` (${c.source})` : "";
-			lines.push(`  ${formatBytes(c.bytes ?? 0).padStart(10)}  ${c.name}${tag}`);
+			lines.push(`  ${sizeText(c.bytes ?? null).padStart(10)}  ${c.name}${tag}`);
 			lines.push(`              ${c.dir}`);
 			if (c.note) lines.push(`              ${c.note}`);
+			if (c.sizeError) lines.push(`              ${c.sizeError}`);
 			if (c.willEmpty) lines.push("              would be EMPTIED");
 			else if (c.emptySkipped) lines.push(`              would be left alone: ${c.emptySkipped}`);
 			else if (c.scopedEmpty?.emptySkipped) lines.push(`              --delete --cache would leave it alone: ${c.scopedEmpty.emptySkipped}`);
 		}
-		lines.push(`  total: ${formatBytes(total)}`);
+		const incomplete = caches.some((c) => c.bytes === void 0) || outputs?.workspaces.some((w) => w.bytes === null);
+		lines.push(`  total: ${incomplete ? "at least " : ""}${formatBytes(total)}`);
 		const doomed = caches.filter((c) => c.willEmpty);
 		if (doomed.length) {
 			const doomedBytes = doomed.reduce((n, c) => n + (c.bytes ?? 0), 0);
-			lines.push(`  would empty ${doomed.length} of these (${formatBytes(doomedBytes)})`);
+			lines.push(`  would empty ${doomed.length} of these (${doomed.some((c) => c.bytes === void 0) ? "at least " : ""}${formatBytes(doomedBytes)})`);
 		}
 		const clearing = outputs?.workspaces.filter((w) => w.willClear) ?? [];
 		if (clearing.length) {
@@ -1093,6 +821,29 @@ function cacheLines(caches, workspaceOutputs) {
 	}
 	return lines;
 }
+const BUILD_STATE_DIRS_SHOWN = 4;
+function buildStateLine(state) {
+	if (!state?.dirs.length) return null;
+	const shown = state.dirs.slice(0, BUILD_STATE_DIRS_SHOWN).map((dir) => `${dir.path} ${sizeText(dir.bytes)}`);
+	const more = state.dirs.length > BUILD_STATE_DIRS_SHOWN ? ", ..." : "";
+	return `              in-tree build state ${sizeText(state.bytes)}: ${shown.join(", ")}${more}`;
+}
+function unlistedWorktreeLines(sweep) {
+	const unlisted = sweep?.unlisted ?? [];
+	if (!unlisted.length) return [];
+	const lines = [`Directories under .worktrees that git does not list as worktrees (${unlisted.length}) - reported, never removed:`];
+	for (const dir of unlisted) {
+		lines.push(`  ${dir.path} (${sizeText(dir.bytes)})`);
+		lines.push(`              ${unlistedWorktreeDetail(dir)}`);
+	}
+	return lines;
+}
+function unlistedWorktreeDetail(dir) {
+	return `git worktree list in ${dir.repository} does not show it, so gc cannot tell whether it holds work; look through it, then remove it with \`${unlistedWorktreeRemedy(dir)}\``;
+}
+function unlistedWorktreeRemedy(dir) {
+	return `rm -rf '${dir.path.replaceAll("'", "'\\''")}'`;
+}
 function worktreeSweepLines(sweep) {
 	if (!sweep || !sweep.idle && !sweep.worktrees.length) return [];
 	const removable = sweep.worktrees.filter((w) => !w.skipped);
@@ -1103,8 +854,10 @@ function worktreeSweepLines(sweep) {
 	for (const w of sweep.worktrees) {
 		const age = w.idleDays === null ? "" : ` (idle ${w.idleDays}d)`;
 		lines.push(`  ${w.path}${age}`);
+		const buildState = buildStateLine(w.buildState);
+		if (buildState) lines.push(buildState);
 		const note = worktreePullRequestNote(w);
-		lines.push(w.skipped ? `              kept: ${w.skipped}${note && !w.skipped.includes(note) ? ` (${note})` : ""}` : `              would be REMOVED by \`stim worktree remove\`: ${worktreeRemovalReason(w)}`);
+		lines.push(w.skipped ? `              kept: ${w.skipped}${note && !w.skipped.includes(note) ? ` (${note})` : ""}` : `              would be REMOVED by \`stim worktree remove\`: ${worktreeRemovalReason(w, sweep)}`);
 	}
 	if (removable.length) lines.push("              --delete runs it without --force; use, idleness and HEAD are re-checked under its removal locks.");
 	return lines;
@@ -1127,7 +880,22 @@ function jsonPullRequest(lookup) {
 		containsHead: pr.containsHead
 	} : null;
 }
-function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedPorts = [], invalidProjects = [], orphanedWorkspaces = [], worktreeSweep = null, parkedSims = [], parkedAvds = [], parkedHostedDevices = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], staleLedgerEntries = [], staleEasLedgerEntries = [], staleStatusCaches = [], buildLocks = {
+function linkedWorktreesJson(sweep) {
+	if (!sweep) return [];
+	return sweep.worktrees.map((w) => ({
+		path: w.path,
+		idleDays: w.idleDays,
+		mergedInto: w.merge?.merged ? w.merge.into : null,
+		pullRequest: jsonPullRequest(w.pullRequest),
+		pullRequestUnknown: w.pullRequest && "unavailable" in w.pullRequest ? w.pullRequest.unavailable : null,
+		willRemove: w.skipCode === null,
+		reason: w.skipCode,
+		detail: w.skipped ?? worktreeRemovalReason(w, sweep),
+		eligibleAt: w.eligibleAt === null ? null : new Date(w.eligibleAt).toISOString(),
+		buildState: w.buildState ?? null
+	}));
+}
+function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedPorts = [], invalidProjects = [], orphanedWorkspaces = [], worktreeSweep = null, parkedSims = [], parkedAvds = [], parkedHostedDevices = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], finishedDevices = [], ownedDeviceDisk = [], staleDeviceRecords = [], staleLedgerEntries = [], staleEasLedgerEntries = [], staleStatusCaches = [], buildLocks = {
 	stale: [],
 	live: [],
 	unresolved: []
@@ -1143,7 +911,7 @@ function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedP
 	orphaned: [],
 	notices: [],
 	deletionSafe: true
-}, workspaceOutputs = null, workspaceLogs = [], recordings = [], agentDeviceUsage = null, swiftpmCacheUsage = null, caches = [], memory = null }) {
+}, workspaceOutputs = null, workspaceLogs = [], recordings = [], agentDeviceUsage = null, swiftpmCacheUsage = null, machineCaches = null, tempLeftovers = null, gradleVersions = null, caches = [], memory = null }) {
 	return {
 		...archives ? {
 			archived: archives.records,
@@ -1161,16 +929,12 @@ function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedP
 			projectRoot,
 			bytes: bytes ?? null
 		})),
-		linkedWorktrees: (worktreeSweep?.worktrees ?? []).map((w) => ({
-			path: w.path,
-			idleDays: w.idleDays,
-			mergedInto: w.merge?.merged ? w.merge.into : null,
-			pullRequest: jsonPullRequest(w.pullRequest),
-			pullRequestUnknown: w.pullRequest && "unavailable" in w.pullRequest ? w.pullRequest.unavailable : null,
-			willRemove: w.skipCode === null,
-			reason: w.skipCode,
-			detail: w.skipped ?? worktreeRemovalReason(w),
-			eligibleAt: w.eligibleAt === null ? null : new Date(w.eligibleAt).toISOString()
+		linkedWorktrees: linkedWorktreesJson(worktreeSweep),
+		unlistedWorktreeDirectories: (worktreeSweep?.unlisted ?? []).map((dir) => ({
+			path: dir.path,
+			repository: dir.repository,
+			bytes: dir.bytes,
+			remedy: unlistedWorktreeRemedy(dir)
 		})),
 		parkedSimulators: parkedSims.map(({ udid, name, model, runtime, parkedAt, app, bytes, listed }) => ({
 			udid,
@@ -1214,6 +978,16 @@ function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedP
 			idleDays: d.idleDays,
 			bytes: d.bytes ?? null
 		})),
+		finishedDevices: finishedDevices.map((d) => ({
+			kind: d.kind,
+			id: d.id,
+			name: d.name,
+			project: d.project,
+			slot: d.slot ?? null,
+			bytes: d.bytes ?? null,
+			reason: d.reason
+		})),
+		ownedDeviceDisk,
 		staleDeviceRecords: staleDeviceRecords.map((r) => ({
 			kind: r.kind,
 			id: r.id,
@@ -1325,12 +1099,179 @@ function gcReportSections({ archives, skipped = [], deadProjects = [], orphanedP
 		})),
 		agentDevice: agentDeviceUsage,
 		swiftpmCache: swiftpmCacheUsage,
+		machineCaches,
+		tempLeftovers: tempLeftoverSection(tempLeftovers),
+		gradleVersions,
 		memory: memory?.processes ?? [],
 		watchmanRoots: memory?.watchmanRoots ?? [],
 		memoryNotices: (memory?.notices ?? []).map((message) => ({ message }))
 	};
 }
 //#endregion
+//#region src/commands/gc/worktree-sizes.ts
+const SIZE_TIMEOUT_MS = 3e4;
+const BUILD_STATE_MAX_AGE_MS = 36e5;
+const BUILD_STATE_TIMEOUT_MS = 1e4;
+const BUILD_STATE_CONCURRENCY = 4;
+const PNPM_STORE = ".pnpm-store";
+const WORKTREES_DIR = ".worktrees";
+function isDirectory(path) {
+	try {
+		return lstatSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function inside(root, path) {
+	const rel = relative(root, path);
+	return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+async function buildStateDirs(path, keys) {
+	const entries = await listWorktreesAsync(path);
+	const own = keys.filter((key) => matchWorktreeEntry(entries, key)?.path === path);
+	const root = canonicalPath(path);
+	const worktree = {
+		path,
+		linked: true,
+		keys: own
+	};
+	const dirs = /* @__PURE__ */ new Map();
+	const add = (dir) => {
+		if (!isDirectory(dir)) return;
+		const real = canonicalPath(dir);
+		if (inside(root, real) && !dirs.has(real)) dirs.set(real, dir);
+	};
+	for (const kind of ["build", "dependencies"]) for (const base of appRoots(worktree, kind)) for (const dir of ARTIFACT_DIRS[kind]) add(join(base, dir));
+	add(join(path, PNPM_STORE));
+	return [...dirs.keys()];
+}
+function cachedSize(dir, now) {
+	const cached = readDiskUsage(dir);
+	if (!cached) return null;
+	const at = Date.parse(cached.measuredAt);
+	if (now - at >= BUILD_STATE_MAX_AGE_MS) return null;
+	try {
+		return statSync(dir).mtimeMs > at ? null : cached.bytes;
+	} catch {
+		return null;
+	}
+}
+async function duSize(dir) {
+	let out;
+	try {
+		out = await getExecutor().runFileAsync("du", ["-sk", dir], {
+			timeoutMs: BUILD_STATE_TIMEOUT_MS,
+			killSignal: "SIGKILL"
+		});
+	} catch (error) {
+		const stdout = error instanceof Error && "stdout" in error ? error.stdout : null;
+		out = typeof stdout === "string" ? stdout : "";
+	}
+	const kb = /^(\d+)\t/.exec(out)?.[1];
+	return kb ? Number(kb) * 1024 : null;
+}
+async function eachLimited(items, limit, run) {
+	const queue = items[Symbol.iterator]();
+	const worker = async () => {
+		for (const item of queue) await run(item);
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+}
+/**
+* Sizes the regenerable directories maintenance clears and a project-local `.pnpm-store` in each worktree of the
+* sweep, from the disk-usage cache while an entry is under an hour old and no entry was added to or removed from the
+* directory since. Stale directories are measured with one `du` each, at most 4 at once and 10 seconds each, so a
+* slow tree delays only itself; a directory du could not measure in time is reported unmeasured (null). Also lists
+* the directories directly under a repository's `.worktrees/` that are no git worktree at all.
+*/
+async function measureWorktreeSweep(sweep, operation) {
+	const now = Date.now();
+	const pending = [];
+	for (const candidate of sweep.worktrees) {
+		if (candidate.skipCode === "not-a-worktree") continue;
+		const dirs = await buildStateDirs(candidate.path, candidate.keys);
+		pending.push({
+			candidate,
+			root: canonicalPath(candidate.path),
+			dirs,
+			sizes: new Map(dirs.map((dir) => [dir, cachedSize(dir, now)]))
+		});
+	}
+	const due = pending.flatMap(({ sizes }) => [...sizes].flatMap(([dir, bytes]) => bytes === null ? [{
+		dir,
+		sizes
+	}] : []));
+	const worktrees = new Set(due.map(({ sizes }) => sizes)).size;
+	if (due.length) phase("worktrees", `measuring the build state of ${plural(worktrees, "worktree")}`, operation);
+	await eachLimited(due, BUILD_STATE_CONCURRENCY, async ({ dir, sizes }) => {
+		const measuredAt = (/* @__PURE__ */ new Date()).toISOString();
+		const bytes = await duSize(dir);
+		if (bytes === null) return;
+		sizes.set(dir, bytes);
+		operation?.signal.throwIfAborted();
+		writeCacheFile(diskUsageCacheFile(dir), {
+			path: dir,
+			measuredAt,
+			bytes
+		});
+	});
+	for (const { candidate, root, dirs, sizes } of pending) {
+		const entries = dirs.map((dir) => ({
+			path: relative(root, dir).split(sep).join("/"),
+			bytes: sizes.get(dir) ?? null
+		}));
+		candidate.buildState = {
+			bytes: entries.every((dir) => dir.bytes !== null) ? entries.reduce((sum, dir) => sum + (dir.bytes ?? 0), 0) : null,
+			dirs: entries.toSorted((a, b) => (b.bytes ?? 0) - (a.bytes ?? 0))
+		};
+	}
+	sweep.unlisted = await unlistedWorktreeDirs();
+	return sweep;
+}
+/** Whether `path` is a checkout git still knows: its own `.git` directory, or a `.git` file whose gitdir exists. */
+function hasLiveGitDir(path) {
+	const dotGit = join(path, ".git");
+	let text;
+	try {
+		if (lstatSync(dotGit).isDirectory()) return true;
+		text = readFileSync(dotGit, "utf-8");
+	} catch {
+		return false;
+	}
+	const gitdir = /^gitdir:\s*(.+)$/m.exec(text)?.[1]?.trim();
+	return Boolean(gitdir) && existsSync(resolve(dirname(dotGit), gitdir ?? ""));
+}
+async function unlistedWorktreeDirs() {
+	const repositories = /* @__PURE__ */ new Map();
+	for (const root of await candidateRootsAsync()) {
+		const { entries, ...source } = await resolveSourceCheckoutAsync(root);
+		if ("refusal" in source || repositories.has(source.path)) continue;
+		repositories.set(source.path, entries.map((entry) => canonicalPath(entry.path)));
+	}
+	const found = [];
+	for (const [repository, listed] of repositories) {
+		const parent = join(repository, WORKTREES_DIR);
+		let names;
+		try {
+			names = readdirSync(parent);
+		} catch {
+			continue;
+		}
+		for (const name of names.toSorted()) {
+			const path = join(parent, name);
+			if (!isDirectory(path) || hasLiveGitDir(path)) continue;
+			const real = canonicalPath(path);
+			if (listed.some((entry) => entry === real || entry.startsWith(`${real}${sep}`))) continue;
+			found.push({
+				path,
+				repository,
+				bytes: await measuredDirectorySizeAsync(path, { timeoutMs: SIZE_TIMEOUT_MS })
+			});
+		}
+	}
+	return found;
+}
+//#endregion
 //#region src/commands/gc/ledger.ts
 /** `sims` must be a complete listing, unavailable simulators included, taken after `ledger` was read. */
 function findStaleLedgerEntries(ledger, sims) {
@@ -1564,266 +1505,6 @@ async function trimWorkspaceLogs(entries) {
 	return failures;
 }
 //#endregion
-//#region src/commands/gc/inventory.ts
-const IOS_SIMULATOR_PLATFORM = "com.apple.platform.iphonesimulator";
-function text(value) {
-	return typeof value === "string" && value.length > 0 ? value : null;
-}
-function parseSimRuntimeList(jsonOutput) {
-	const parsed = JSON.parse(jsonOutput);
-	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Expected simctl runtime list to return a JSON object.");
-	const runtimes = [];
-	for (const [key, value] of Object.entries(parsed)) {
-		if (!isJsonObject(value)) continue;
-		const entry = value;
-		if (entry.platformIdentifier !== IOS_SIMULATOR_PLATFORM) continue;
-		runtimes.push({
-			identifier: text(entry.identifier) ?? key,
-			runtimeIdentifier: text(entry.runtimeIdentifier),
-			version: text(entry.version),
-			build: text(entry.build),
-			sizeBytes: typeof entry.sizeBytes === "number" && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null,
-			deletable: entry.deletable === true,
-			lastUsedAt: text(entry.lastUsedAt)
-		});
-	}
-	return runtimes;
-}
-function unlistedRuntimes(jsonOutput, images) {
-	const known = new Set(images.map((image) => image.runtimeIdentifier));
-	const parsed = JSON.parse(jsonOutput);
-	if (!Array.isArray(parsed.runtimes)) throw new Error("Expected simctl list runtimes to return a runtimes array.");
-	return parsed.runtimes.flatMap((value) => {
-		if (value === null || typeof value !== "object") return [];
-		const entry = value;
-		const identifier = text(entry.identifier);
-		if (!identifier || !/\.iOS-/.test(identifier) || known.has(identifier)) return [];
-		return [{
-			identifier,
-			runtimeIdentifier: identifier,
-			version: text(entry.version),
-			build: text(entry.buildversion),
-			sizeBytes: null,
-			deletable: false,
-			lastUsedAt: null
-		}];
-	});
-}
-function modelName(deviceTypeIdentifier) {
-	return deviceTypeIdentifier.replace(/^com\.apple\.CoreSimulator\.SimDeviceType\./, "").replaceAll("-", " ");
-}
-function sdkmanagerCommand(pkg) {
-	const tool = androidToolPath("sdkmanager");
-	return `${tool === "sdkmanager" ? tool : JSON.stringify(tool)} --uninstall ${JSON.stringify(pkg)}`;
-}
-function buildInventory({ sims, avds, runtimes, systemImages, config, deadProjects = [] }) {
-	const dead = new Set(deadProjects);
-	const assigned = /* @__PURE__ */ new Map();
-	for (const [project, record] of Object.entries(config?.projects ?? {})) {
-		if (dead.has(project)) continue;
-		let slots;
-		try {
-			slots = projectDeviceSlots(record);
-		} catch {
-			continue;
-		}
-		for (const { slot, platforms } of slots) {
-			if (platforms.ios?.deviceUdid) assigned.set(`ios:${platforms.ios.deviceUdid}`, {
-				project,
-				slot
-			});
-			if (platforms.android?.avdName) assigned.set(`android:${platforms.android.avdName}`, {
-				project,
-				slot
-			});
-		}
-	}
-	const parked = /* @__PURE__ */ new Set([...readParked("ios", { config }).map((sim) => `ios:${sim.udid}`), ...readParked("android", { config }).map((avd) => `android:${avd.name}`)]);
-	const owner = (key, name, created) => {
-		const workspace = assigned.get(key);
-		if (workspace && created()) return {
-			owner: "workspace",
-			project: workspace.project,
-			slot: workspace.slot
-		};
-		if (parked.has(key)) return {
-			owner: "parked",
-			project: null,
-			slot: null
-		};
-		if (!name.startsWith("stim-")) return {
-			owner: "user",
-			project: null,
-			slot: null
-		};
-		return {
-			owner: created() ? "orphaned" : "otherStimHome",
-			project: null,
-			slot: null
-		};
-	};
-	const devices = [...sims.map((sim) => ({
-		kind: "ios",
-		id: sim.udid,
-		name: sim.name,
-		model: modelName(sim.deviceTypeIdentifier),
-		runtime: sim.runtime,
-		state: sim.state,
-		lastUsedAt: sim.lastUsedAt ?? null,
-		bytes: sim.dataPathSize ?? null,
-		directory: sim.dataPath ? sim.dataPath.replace(/\/data\/?$/, "") : null,
-		...owner(`ios:${sim.udid}`, sim.name, () => isStimOwnedSim({
-			udid: sim.udid,
-			name: sim.name
-		}))
-	})), ...avds.map((avd) => ({
-		kind: "android",
-		id: avd.name,
-		name: avd.name,
-		model: avd.deviceProfile,
-		runtime: avd.systemImage,
-		state: null,
-		lastUsedAt: avd.lastUsedAt,
-		bytes: null,
-		directory: avd.directory,
-		...owner(`android:${avd.name}`, avd.name, () => isStimOwnedAvd(avd.name))
-	}))];
-	const simsByRuntime = /* @__PURE__ */ new Map();
-	for (const sim of sims) simsByRuntime.set(sim.runtime, (simsByRuntime.get(sim.runtime) ?? 0) + 1);
-	const avdsByImage = /* @__PURE__ */ new Map();
-	for (const avd of avds) if (avd.systemImage) avdsByImage.set(avd.systemImage, (avdsByImage.get(avd.systemImage) ?? 0) + 1);
-	return {
-		devices,
-		runtimes: runtimes.map((runtime) => ({
-			identifier: runtime.identifier,
-			runtimeIdentifier: runtime.runtimeIdentifier,
-			version: runtime.version,
-			build: runtime.build,
-			bytes: runtime.sizeBytes,
-			lastUsedAt: runtime.lastUsedAt,
-			deviceCount: runtime.runtimeIdentifier ? simsByRuntime.get(runtime.runtimeIdentifier) ?? 0 : 0,
-			command: runtime.deletable ? `xcrun simctl runtime delete ${runtime.identifier}` : null
-		})),
-		systemImages: systemImages.map((image) => ({
-			package: image.pkg,
-			directory: image.directory,
-			avdCount: avdsByImage.get(image.pkg) ?? 0,
-			command: sdkmanagerCommand(image.pkg)
-		}))
-	};
-}
-function modifiedAt(path) {
-	try {
-		return statSync(path).mtime.toISOString();
-	} catch {
-		return null;
-	}
-}
-function isMissing(error) {
-	const code = error.code;
-	return code === "ENOENT" || code === "ENOTDIR";
-}
-function unreadableNotice(what, error) {
-	const notice = `${what} not listed: ${describeError(error)}`;
-	if (process.platform !== "darwin" || error.code !== "EPERM") return notice;
-	return `${notice}. macOS privacy protection blocked the read; allow ${process.env.STIM_DESKTOP_APP ? "Stim Desktop" : "the app that runs stim"} under System Settings > Privacy & Security > Files and Folders (Removable Volumes for an external disk) or Full Disk Access`;
-}
-function listAvdRecords(notices, roots = avdStorageRoots()) {
-	const records = /* @__PURE__ */ new Map();
-	for (const root of roots) {
-		let names;
-		try {
-			names = readdirSync(root);
-		} catch (error) {
-			if (!isMissing(error)) notices.push(unreadableNotice(`AVDs in ${root}`, error));
-			continue;
-		}
-		for (const entry of names) {
-			if (!entry.endsWith(".ini")) continue;
-			const name = entry.slice(0, -4);
-			if (records.has(name)) continue;
-			let ini;
-			try {
-				ini = readFileSync(join(root, entry), "utf8");
-			} catch (error) {
-				if (!isMissing(error)) notices.push(unreadableNotice(`AVD ${name}`, error));
-				continue;
-			}
-			let directory = null;
-			let config = "";
-			let unreadable = null;
-			for (const candidate of avdIniPaths(root, ini)) try {
-				config = readFileSync(join(candidate, "config.ini"), "utf8");
-				directory = candidate;
-				break;
-			} catch (error) {
-				if (!isMissing(error)) unreadable ??= error;
-			}
-			if (!directory && unreadable) notices.push(unreadableNotice(`details of AVD ${name}`, unreadable));
-			records.set(name, {
-				name,
-				directory,
-				systemImage: parseAvdSystemImage(config),
-				deviceProfile: parseAvdDeviceProfile(config),
-				lastUsedAt: directory ? modifiedAt(join(directory, "hardware-qemu.ini")) : null
-			});
-		}
-	}
-	return [...records.values()];
-}
-function simctl(args) {
-	return getExecutor().runFile("xcrun", ["simctl", ...args], {
-		timeoutMs: DEVICE_LIST_TIMEOUT_MS,
-		killSignal: "SIGKILL"
-	});
-}
-function collectInventory(config, deadProjects) {
-	const notices = [];
-	let sims = [];
-	let runtimes = [];
-	if (process.platform === "darwin") {
-		try {
-			sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
-		} catch (error) {
-			notices.push(`simulators not listed: ${describeError(error)}`);
-		}
-		try {
-			runtimes = parseSimRuntimeList(simctl([
-				"runtime",
-				"list",
-				"-j"
-			]));
-		} catch (error) {
-			notices.push(`simulator runtime images not listed: ${describeError(error)}`);
-		}
-		try {
-			runtimes.push(...unlistedRuntimes(simctl([
-				"list",
-				"runtimes",
-				"-j"
-			]), runtimes));
-		} catch (error) {
-			notices.push(`simulator runtimes not listed: ${describeError(error)}`);
-		}
-	}
-	const imagesRoot = join(androidHome(), "system-images");
-	const images = listInstalledSystemImages((error) => notices.push(unreadableNotice("Android system images", error))).map((image) => ({
-		pkg: image.pkg,
-		directory: join(imagesRoot, `android-${image.api}`, image.tag, image.arch)
-	}));
-	return {
-		...buildInventory({
-			sims,
-			avds: listAvdRecords(notices),
-			runtimes,
-			systemImages: images,
-			config,
-			deadProjects
-		}),
-		notices
-	};
-}
-//#endregion
 //#region src/commands/gc/hosted-devices.ts
 function collectParkedHostedDevices({ olderThanDays = null, now = Date.now() } = {}) {
 	const notices = [];
@@ -2085,6 +1766,14 @@ async function deleteParkedHostedDevices(devices, { listAvds: list = listAvds }
 }
 //#endregion
 //#region src/commands/gc.ts
+function readGcReport(options = {}, deps = {}) {
+	return sweep({
+		olderThan: options.olderThan,
+		cache: options.cache,
+		worktrees: options.worktrees,
+		json: true
+	}, deps, true);
+}
 function removeInvalidProjectEntries(invalidProjects) {
 	for (const path of invalidProjects) {
 		removeProject(path);
@@ -2092,8 +1781,8 @@ function removeInvalidProjectEntries(invalidProjects) {
 		recordGcResult("project", "done", path);
 	}
 }
-function collectGcMemory(scope) {
-	return memorySweepIsScoped() ? Promise.resolve(scopedMemoryReport()) : collectMemoryReport(scope, true);
+function collectGcMemory(scope, env, operation) {
+	return memorySweepIsScoped(env) ? Promise.resolve(scopedMemoryReport()) : collectMemoryReport(scope, true, operation);
 }
 function classifyProjectEntries(cfg, mountedVolumes) {
 	const deadProjects = [];
@@ -2132,14 +1821,16 @@ function removedWholeWorkspaceDirs() {
 	const { orphaned } = collectOrphanedWorkspaces(Object.keys(cfg?.projects ?? {}), mountedVolumes, { measure: false });
 	return [...orphaned.map((entry) => entry.dir), ...deadProjects.map(workspaceDir)];
 }
-async function collectGcReport({ olderThan = null, cache = null, worktrees = false, now = Date.now(), lastTouched = workspaceLastUsed } = {}, deps = {}) {
+async function collectGcReport({ olderThan = null, cache = null, worktrees = false, refresh = true, now = Date.now(), lastTouched = workspaceLastUsed } = {}, deps = {}) {
+	const operation = deps.operation;
+	const env = operation?.env ?? process.env;
 	const scope = typeof cache === "string" && cache.trim() ? cache : null;
 	const all = scope !== null && olderThan === null;
 	const withWorkspaces = includesWorkspaceOutputs(scope);
-	const selected = selectCaches(discoverCaches(), scope).filter((c) => !withWorkspaces || !isInsideWorkspaces(c.dir));
-	if (selected.length) phase("caches", `measuring ${plural(selected.length, "shared cache")}`);
-	const sized = sizeCaches(selected);
-	const caches = scope === null ? previewScopedEmptying(sized) : planCacheEmptying(sized, all);
+	const selected = selectCaches(discoverCaches(env, operation?.cwd), scope).filter((c) => !withWorkspaces || !isInsideWorkspaces(c.dir));
+	if (selected.length) phase("caches", `measuring ${plural(selected.length, "shared cache")}`, operation);
+	const sized = await sizeCaches(selected);
+	const caches = scope === null ? previewScopedEmptying(sized, env) : planCacheEmptying(sized, all, env);
 	if (scope) return {
 		archives: includesArchives(scope) ? collectArchives(scope, olderThan, now) : void 0,
 		skipped: [],
@@ -2149,6 +1840,8 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		orphanedDevices: [],
 		unverifiedDevices: [],
 		staleDevices: [],
+		finishedDevices: [],
+		ownedDeviceDisk: [],
 		staleDeviceRecords: [],
 		staleLedgerEntries: [],
 		staleEasLedgerEntries: [],
@@ -2175,17 +1868,17 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			notices: [],
 			deletionSafe: true
 		},
-		parkedSims: includesParkedDevices(scope) ? collectParkedSims(deps, {
+		parkedSims: includesParkedDevices(scope) ? await collectParkedSims(deps, {
 			olderThanDays: olderThan,
 			now
 		}) : [],
-		parkedAvds: includesParkedDevices(scope) ? collectParkedAvds(deps, {
+		parkedAvds: includesParkedDevices(scope) ? await collectParkedAvds(deps, {
 			olderThanDays: olderThan,
 			now
 		}) : [],
 		parkedHostedDevices: [],
 		caches,
-		workspaceOutputs: withWorkspaces ? collectWorkspaceOutputs({
+		workspaceOutputs: withWorkspaces ? await collectWorkspaceOutputs({
 			olderThan,
 			now,
 			exclude: isWorkspacesScope(scope) ? removedWholeWorkspaceDirs() : []
@@ -2197,22 +1890,37 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			now
 		}) : [],
 		worktreeSweep: null,
-		memory: memoryCacheKind(scope) ? await collectGcMemory(memoryScope(scope)) : null,
+		memory: memoryCacheKind(scope) ? await collectGcMemory(memoryScope(scope), env, operation) : null,
 		agentDeviceUsage: null,
 		swiftpmCacheUsage: null,
+		machineCaches: null,
+		tempLeftovers: null,
+		gradleVersions: includesGradleVersions(scope) ? await collectGradleVersions({
+			olderThanDays: olderThan,
+			now,
+			operation
+		}) : null,
 		cacheScope: scope,
 		olderThan,
 		all
 	};
-	phase("agent-device", "measuring report-only state");
-	const agentDeviceUsage = await getAgentDeviceUsage();
-	phase("SwiftPM cache", "measuring report-only state");
-	const swiftpmCacheUsage = await getSwiftpmCacheUsage();
+	phase("agent-device", "measuring report-only state", operation);
+	const agentDeviceUsage = await getAgentDeviceUsage({ operation });
+	phase("SwiftPM cache", "measuring report-only state", operation);
+	const swiftpmCacheUsage = await getSwiftpmCacheUsage({ operation });
+	phase("machine caches", "measuring report-only state", operation);
+	const machineCaches = await getMachineCacheReport(agentDeviceUsage, { operation });
+	if (!deviceSweepIsScoped(env)) phase("TMPDIR", "checking recognized leftovers", operation);
+	const tempLeftovers = await collectTempLeftovers({
+		now,
+		env,
+		signal: operation?.signal
+	});
 	const mountedVolumes = listMountedVolumes();
 	const cfg = loadConfig$1();
 	let easSessionSweep = deps.precollectedEasSessionSweep;
 	if (!easSessionSweep) try {
-		easSessionSweep = collectEasSessionSweep(cfg, deps);
+		easSessionSweep = await collectEasSessionSweep(cfg, deps);
 	} catch (error) {
 		easSessionSweep = {
 			projectScope: null,
@@ -2221,16 +1929,16 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			deletionSafe: false
 		};
 	}
-	const parkedSims = collectParkedSims(deps, {
+	const parkedSims = await collectParkedSims(deps, {
 		olderThanDays: olderThan,
 		now
 	});
-	const parkedAvds = collectParkedAvds(deps, {
+	const parkedAvds = await collectParkedAvds(deps, {
 		olderThanDays: olderThan,
 		now
 	});
 	const { deadProjects, invalidProjects, skipped } = classifyProjectEntries(cfg, mountedVolumes);
-	const workspaceDirs = collectOrphanedWorkspaces(Object.keys(cfg?.projects ?? {}), mountedVolumes);
+	const workspaceDirs = await collectOrphanedWorkspaces(Object.keys(cfg?.projects ?? {}), mountedVolumes);
 	skipped.push(...workspaceDirs.skipped);
 	const statusCaches = collectStaleStatusCaches(mountedVolumes);
 	skipped.push(...statusCaches.skipped);
@@ -2245,16 +1953,24 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	let staleDeviceRecords = [];
 	let staleLedgerEntries = staleBrowserProfiles(readCreatedDevices$1());
 	let idleDevices = [];
-	const unsweepableReason = cfg === null ? "no Stim config found" : deviceSweepIsScoped() ? "STIM_HOME scopes this config, but simulators and AVDs are machine-global" : null;
-	phase("devices", "listing simulators and emulators");
+	let listed = null;
+	let deviceDisk = [];
+	const avdSizes = /* @__PURE__ */ new Map();
+	const avdSize = (dir, options) => {
+		let bytes = avdSizes.get(dir);
+		if (bytes === void 0) avdSizes.set(dir, bytes = Promise.resolve((deps.directorySize ?? directorySizeAsync)(dir, options)));
+		return bytes;
+	};
+	const unsweepableReason = cfg === null ? "no Stim config found" : deviceSweepIsScoped(env) ? "STIM_HOME scopes this config, but simulators and AVDs are machine-global" : null;
+	phase("devices", "listing simulators and emulators", operation);
 	if (unsweepableReason) {
 		let simNames = [];
 		let avdNames = [];
 		try {
-			simNames = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }).map((s) => s.name);
+			simNames = (await listAllIosSimsAsync({ timeoutMs: DEVICE_LIST_TIMEOUT_MS })).map((s) => s.name);
 		} catch {}
 		try {
-			avdNames = listAvds({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+			avdNames = await listAvdsAsync({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
 		} catch {}
 		deviceSweepNotices.push(...describeUnverifiableDevices(simNames, avdNames, { reason: unsweepableReason }));
 	} else {
@@ -2262,7 +1978,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		let simsChecked = true;
 		const ledger = readCreatedDevices$1();
 		try {
-			const allSims = listAllIosSims({
+			const allSims = await listAllIosSimsAsync({
 				timeoutMs: DEVICE_LIST_TIMEOUT_MS,
 				includeUnavailable: true
 			});
@@ -2275,7 +1991,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		let avds = [];
 		let avdsChecked = true;
 		try {
-			avds = listAvds({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+			avds = await listAvdsAsync({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
 		} catch {
 			avdsChecked = false;
 			deviceSweepNotices.push(`android device sweep skipped: emulator tooling did not answer within ${DEVICE_LIST_TIMEOUT_MS / 1e3}s`);
@@ -2302,14 +2018,30 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			const directories = device.kind === "android" && !registeredAvds.has(device.id) ? orphanedAvdDirectories.filter((entry) => entry.name === device.id) : [];
 			return directories.length ? directories.map(({ directory }) => Object.assign({}, device, { directory })) : [device];
 		});
-		orphanedDevices = withAndroidAvdSizes(found.orphaned.flatMap((device) => {
+		orphanedDevices = await withAndroidAvdSizes(found.orphaned.flatMap((device) => {
 			const directories = device.kind === "android" ? orphanedAvdDirectories.filter((entry) => entry.name === device.name) : [];
 			return directories.length ? directories.map((orphanedDirectory) => Object.assign({}, device, { orphanedDirectory })) : [device];
 		}), {
 			avdDirectory: deps.avdDirectory ?? ownedAvdDirectory,
-			size: deps.directorySize ?? directorySize
+			size: avdSize
 		});
-		idleDevices = collectIdleDevices(cfg, sims, deadProjects, now);
+		idleDevices = operation ? await collectIdleDevicesAsync(cfg, sims, deadProjects, now, env) : collectIdleDevices(cfg, sims, deadProjects, now);
+		if (simsChecked || avdsChecked) {
+			const lists = {
+				sims,
+				avds: [...registeredAvds]
+			};
+			listed = lists;
+			let unmeasured = 0;
+			deviceDisk = ownedDeviceDisk(await ownedDeviceUsage((_target, workspace) => {
+				if (workspace) unmeasured++;
+			}, {
+				sims: () => lists.sims,
+				avds: () => lists.avds,
+				avdDirectory: deps.avdDirectory ?? ownedAvdDirectory,
+				size: async (dir) => await avdSize(dir, { timeoutMs: 5e3 }) || null
+			}), { android: unmeasured });
+		}
 		staleDeviceRecords = findStaleDeviceRecords({
 			config: cfg,
 			sims,
@@ -2318,7 +2050,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			simsChecked,
 			avdsChecked
 		});
-		if (olderThan !== null) staleDevices = withAndroidAvdSizes(findStaleProjectDevices({
+		if (olderThan !== null) staleDevices = await withAndroidAvdSizes(findStaleProjectDevices({
 			config: cfg,
 			sims,
 			avds,
@@ -2328,13 +2060,20 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			deadProjects
 		}), {
 			avdDirectory: deps.avdDirectory ?? ownedAvdDirectory,
-			size: deps.directorySize ?? directorySize
+			size: avdSize
 		});
 	}
 	const locks = listBuildLocks();
 	const slots = listBuildSlots();
 	const goneWorkspaceDirs = [...workspaceDirs.orphaned.map((entry) => entry.dir), ...deadProjects.map(workspaceDir)];
 	const deviceLeases = collectDeviceLeases(now);
+	const worktreeSweep = await measureWorktreeSweep(await collectWorktreeSweep({
+		idle: worktrees,
+		olderThan,
+		now,
+		refresh,
+		operation
+	}), operation);
 	return {
 		skipped,
 		deadProjects,
@@ -2370,7 +2109,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		deviceSweepNotices,
 		easSessionSweep,
 		caches,
-		workspaceOutputs: collectWorkspaceOutputs({
+		workspaceOutputs: await collectWorkspaceOutputs({
 			olderThan,
 			now,
 			exclude: goneWorkspaceDirs
@@ -2381,17 +2120,22 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			olderThan,
 			now
 		}, goneWorkspaceDirs),
-		worktreeSweep: await collectWorktreeSweep({
-			idle: worktrees,
-			olderThan,
+		worktreeSweep,
+		finishedDevices: listed ? collectFinishedDevices({
+			config: cfg,
+			...listed,
+			sweep: worktreeSweep,
 			now
-		}),
+		}) : [],
+		ownedDeviceDisk: deviceDisk,
 		memory: await collectGcMemory({
 			watchman: true,
 			gradle: true
-		}),
+		}, env, operation),
 		agentDeviceUsage,
 		swiftpmCacheUsage,
+		machineCaches,
+		tempLeftovers,
 		cacheScope: null,
 		olderThan,
 		all
@@ -2446,11 +2190,17 @@ async function maintenanceGuardedSweep(opts, deps) {
 		if (claim) (0, ownership_claim_exports.releaseClaim)(claim);
 	}
 }
-async function sweep(opts, deps) {
+async function sweep(opts, deps, reportOnly = false) {
+	const core = (dependencies) => runGcCore(opts, dependencies, reportOnly);
 	if (opts.cache && (opts.worktrees || opts.idle !== void 0)) {
 		const flag = opts.worktrees ? "--worktrees" : "--idle";
 		const message = opts.worktrees ? "--cache acts only on the named caches, and --worktrees sweeps linked worktrees." : "--cache acts only on the named caches, and --idle shuts down idle owned devices.";
 		const remedy = `Run \`stim gc ${flag}${opts.worktrees ? "" : " <duration>"}\` and \`stim gc --cache <name>\` separately.`;
+		if (reportOnly) return {
+			code: "STIM_BAD_ARG",
+			message,
+			remedy
+		};
 		console.error(chalk.red(message));
 		console.error(chalk.dim(remedy));
 		console.error(chalk.red("failed: STIM_BAD_ARG"));
@@ -2465,6 +2215,11 @@ async function sweep(opts, deps) {
 	if (memoryKind && opts.olderThan !== void 0) {
 		const message = `--older-than does not apply to --cache ${memoryKind}, which acts on running processes.`;
 		const remedy = `Run \`stim gc --cache ${memoryKind}\` without --older-than.`;
+		if (reportOnly) return {
+			code: "STIM_BAD_ARG",
+			message,
+			remedy
+		};
 		console.error(chalk.red(message));
 		console.error(chalk.dim(remedy));
 		console.error(chalk.red("failed: STIM_BAD_ARG"));
@@ -2476,8 +2231,11 @@ async function sweep(opts, deps) {
 		};
 	}
 	const poolError = parkedMaxSetting("ios").error || parkedMaxSetting("android").error;
-	if (poolError) console.error(chalk.yellow(`${poolError} ${POOL_SETTING_REMEDY}`));
-	if (opts.cache) return runGcCore(opts, {
+	if (poolError) {
+		if (reportOnly) phase("note", `${poolError} ${POOL_SETTING_REMEDY}`, deps.operation);
+		else console.error(chalk.yellow(`${poolError} ${POOL_SETTING_REMEDY}`));
+	}
+	if (opts.cache) return core({
 		...deps,
 		precollectedEasSessionSweep: {
 			projectScope: null,
@@ -2488,8 +2246,8 @@ async function sweep(opts, deps) {
 	});
 	let projectRoot = null;
 	try {
-		projectRoot = (deps.findProjectRoot ?? findProjectRoot)(process.cwd());
-		if (!projectRoot) return runGcCore(opts, {
+		projectRoot = (deps.findProjectRoot ?? findProjectRoot$1)(deps.operation?.cwd ?? process.cwd());
+		if (!projectRoot) return core({
 			...deps,
 			precollectedEasSessionSweep: {
 				projectScope: null,
@@ -2498,7 +2256,7 @@ async function sweep(opts, deps) {
 				deletionSafe: false
 			}
 		});
-		if (!(deps.detectIsExpo ?? detectIsExpo)(projectRoot)) return runGcCore(opts, {
+		if (!(deps.detectIsExpo ?? detectIsExpo)(projectRoot)) return core({
 			...deps,
 			precollectedEasSessionSweep: {
 				projectScope: projectRoot,
@@ -2508,7 +2266,7 @@ async function sweep(opts, deps) {
 			}
 		});
 	} catch (error) {
-		return runGcCore(opts, {
+		return core({
 			...deps,
 			precollectedEasSessionSweep: {
 				projectScope: projectRoot,
@@ -2524,7 +2282,7 @@ async function sweep(opts, deps) {
 	try {
 		easSessionSweep = await withProjectLock(projectRoot, () => {
 			sweepStarted = true;
-			return withRemoteSessionGcLocks(projectRoot, deps, (coordinatedDeps) => Promise.resolve(collectEasSessionSweep(loadConfig$1(), coordinatedDeps)));
+			return withRemoteSessionGcLocks(projectRoot, deps, (coordinatedDeps) => collectEasSessionSweep(loadConfig$1(), coordinatedDeps));
 		}, {
 			waitMs: 0,
 			ownerPurpose: "EAS orphan sweep",
@@ -2538,7 +2296,7 @@ async function sweep(opts, deps) {
 			deletionSafe: false
 		};
 	}
-	return runGcCore(opts, {
+	return core({
 		...deps,
 		precollectedEasSessionSweep: easSessionSweep
 	});
@@ -2589,13 +2347,18 @@ async function pruneDeadProjects(deadProjects) {
 	}
 	return deleteFailures;
 }
-async function attachMaintenancePreview(report, deleting, cache) {
-	if (!deleting) report.maintenance = await previewMaintenance({ devices: !cache });
+async function attachMaintenancePreview(report, deleting, cache, refresh, operation) {
+	if (!deleting) report.maintenance = await previewMaintenance({
+		devices: !cache,
+		refresh,
+		operation
+	});
 }
 function scopedDryRunAction(cache) {
 	const memory = memoryCacheKind(cache);
 	if (memory === "watchman") return "remove the stale roots and shut down the unused watchman";
 	if (memory === "gradle-daemons") return "stop the idle daemons";
+	if (includesGradleVersions(cache)) return "delete the Gradle versions marked deletable";
 	return includesParkedDevices(cache) ? "erase the parked devices" : "empty the caches";
 }
 function dryRunHint(cache, all, actionable, caches) {
@@ -2604,45 +2367,64 @@ function dryRunHint(cache, all, actionable, caches) {
 	if (caches) return "Pass --delete --cache all to empty the caches above, or --delete --older-than <days> to trim them.";
 	return null;
 }
+function scopedWorkPending(cache, report) {
+	return memoryWorkPending(cache, report.memory) || gradleVersionsPending(report.gradleVersions);
+}
 function pruneStatusCaches(report) {
 	if (report.cacheScope !== null) return 0;
 	return deleteStaleStatusCaches(collectStaleStatusCaches(listMountedVolumes()).stale);
 }
-function reclaimParkedDevices(report, deps) {
-	return report.cacheScope ? eraseParkedDevices(report.parkedSims, report.parkedAvds) : deleteParkedSims(report.parkedSims, deps) + deleteParkedAvds(report.parkedAvds);
+async function reclaimParkedDevices(report, deps) {
+	return report.cacheScope ? await eraseParkedDevices(report.parkedSims, report.parkedAvds) : await deleteParkedSims(report.parkedSims, deps) + await deleteParkedAvds(report.parkedAvds);
 }
-async function runGcCore(opts, deps) {
-	takeGcResults();
+function reportActionable(report) {
+	const { deadProjects, invalidProjects, orphanedDevices, staleDevices, staleDeviceRecords, buildLocks, buildSlots, deviceLeases, easSessionSweep, caches, olderThan, all, cacheScope: cache } = report;
+	return archiveWorkPending(report.archives, deadProjects.length + invalidProjects.length > 0 || report.orphanedWorkspaces.length > 0 || Boolean(report.workspaceOutputs?.workspaces.some((entry) => entry.willClear)) || report.workspaceLogs.some((entry) => entry.willTrim) || report.recordings.some((entry) => entry.willDelete && !entry.withWorkspace) || Boolean(report.tempLeftovers?.entries.some((entry) => entry.willDelete)) || Boolean(report.worktreeSweep?.worktrees.some((entry) => !entry.skipped)) || report.parkedSims.length > 0 || report.parkedAvds.length + report.parkedHostedDevices.filter((device) => device.listed !== false).length > 0 || orphanedDevices.length > 0 || staleDevices.length + report.finishedDevices.length > 0 || staleDeviceRecords.length > 0 || report.staleLedgerEntries.length + report.staleEasLedgerEntries.length > 0 || report.staleStatusCaches.length > 0 || buildLocks.stale.length > 0 || buildSlots.stale.length > 0 || deviceLeases.expired.length > 0 || easSessionSweep.orphaned.length > 0 || (olderThan !== null || all) && caches.length > 0 || scopedWorkPending(cache, report));
+}
+async function runGcCore(opts, deps, reportOnly = false) {
+	if (!reportOnly) takeGcResults();
 	const olderThan = typeof opts.olderThan === "number" ? opts.olderThan : null;
 	const cache = typeof opts.cache === "string" && opts.cache.trim() ? opts.cache : null;
+	const refresh = opts.delete === true;
 	const report = await collectGcReport({
 		olderThan,
 		cache,
-		worktrees: Boolean(opts.worktrees)
+		worktrees: Boolean(opts.worktrees),
+		refresh
 	}, deps);
 	if (cache && report.caches.length === 0 && report.workspaceOutputs === null && !selectsBeyondCaches(cache)) {
-		const names = [...new Set(discoverCaches().map((c) => c.name))];
+		const names = [...new Set(discoverCaches(deps.operation?.env ?? process.env, deps.operation?.cwd).map((c) => c.name))];
 		const message = `No shared cache carries "${cache}" in its name or directory.`;
-		console.log(chalk.yellow(message));
-		if (names.length) console.log(chalk.dim(`Caches on this machine: ${names.join(", ")}`));
-		if (opts.json) process.exitCode = 1;
+		if (!reportOnly) {
+			console.log(chalk.yellow(message));
+			if (names.length) console.log(chalk.dim(`Caches on this machine: ${names.join(", ")}`));
+			if (opts.json) process.exitCode = 1;
+		}
 		return {
 			code: "STIM_BAD_ARG",
 			message,
 			remedy: names.length ? `Pass --cache all or a name from: ${names.join(", ")}.` : "No shared cache was found on this machine."
 		};
 	}
-	await attachMaintenancePreview(report, opts.delete === true, cache);
+	await attachMaintenancePreview(report, opts.delete === true, cache, refresh, deps.operation);
 	const refusal = archiveRefusal(report.archives);
-	if (refusal !== null) return refusal;
+	if (refusal !== null) {
+		if (!reportOnly) {
+			process.exitCode = 1;
+			console.error(chalk.red(refusal.message));
+			console.error(chalk.dim(refusal.remedy));
+			console.error(chalk.red(`failed: ${refusal.code}`));
+		}
+		return refusal;
+	}
 	const all = report.all;
-	for (const line of formatGcReport(report)) console.log(line);
+	if (!reportOnly) for (const line of formatGcReport(report)) console.log(line);
 	const { deadProjects, invalidProjects, orphanedDevices, staleDevices, staleDeviceRecords, buildLocks, buildSlots, deviceLeases, easSessionSweep, caches } = report;
-	const actionable = archiveWorkPending(report.archives, deadProjects.length + invalidProjects.length > 0 || report.orphanedWorkspaces.length > 0 || Boolean(report.workspaceOutputs?.workspaces.some((entry) => entry.willClear)) || report.workspaceLogs.some((entry) => entry.willTrim) || report.recordings.some((entry) => entry.willDelete && !entry.withWorkspace) || Boolean(report.worktreeSweep?.worktrees.some((entry) => !entry.skipped)) || report.parkedSims.length > 0 || report.parkedAvds.length + report.parkedHostedDevices.filter((device) => device.listed !== false).length > 0 || orphanedDevices.length > 0 || staleDevices.length > 0 || staleDeviceRecords.length > 0 || report.staleLedgerEntries.length + report.staleEasLedgerEntries.length > 0 || report.staleStatusCaches.length > 0 || buildLocks.stale.length > 0 || buildSlots.stale.length > 0 || deviceLeases.expired.length > 0 || easSessionSweep.orphaned.length > 0 || (olderThan !== null || all) && caches.length > 0 || memoryWorkPending(cache, report.memory));
+	const actionable = reportActionable(report);
 	const idle = opts.idle ?? null;
-	const idleFailures = idle === null ? 0 : shutDownIdleDevices(report.idleDevices, idle, () => collectIdleDevices(loadConfig$1(), listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }), report.deadProjects)).failures;
+	const idleFailures = idle === null ? 0 : (await shutDownIdleDevices(report.idleDevices, idle, () => collectIdleDevices(loadConfig$1(), listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }), report.deadProjects))).failures;
 	if (idleFailures) process.exitCode = 1;
-	const inventory = opts.json && !opts.delete && idle === null && report.cacheScope === null ? collectInventory(loadConfig$1(), deadProjects) : null;
+	const inventory = opts.json && !opts.delete && idle === null && report.cacheScope === null ? await collectInventory(loadConfig$1(), deadProjects, deps.operation?.env ?? process.env) : null;
 	const payload = (failures) => ({
 		mode: opts.delete ? "delete" : "dry-run",
 		idle,
@@ -2653,12 +2435,12 @@ async function runGcCore(opts, deps) {
 		failures,
 		sections: gcReportSections(report),
 		...report.maintenance ? { maintenance: report.maintenance } : {},
-		results: takeGcResults(),
+		results: reportOnly ? [] : takeGcResults(),
 		inventory
 	});
 	if (!opts.delete) {
 		const hint = dryRunHint(cache, all, actionable, caches.length > 0);
-		if (hint) console.log(chalk.dim(`\n${hint}`));
+		if (hint && !reportOnly) console.log(chalk.dim(`\n${hint}`));
 		return payload(idle === null ? null : idleFailures);
 	}
 	let deleteFailures = idleFailures;
@@ -2670,16 +2452,22 @@ async function runGcCore(opts, deps) {
 		olderThan,
 		now: Date.now()
 	});
-	deleteFailures += reclaimParkedDevices(report, deps);
+	deleteFailures += await reclaimParkedDevices(report, deps);
 	deleteFailures += await deleteParkedHostedDevices(report.parkedHostedDevices);
 	deleteFailures += await reclaimMemory(cache, report.memory);
+	deleteFailures += await deleteGradleVersions(report.gradleVersions);
 	removeInvalidProjectEntries(invalidProjects);
 	deleteFailures += await pruneDeadProjects(deadProjects);
 	deleteFailures += await deleteOrphanedWorkspaces(report.orphanedWorkspaces);
-	deleteFailures += deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords);
+	deleteFailures += await deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords);
+	deleteFailures += await deleteFinishedDevices(report);
 	deleteFailures += forgetStaleLedgerEntries(report.staleLedgerEntries);
 	deleteFailures += forgetStaleEasLedgerEntries(report.staleEasLedgerEntries, listMountedVolumes(), deps);
 	deleteFailures += pruneStatusCaches(report);
+	if (report.tempLeftovers) deleteFailures += (await deleteTempLeftovers({
+		env: deps.operation?.env ?? process.env,
+		signal: deps.operation?.signal
+	})).failures;
 	for (const lock of buildLocks.stale) {
 		const cleared = (0, ownership_claim_exports.clearFreeClaimSet)({
 			root: lock.path,
@@ -2758,11 +2546,11 @@ async function runGcCore(opts, deps) {
 	return payload(deleteFailures);
 }
 function gcCommand(program) {
-	program.command("gc").description("Report what Stim has left behind: dead project entries, orphaned workspace directories, clean Stim-managed linked worktrees whose branch is merged or whose pull request was merged or closed, orphaned owned devices and EAS sessions, records of devices that no longer exist, build locks whose builder is gone, expired physical-device leases, the shared build caches, the build outputs and logs of each workspace, and the memory of watchman and of the Gradle and Kotlin daemons. Reports by default; pass --delete to act.").option("--worktrees", "also remove clean, idle Stim-managed linked worktrees, not only merged ones: with --delete run `stim worktree remove` (never --force) on each; idle means unused for --older-than days, 7 without it").option("--delete", "actually prune the reported entries, reap the reported devices, clear the build outputs of every workspace not in use, and trim its Metro, client and device logs to their newest 8 MiB").option("--older-than <days>", "also reap owned devices whose workspace has not been used this long, trim shared cache entries nothing has used in that time and device recordings made before it, and clear workspace build outputs only for workspaces idle this long and parked devices only once parked this long", (v) => {
+	program.command("gc").description("Report what Stim has left behind: dead project entries, orphaned workspace directories, clean Stim-managed linked worktrees whose branch is merged or whose pull request was merged or closed, orphaned owned devices and EAS sessions, records of devices that no longer exist, build locks whose builder is gone, expired physical-device leases, the shared build caches, the build outputs and logs of each workspace, the memory of watchman and of the Gradle and Kotlin daemons, and recognized leftovers in TMPDIR. Reports by default; pass --delete to act.").option("--worktrees", "also remove clean, idle Stim-managed linked worktrees, not only merged ones: with --delete run `stim worktree remove` (never --force) on each; idle means unused for --older-than days, 7 without it").option("--delete", "actually prune the reported entries, reap the reported devices, clear the build outputs of every workspace not in use, and trim its Metro, client and device logs to their newest 8 MiB").option("--older-than <days>", "also reap owned devices whose workspace has not been used this long, trim shared cache entries nothing has used in that time and device recordings made before it, and clear workspace build outputs only for workspaces idle this long and parked devices only once parked this long", (v) => {
 		const n = parseInt(v, 10);
 		if (!Number.isFinite(n) || String(n) !== String(v).trim()) throw new InvalidArgumentError("must be a whole number of days, e.g. --older-than 30");
 		return n;
-	}).option("--cache <name>", "act on the shared caches whose name or directory contains <name>, every cache, the workspace build outputs and the device recordings with --cache all, only the workspace build outputs with --cache workspaces, only the device recordings with --cache recordings, only the parked simulators and emulators with --cache parked, the watchman daemon and its stale roots with --cache watchman, or the Gradle and Kotlin compile daemons with --cache gradle-daemons; archived, archived:<id>, archived-logs, archived-recordings and archived-agent select archived history explicitly, and the three kind selectors also take :<id> (archived-logs:<id>) to clear one kind of one archive; --cache all excludes archives. all, workspaces, recordings, parked, archived, archived:<id>, archived-logs, archived-recordings, archived-agent, their :<id> forms, watchman and gradle-daemons are reserved names that never select a single cache, and --cache all never includes watchman or gradle-daemons. With --delete they are emptied whole (a parked device is erased and stays parked, watchman loses its stale roots and shuts down only when no client uses it, and only daemons proven idle stop), which is the only way to clear an index-backed cache; add --older-than <days> to trim them by age instead. Archive ids, including the :<id> of a kind selector, ignore --older-than; archived and per-kind archive selectors without an id filter by removal age. Only those caches are reported; other devices and project entries are not inspected. Caches outside the config dir are refused while STIM_HOME is set.", (v) => {
+	}).option("--cache <name>", "act on the shared caches whose name or directory contains <name>, every cache, the workspace build outputs and the device recordings with --cache all, only the workspace build outputs with --cache workspaces, only the device recordings with --cache recordings, only the parked simulators and emulators with --cache parked, the watchman daemon and its stale roots with --cache watchman, the Gradle and Kotlin compile daemons with --cache gradle-daemons, or the Gradle version caches and wrapper distributions no registered project pins with --cache gradle-versions; archived, archived:<id>, archived-logs, archived-recordings and archived-agent select archived history explicitly, and the three kind selectors also take :<id> (archived-logs:<id>) to clear one kind of one archive; --cache all excludes archives. all, workspaces, recordings, parked, archived, archived:<id>, archived-logs, archived-recordings, archived-agent, their :<id> forms, watchman, gradle-daemons and gradle-versions are reserved names that never select a single cache, and --cache all never includes watchman, gradle-daemons or gradle-versions. With --delete they are emptied whole (a parked device is erased and stays parked, watchman loses its stale roots and shuts down only when no client uses it, and only daemons proven idle stop), which is the only way to clear an index-backed cache; add --older-than <days> to trim them by age instead. Archive ids, including the :<id> of a kind selector, ignore --older-than; archived and per-kind archive selectors without an id filter by removal age. Only those caches are reported; other devices and project entries are not inspected. Caches outside the config dir are refused while STIM_HOME is set.", (v) => {
 		if (!v.trim()) throw new InvalidArgumentError("must name a cache, e.g. --cache \"compilation cache\"");
 		return v;
 	}).option("--idle <duration>", "shut down (never delete) owned simulators and emulators that have had no driver, claim, or activity for at least <duration>, such as 30m, 2h, or 1d; acts without --delete", (v) => {
@@ -2774,4 +2562,4 @@ function gcCommand(program) {
 	});
 }
 //#endregion
-export { collectGcReport, gcCommand as default, deleteParkedSims, describeParkedSims, describeUnverifiableDevices, findOrphanedDevices, findStaleDeviceRecords, findStaleProjectDevices, formatGcReport, runGc, selectCaches };
+export { formatGcReport as a, runGc as i, gcCommand as n, readGcReport as r, collectGcReport as t };