stim 1.9.0 → 1.10.0

package/dist/{gc-Ckw8RQHi.mjs → gc-ChPFZMRC.mjs}

@@ -1,727 +1,23 @@
-import { F as formatBytes, I as isOnMountedVolume, K as projectDeviceSlots, L as listMountedVolumes, M as readJsonFile, P as directorySize, R as measuredDirectorySize, T as withConfigLock, U as deviceSlotPlatforms, b as removeProject, f as getProject, g as loadConfig, h as isPathPrefix, i as clearDevice, j as isJsonObject, k as ownership_claim_exports, u as getConfigDir, z as volumeRootFor } from "./config-Cp9lM3wX.mjs";
-import { t as getExecutor } from "./exec-jIAlgilk.mjs";
-import { i as registeredCaches } from "./cache-manifest-Dg7OnMrp.mjs";
-import { S as workspaceStateFile, _ as workspaceDir, s as workspaceLastUsed, x as workspaceName$1 } from "./workspace-state-DF2gCFhx.mjs";
-import { S as unpushedCommits, c as hasPopulatedSubmodules, f as listWorktrees, o as dirtyPaths, u as hasUncommittedWork, x as sourceCheckoutOf } from "./worktree-R_cUlE7s.mjs";
-import { a as detectIsExpo, o as findProjectRoot } from "./project-DS112DYB.mjs";
-import { E as listOrphanedAvdDirectories, k as ownedAvdDirectory, w as listAvds } from "./android-_y4Ohi5z.mjs";
-import { h as shortUdid, o as formatLongDuration, u as plural } from "./command-output-gByVmIjy.mjs";
-import { n as listBuildLocks } from "./build-lock-DPXPLgTc.mjs";
-import { b as resolveEasCliBin, o as parkedMaxSetting, r as dropParked, s as readParked, t as POOL_SETTING_REMEDY } from "./sim-pool-KaIsp2Ft.mjs";
-import { _ as parseRuntimeVersion, f as listIosDeviceTypes, u as listAllIosSims } from "./ios-BL2NFckr.mjs";
-import { i as listLeaseFiles, r as leaseIsExpired, u as removeExpiredLease } from "./device-lease-Crs-HkJY.mjs";
-import { _ as listBuildSlots } from "./xcode-BZqyxh3e.mjs";
-import { C as verifyStoppedSession, D as teardownParkedAvd, E as teardownOwnedIosSim, O as teardownParkedIosSim, S as stopSessionArgs, T as teardownOwnedAvd, _ as inspectSessionForTeardown, d as withEasProjectLock, f as easMachineStateRoot, g as getSessionArgs, h as findOrphanedOwnedSessions, m as removeEasSessionClaim, p as readEasSessionLedger, u as withRemoteSessionLock, v as isDefinitiveMissingSessionError, x as parseSessionListPage, y as listOwnedSessionsArgs } from "./device-remote-AQ5rQPqr.mjs";
-import { _ as workspaceInUse, a as reclaimKeys, d as removeWorktreeTarget, g as withIdleWorkspace, h as emptyWorkspaceDir, m as reclaimProject, n as excludePodChurn, p as describeDereferenced, r as matchWorktreeEntry, v as canonicalPath } from "./worktree-LGB-UwgG.mjs";
+import { A as directorySize, F as volumeRootFor, M as isOnMountedVolume, N as listMountedVolumes, b as removeProject, g as loadConfig, j as formatBytes, k as ownership_claim_exports } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { N as workspaceStateFile, O as workspaceDir, v as workspaceLastUsed } from "./metro-BWLOJ_Wr.mjs";
+import { C as sourceCheckoutOf, b as resolveFullRef, d as hasUncommittedWork, l as hasPopulatedSubmodules, m as listWorktrees, o as dirtyPaths, w as unpushedCommits } from "./worktree-BlizKDpZ.mjs";
+import { a as detectIsExpo, o as findProjectRoot } from "./project-BXZzOABt.mjs";
+import { h as shortUdid, o as formatLongDuration, u as plural } from "./command-output-D5z2_bcF.mjs";
+import { d as removeExpiredLease, h as listBuildLocks } from "./device-lease-CbEaIk7b.mjs";
+import { A as ownedAvdDirectory, C as isStimOwnedAvdName, D as listOrphanedAvdDirectories, K as isStimOwnedSim, T as listAvds } from "./android-787HhP5w.mjs";
+import { h as POOL_SETTING_REMEDY, y as parkedMaxSetting } from "./ownership-DZjdx8Gq.mjs";
+import { l as listAllIosSims } from "./ios-B2Fpqvlb.mjs";
+import { a as parseIdleDuration, o as shutDownIdleDevices, r as idleDeviceLines, t as collectIdleDevices } from "./idle-DpRLp5lj.mjs";
+import { i as canonicalPath, o as listBuildSlots, r as workspaceInUse } from "./in-use-CjUluqIX.mjs";
+import { C as listOwnedSessionsArgs, D as verifyStoppedSession, E as stopSessionArgs, S as isDefinitiveMissingSessionError, T as parseSessionListPage, b as getSessionArgs, d as withRemoteSessionLock, f as withEasProjectLock, h as removeEasSessionClaim, m as readEasSessionLedger, p as easMachineStateRoot, x as inspectSessionForTeardown, y as findOrphanedOwnedSessions, z as resolveEasCliBin } from "./device-remote-Dy1jGj3U.mjs";
+import { A as discoverCaches, C as unverifiedDeviceCommand, D as planCacheEmptying, E as includesWorkspaceOutputs, O as selectCaches, S as findStaleProjectDevices, T as emptyCaches, _ as describeParkedSims, a as collectWorkspaceOutputs, b as findOrphanedDevices, c as listWorkspaceDirs, d as collectDeviceLeases, f as collectParkedAvds, g as deleteProjectDevices, h as deleteParkedSims, i as collectOrphanedWorkspaces, j as sizeCaches, k as trimCaches, l as sizeText, m as deleteParkedAvds, n as WORKSPACE_OUTPUT_DIRS, o as deleteOrphanedWorkspaces, p as collectParkedSims, r as clearWorkspaceOutputs, s as isInsideWorkspaces, t as REBUILD_COST, u as DEVICE_LIST_TIMEOUT_MS, v as describeUnverifiableDevices, w as withAndroidAvdSizes, x as findStaleDeviceRecords, y as deviceSweepIsScoped } from "./workspaces-BTUyFfkv.mjs";
+import { a as reclaimKeys, d as removeWorktreeTarget, m as reclaimProject, n as excludePodChurn, p as describeDereferenced, r as matchWorktreeEntry } from "./worktree-BMS7GeqB.mjs";
+import { statSync } from "node:fs";
 import { InvalidArgumentError } from "commander";
-import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "fs";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
-import { METRO_NAMED_CACHE_LAYOUT } from "@stim-cli/core";
-import { homedir, tmpdir } from "os";
+import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, statSync as statSync$1 } from "fs";
+import { basename, dirname, isAbsolute, join } from "path";
 import chalk from "chalk";
-//#region src/cache/caches.ts
-function xcodeDerivedDataRoot() {
-	return join(homedir(), "Library", "Developer", "Xcode", "DerivedData");
-}
-function compilationCache() {
-	const dir = join(xcodeDerivedDataRoot(), "CompilationCache.noindex");
-	if (!existsSync(dir)) return null;
-	return {
-		name: "Xcode compilation cache",
-		dir,
-		prune: "atomic",
-		note: "index-backed, so it can only be emptied whole"
-	};
-}
-function gradleBuildCache() {
-	const gradleHome = process.env.GRADLE_USER_HOME || join(homedir(), ".gradle");
-	const dir = resolve(gradleHome, "caches", "build-cache-1");
-	if (!existsSync(dir)) return null;
-	return {
-		name: "Gradle build cache",
-		dir,
-		prune: "report-only",
-		note: "shared with every Gradle build; report only, never pruned or emptied by Stim"
-	};
-}
-function metroFileMaps() {
-	const root = tmpdir();
-	if (!existsSync(root)) return null;
-	let names;
-	try {
-		names = readdirSync(root).filter((n) => n.startsWith("metro-file-map-"));
-	} catch {
-		return null;
-	}
-	const uid = process.getuid?.();
-	const files = [];
-	let bytes = 0;
-	for (const n of names) try {
-		const st = statSync(join(root, n));
-		if (uid !== void 0 && st.uid !== uid) continue;
-		files.push(join(root, n));
-		bytes += st.size;
-	} catch {}
-	if (!files.length) return null;
-	return {
-		name: "Metro file maps",
-		dir: root,
-		files,
-		bytes,
-		prune: "entries",
-		note: `${files.length} file(s), one per project root Metro has served`
-	};
-}
-function discoverCaches() {
-	const gradle = gradleBuildCache();
-	const gradleDir = gradle ? canonicalCacheDir(gradle.dir) : null;
-	const registered = protectNestedMetroAncestors(suppressLegacyMetroAncestors(registeredCaches().map((c) => Object.assign({}, c, {
-		name: c.name ?? c.dir,
-		note: c.note ?? "registered",
-		prune: c.prune,
-		source: "registered"
-	}))));
-	const detected = [
-		compilationCache(),
-		gradle,
-		metroFileMaps()
-	].filter((c) => Boolean(c)).map((c) => Object.assign({}, c, { source: "detected" }));
-	return mergeCacheDescriptors([...registered, ...detected], gradleDir);
-}
-function suppressLegacyMetroAncestors(caches) {
-	const current = caches.filter(isCurrentMetroStore);
-	return caches.filter((cache) => {
-		if (!isLegacyMetroStore(cache)) return true;
-		return !current.some((candidate) => isNamedMetroChild(cache.dir, candidate.dir));
-	});
-}
-function protectNestedMetroAncestors(caches) {
-	const current = caches.filter(isCurrentMetroStore);
-	return caches.map((cache) => {
-		if (!isCurrentMetroStore(cache)) return cache;
-		if (!current.some((candidate) => isNamedMetroChild(cache.dir, candidate.dir))) return cache;
-		return Object.assign({}, cache, {
-			prune: "report-only",
-			note: "named Metro store is also an override parent; report only while its child is registered"
-		});
-	});
-}
-function isLegacyMetroStore(cache) {
-	return isMetroStore(cache) && cache.layout === void 0;
-}
-function isCurrentMetroStore(cache) {
-	return isMetroStore(cache) && cache.layout === METRO_NAMED_CACHE_LAYOUT;
-}
-function isMetroStore(cache) {
-	return cache.source === "registered" && cache.name === "Metro transform cache" && cache.prune === "entries" && cache.entriesDepth === 2;
-}
-function isNamedMetroChild(parent, candidate) {
-	const dir = canonicalCacheDir(parent);
-	const child = canonicalCacheDir(candidate);
-	return dirname(child) === dir || canonicalCacheDir(dirname(candidate)) === dir;
-}
-function mergeCacheDescriptors(caches, gradleDir) {
-	const merged = [];
-	for (const cache of caches) {
-		const descriptor = protectGradleCache(cache, gradleDir);
-		const dir = canonicalCacheDir(descriptor.dir);
-		const exact = merged.findIndex((candidate) => canonicalCacheDir(candidate.dir) === dir);
-		if (exact !== -1) {
-			const current = merged[exact];
-			if (pruneStrength(descriptor.prune) > pruneStrength(current.prune)) merged[exact] = Object.assign({}, current, {
-				prune: descriptor.prune,
-				note: descriptor.note
-			});
-			continue;
-		}
-		if (gradleDir && isGradleProtectedDescriptor(descriptor, gradleDir)) {
-			if (merged.some((candidate) => {
-				const candidateDir = canonicalCacheDir(candidate.dir);
-				return isGradleProtectedDescriptor(candidate, gradleDir) && cachePathContains(candidateDir, dir);
-			})) continue;
-			for (let i = merged.length - 1; i >= 0; i--) {
-				const candidate = merged[i];
-				const candidateDir = canonicalCacheDir(candidate.dir);
-				if (isGradleProtectedDescriptor(candidate, gradleDir) && cachePathContains(dir, candidateDir)) merged.splice(i, 1);
-			}
-		}
-		merged.push(descriptor);
-	}
-	return merged;
-}
-function protectGradleCache(cache, gradleDir) {
-	if (cache.files) return cache;
-	if (!gradleDir || !cachePathsOverlap(canonicalCacheDir(cache.dir), gradleDir)) return cache;
-	return Object.assign({}, cache, {
-		prune: "report-only",
-		note: "shared with every Gradle build; report only, never pruned or emptied by Stim"
-	});
-}
-function isGradleProtectedDescriptor(cache, gradleDir) {
-	return cache.prune === "report-only" && cachePathsOverlap(canonicalCacheDir(cache.dir), gradleDir);
-}
-function pruneStrength(prune) {
-	if (prune === "report-only") return 3;
-	if (prune === "atomic") return 2;
-	return 1;
-}
-function cachePathsOverlap(left, right) {
-	return cachePathContains(left, right) || cachePathContains(right, left);
-}
-function cachePathContains(parent, child) {
-	const rel = relative(parent, child);
-	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
-}
-function canonicalCacheDir(dir) {
-	try {
-		return realpathSync(dir);
-	} catch {
-		return resolve(dir);
-	}
-}
-function sizeCaches(caches) {
-	return caches.map((c) => Object.assign({}, c, { bytes: c.bytes ?? directorySize(c.dir) }));
-}
-function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
-	const cutoff = now - olderThanDays * 24 * 60 * 60 * 1e3;
-	if (cache.prune === "report-only") return {
-		removed: 0,
-		bytes: 0,
-		skipped: "report-only shared cache; Stim never deletes it"
-	};
-	if (cache.prune === "atomic") return {
-		removed: 0,
-		bytes: 0,
-		skipped: "index-backed; empty it whole or not at all"
-	};
-	const entries = cache.files ?? entriesAtDepth(cache.dir, cache.entriesDepth ?? 1);
-	let removed = 0;
-	let bytes = 0;
-	let failed = 0;
-	for (const entry of entries) {
-		let used;
-		let size;
-		try {
-			const st = statSync(entry);
-			used = Math.max(st.atimeMs, st.mtimeMs);
-			size = st.isDirectory() ? directorySize(entry) : st.size;
-		} catch {
-			continue;
-		}
-		if (used >= cutoff) continue;
-		try {
-			rmSync(entry, {
-				recursive: true,
-				force: true
-			});
-			removed++;
-			bytes += size;
-		} catch {
-			failed++;
-		}
-	}
-	return {
-		removed,
-		bytes,
-		failed,
-		skipped: null
-	};
-}
-function entriesAtDepth(dir, depth) {
-	let level = [dir];
-	for (let i = 0; i < depth; i++) {
-		const next = [];
-		for (const parent of level) {
-			let names;
-			try {
-				names = readdirSync(parent);
-			} catch {
-				continue;
-			}
-			for (const name of names) next.push(join(parent, name));
-		}
-		level = next;
-	}
-	return level;
-}
-//#endregion
-//#region src/commands/gc/caches.ts
-const DAY_MS$3 = 864e5;
-function cacheSweepIsScoped() {
-	return Boolean(process.env.STIM_HOME);
-}
-function isInsideConfigDir(dir) {
-	const root = canonicalPath(getConfigDir());
-	const target = canonicalPath(dir);
-	const rel = relative(root, target);
-	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
-}
-function machineGlobalReason(cache) {
-	if (!cacheSweepIsScoped()) return null;
-	if (cache.source === "registered") return null;
-	if (isInsideConfigDir(cache.dir)) return null;
-	return `STIM_HOME scopes this config, but ${cache.dir} is outside it and therefore machine-global`;
-}
-const EVERY_CACHE = "all";
-const WORKSPACE_OUTPUTS = "workspaces";
-function includesWorkspaceOutputs(name) {
-	const wanted = name?.trim().toLowerCase();
-	return !wanted || wanted === EVERY_CACHE || wanted === WORKSPACE_OUTPUTS;
-}
-function selectCaches(caches, name) {
-	if (!name) return caches;
-	const wanted = name.trim().toLowerCase();
-	if (wanted === EVERY_CACHE) return caches;
-	if (wanted === WORKSPACE_OUTPUTS) return [];
-	return caches.filter((c) => c.name.toLowerCase().includes(wanted) || c.dir.toLowerCase().includes(wanted));
-}
-function planCacheEmptying(caches, all) {
-	const annotated = caches.map((c) => Object.assign({}, c, { machineGlobal: machineGlobalReason(c) }));
-	if (!all) return annotated;
-	return annotated.map((c) => {
-		if (c.prune === "report-only") return Object.assign({}, c, {
-			willEmpty: false,
-			emptySkipped: "report-only shared cache; Stim never deletes it"
-		});
-		if (c.machineGlobal) return Object.assign({}, c, {
-			willEmpty: false,
-			emptySkipped: c.machineGlobal
-		});
-		if (!ownsItsDirectory(c)) return Object.assign({}, c, {
-			willEmpty: false,
-			emptySkipped: `${c.dir} is not a directory this cache owns`
-		});
-		return Object.assign({}, c, {
-			willEmpty: true,
-			emptySkipped: null
-		});
-	});
-}
-function ownsItsDirectory(cache) {
-	if (Array.isArray(cache.files)) return false;
-	const dir = canonicalPath(cache.dir);
-	if (dirname(dir) === dir) return false;
-	return ![
-		homedir(),
-		tmpdir(),
-		getConfigDir()
-	].map(canonicalPath).includes(dir);
-}
-function emptyCache(cache) {
-	if (cache.prune === "report-only") return {
-		removed: 0,
-		bytes: 0,
-		skipped: "report-only shared cache; Stim never deletes it"
-	};
-	if (cache.prune !== "atomic") return pruneCache(cache, {
-		olderThanDays: 0,
-		now: Date.now() + DAY_MS$3
-	});
-	let names;
-	try {
-		names = readdirSync(cache.dir);
-	} catch (e) {
-		return {
-			removed: 0,
-			bytes: 0,
-			skipped: `could not read ${cache.dir}: ${e.message}`
-		};
-	}
-	let removed = 0;
-	let failed = 0;
-	for (const name of names) try {
-		rmSync(join(cache.dir, name), {
-			recursive: true,
-			force: true
-		});
-		removed++;
-	} catch {
-		failed++;
-	}
-	return {
-		removed,
-		bytes: failed ? 0 : cache.bytes ?? 0,
-		failed,
-		skipped: null
-	};
-}
-function reportFailures(cache, failed) {
-	if (!failed) return;
-	console.log(chalk.red(`${cache.name}: ${failed} entr${failed === 1 ? "y" : "ies"} in ${cache.dir} could not be removed`));
-	process.exitCode = 1;
-}
-function trimCaches(caches, olderThan) {
-	let cacheBytes = 0;
-	for (const c of caches) {
-		if (c.machineGlobal) {
-			console.log(chalk.yellow(`Left ${c.name} alone: ${c.machineGlobal}`));
-			continue;
-		}
-		const r = pruneCache(c, { olderThanDays: olderThan });
-		if (r.skipped) console.log(chalk.yellow(`Left ${c.name} alone: ${r.skipped}`));
-		else if (r.removed) {
-			cacheBytes += r.bytes;
-			console.log(chalk.green(`Trimmed ${c.name}: ${r.removed} entr${r.removed === 1 ? "y" : "ies"} (${formatBytes(r.bytes)})`));
-		} else if (!r.failed) console.log(chalk.dim(`${c.name}: nothing older than ${olderThan}d`));
-		reportFailures(c, r.failed);
-	}
-	if (cacheBytes) console.log(chalk.dim(`Trimmed ${formatBytes(cacheBytes)} of shared cache. The next build that wanted those entries pays to rebuild them.`));
-}
-function emptyCaches(caches) {
-	let cacheBytes = 0;
-	for (const c of caches) {
-		if (!c.willEmpty) {
-			console.log(chalk.yellow(`Left ${c.name} alone: ${c.emptySkipped}`));
-			continue;
-		}
-		const r = emptyCache(c);
-		if (r.skipped) console.log(chalk.yellow(`Left ${c.name} alone: ${r.skipped}`));
-		else if (r.removed) {
-			cacheBytes += r.bytes;
-			console.log(chalk.green(`Emptied ${c.name}: ${r.removed} entr${r.removed === 1 ? "y" : "ies"} (${formatBytes(r.bytes)})`));
-		} else if (!r.failed) console.log(chalk.dim(`${c.name}: already empty`));
-		reportFailures(c, r.failed);
-	}
-	if (cacheBytes) console.log(chalk.dim(`Emptied ${formatBytes(cacheBytes)} of shared cache. Every build that wanted any of it now pays to rebuild it.`));
-}
-//#endregion
-//#region src/commands/gc/devices.ts
-const DEVICE_LIST_TIMEOUT_MS = 3e4;
-const AVD_SIZE_TIMEOUT_MS = 5e3;
-const DAY_MS$2 = 864e5;
-function describeKept(ref) {
-	return ref.mounted ? `referenced by ${ref.path}` : `referenced by ${ref.path} (volume not mounted; kept just in case)`;
-}
-function findOrphanedDevices({ sims = [], avds = [], config, isMounted, deadProjects = [] }) {
-	const dead = new Set(deadProjects);
-	const referenced = /* @__PURE__ */ new Map();
-	for (const [path, proj] of Object.entries(config?.projects || {})) {
-		if (dead.has(path)) continue;
-		const mounted = isMounted ? isMounted(path) : true;
-		for (const { platforms } of projectDeviceSlots(proj)) {
-			const ios = platforms.ios;
-			if (ios?.deviceUdid) referenced.set(ios.deviceUdid, {
-				path,
-				mounted
-			});
-			const android = platforms.android;
-			if (android?.avdName) referenced.set(android.avdName, {
-				path,
-				mounted
-			});
-		}
-	}
-	for (const sim of readParked("ios", { config })) referenced.set(sim.udid, {
-		path: "the simulator pool",
-		mounted: true
-	});
-	for (const avd of readParked("android", { config })) referenced.set(avd.name, {
-		path: "the emulator pool",
-		mounted: true
-	});
-	const orphaned = [];
-	const kept = [];
-	for (const sim of sims) {
-		if (!sim?.name?.startsWith("stim-")) continue;
-		const ref = referenced.get(sim.udid);
-		if (!ref) orphaned.push({
-			kind: "ios",
-			id: sim.udid,
-			name: sim.name
-		});
-		else kept.push({
-			kind: "ios",
-			id: sim.udid,
-			name: sim.name,
-			reason: describeKept(ref)
-		});
-	}
-	for (const avdName of avds) {
-		if (!avdName?.startsWith("stim-")) continue;
-		const ref = referenced.get(avdName);
-		if (!ref) orphaned.push({
-			kind: "android",
-			id: avdName,
-			name: avdName
-		});
-		else kept.push({
-			kind: "android",
-			id: avdName,
-			name: avdName,
-			reason: describeKept(ref)
-		});
-	}
-	return {
-		orphaned,
-		kept
-	};
-}
-function findStaleProjectDevices({ config, sims = [], avds = [], olderThanDays, now = Date.now(), lastTouched, deadProjects = [] }) {
-	if (!Number.isFinite(olderThanDays) || typeof lastTouched !== "function") return [];
-	const cutoff = now - olderThanDays * DAY_MS$2;
-	const dead = new Set(deadProjects);
-	const liveSims = new Map(sims.filter((s) => s?.name?.startsWith("stim-")).map((s) => [s.udid, s.name]));
-	const liveAvds = new Set(avds.filter((a) => typeof a === "string" && a.startsWith("stim-")));
-	const stale = [];
-	for (const [path, proj] of Object.entries(config?.projects || {})) {
-		if (dead.has(path) || !isAbsolute(path)) continue;
-		const touched = lastTouched(path);
-		if (!Number.isFinite(touched) || touched >= cutoff) continue;
-		const idleDays = Math.floor((now - touched) / DAY_MS$2);
-		for (const { slot, platforms } of projectDeviceSlots(proj)) {
-			const ios = platforms.ios;
-			if (ios?.owned && ios.deviceUdid && liveSims.has(ios.deviceUdid)) stale.push({
-				kind: "ios",
-				id: ios.deviceUdid,
-				name: liveSims.get(ios.deviceUdid),
-				project: path,
-				...slot === "default" ? {} : { slot },
-				idleDays
-			});
-			const android = platforms.android;
-			if (android?.owned && android.avdName && liveAvds.has(android.avdName)) stale.push({
-				kind: "android",
-				id: android.avdName,
-				name: android.avdName,
-				project: path,
-				idleDays,
-				...slot === "default" ? {} : { slot }
-			});
-		}
-	}
-	return stale;
-}
-function findStaleDeviceRecords({ config, sims = [], avds = [], deadProjects = [], simsChecked = true, avdsChecked = true }) {
-	const dead = new Set(deadProjects);
-	const liveSims = new Set(sims.map((s) => s?.udid).filter(Boolean));
-	const liveAvds = new Set(avds.filter((a) => typeof a === "string"));
-	const stale = [];
-	for (const [path, proj] of Object.entries(config?.projects || {})) {
-		if (dead.has(path)) continue;
-		for (const { slot, platforms } of projectDeviceSlots(proj)) {
-			const ios = platforms.ios;
-			if (simsChecked && ios?.deviceUdid && !liveSims.has(ios.deviceUdid)) stale.push({
-				kind: "ios",
-				id: ios.deviceUdid,
-				project: path,
-				...slot === "default" ? {} : { slot },
-				owned: Boolean(ios.owned)
-			});
-			const android = platforms.android;
-			if (avdsChecked && android?.avdName && !liveAvds.has(android.avdName)) stale.push({
-				kind: "android",
-				id: android.avdName,
-				project: path,
-				...slot === "default" ? {} : { slot },
-				owned: Boolean(android.owned)
-			});
-		}
-	}
-	return stale;
-}
-function describeUnverifiableDevices(simNames = [], avdNames = [], { reason = "no Stim config found" } = {}) {
-	const ours = [...simNames, ...avdNames].filter((n) => typeof n === "string" && n.startsWith("stim-"));
-	if (ours.length === 0) return [`${reason}; device sweep skipped`];
-	return [`${reason}, so ${ours.length} stim-created device(s) cannot be verified as orphaned: ${ours.join(", ")}`, "they were NOT touched. If they are stale, delete them with `xcrun simctl delete <udid>` or `avdmanager delete avd -n <name>`"];
-}
-function withAndroidAvdSizes(devices, { avdDirectory = ownedAvdDirectory, size = directorySize } = {}) {
-	return devices.map((device) => {
-		if (device.kind !== "android") return device;
-		const dir = device.orphanedDirectory?.directory ?? avdDirectory(device.id);
-		if (!dir) return device;
-		try {
-			const bytes = size(dir, { timeoutMs: AVD_SIZE_TIMEOUT_MS });
-			return bytes > 0 ? {
-				...device,
-				bytes
-			} : device;
-		} catch {
-			return device;
-		}
-	});
-}
-function describeParkedSims(records, sims, deviceTypes, { simsChecked = true } = {}) {
-	const listed = new Map(sims.map((sim) => [sim.udid, sim]));
-	return records.map((record) => {
-		const sim = listed.get(record.udid);
-		return {
-			udid: record.udid,
-			name: sim?.name ?? record.name,
-			model: deviceTypes.find((d) => d.identifier === record.deviceTypeIdentifier)?.name ?? null,
-			runtime: sim ? parseRuntimeVersion(sim.runtime) : parseRuntimeVersion(record.runtimeIdentifier),
-			parkedAt: record.parkedAt,
-			bytes: typeof sim?.dataPathSize === "number" ? sim.dataPathSize : null,
-			listed: simsChecked ? Boolean(sim) : null
-		};
-	});
-}
-function collectParkedSims(deps) {
-	const records = readParked("ios");
-	if (records.length === 0) return [];
-	let sims;
-	let deviceTypes = [];
-	try {
-		sims = (deps.listAllIosSims ?? listAllIosSims)({
-			timeoutMs: DEVICE_LIST_TIMEOUT_MS,
-			includeUnavailable: true
-		});
-	} catch {
-		return describeParkedSims(records, [], [], { simsChecked: false });
-	}
-	try {
-		deviceTypes = (deps.listIosDeviceTypes ?? listIosDeviceTypes)();
-	} catch {}
-	return describeParkedSims(records, sims, deviceTypes);
-}
-function collectParkedAvds(deps) {
-	const records = readParked("android");
-	if (!records.length) return [];
-	let avds = null;
-	try {
-		avds = (deps.listAvds ?? listAvds)();
-	} catch {}
-	return records.map((record) => {
-		let bytes = null;
-		try {
-			const directory = (deps.avdDirectory ?? ownedAvdDirectory)(record.name);
-			if (directory) bytes = (deps.directorySize ?? directorySize)(directory, { timeoutMs: AVD_SIZE_TIMEOUT_MS });
-		} catch {}
-		return {
-			name: record.name,
-			systemImage: record.systemImage,
-			parkedAt: record.parkedAt,
-			bytes,
-			listed: avds === null ? null : avds.includes(record.name)
-		};
-	});
-}
-function deleteParkedAvds(avds) {
-	let failures = 0;
-	for (const avd of avds) {
-		if (avd.listed === null) {
-			failures++;
-			console.log(chalk.red(`Could not verify parked android emulator ${avd.name}; its pool record was kept.`));
-			continue;
-		}
-		const result = teardownParkedAvd(avd.name);
-		if (result.status === "failed") {
-			failures++;
-			console.log(chalk.red(`Failed to delete parked android emulator ${avd.name}: ${result.reason}`));
-		} else if (result.status === "torn-down") console.log(chalk.green(`Deleted parked android emulator ${avd.name}`));
-		else console.log(chalk.dim(`Skipped ${avd.name}; it is no longer parked.`));
-	}
-	return failures;
-}
-function deleteParkedSims(parkedSims, deps = {}) {
-	let failures = 0;
-	let emptied = 0;
-	for (const sim of parkedSims) {
-		if (sim.listed === null) {
-			failures++;
-			console.log(chalk.red(`Could not verify parked ios sim ${sim.name} (${sim.udid}); its pool record was kept.`));
-			continue;
-		}
-		try {
-			const teardown = sim.listed ? teardownParkedIosSim(sim.udid, {
-				label: sim.name,
-				deleteSim: deps.deleteParkedIosSim
-			}) : null;
-			if (!(sim.listed ? teardown?.status === "torn-down" : dropParked("ios", sim.udid))) {
-				if (teardown?.status === "failed") {
-					failures++;
-					console.log(chalk.red(`Failed to delete parked ios sim ${sim.name}: ${teardown.reason}`));
-				} else console.log(chalk.dim(`Skipped ${sim.name} (${sim.udid}); it is no longer parked.`));
-				continue;
-			}
-			emptied++;
-			console.log(chalk.green(sim.listed ? `Deleted parked ios sim ${sim.name} (${sim.udid})` : `Dropped the parked record for ${sim.name} (${sim.udid}); it is not on this machine.`));
-		} catch (err) {
-			failures++;
-			console.log(chalk.red(`Failed to delete parked ios sim ${sim.name}: ${err?.message || err}`));
-		}
-	}
-	if (emptied) console.log(chalk.dim(`  emptied ${plural(emptied, "parked simulator")} from the pool`));
-	return failures;
-}
-function deviceSweepIsScoped() {
-	return Boolean(process.env.STIM_HOME);
-}
-function collectDeviceLeases(now) {
-	const expired = [];
-	const kept = [];
-	for (const entry of listLeaseFiles()) {
-		const lease = entry.lease;
-		if (!lease) {
-			kept.push({
-				name: entry.name,
-				path: entry.path,
-				reason: "it does not parse as a lease, so no run may take that device"
-			});
-			continue;
-		}
-		if (leaseIsExpired(lease, now)) {
-			expired.push(entry);
-			continue;
-		}
-		if (!existsSync(lease.holder)) kept.push({
-			name: entry.name,
-			path: entry.path,
-			reason: `${lease.holder} is not on this machine, but the lease runs until ${lease.expiresAt}`
-		});
-	}
-	return {
-		expired,
-		kept
-	};
-}
-function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords) {
-	let deleteFailures = 0;
-	function reap(d, onlyIfMissing = false) {
-		const r = d.kind === "ios" ? teardownOwnedIosSim(d.id, {
-			del: true,
-			label: d.name
-		}) : teardownOwnedAvd(d.name, {
-			del: true,
-			onlyIfMissing,
-			..."project" in d ? { owner: {
-				projectPath: d.project,
-				slot: d.slot
-			} } : {},
-			..."project" in d ? { onRemoved: () => {
-				if (clearDevice(d.project, d.kind, d.slot, d.id)) console.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
-			} } : {},
-			..."orphanedDirectory" in d ? { orphanedDirectory: d.orphanedDirectory } : {}
-		});
-		const what = d.kind === "ios" ? `ios sim ${d.name} (${d.id})` : `android avd ${d.name}`;
-		if (r.status === "torn-down") console.log(chalk.green(`Deleted ${what}`));
-		else if (r.status === "missing") console.log(chalk.dim(`${what} is already gone; nothing to delete.`));
-		else if (r.status === "skipped") console.log(chalk.yellow(`Skipped ${what}: ${r.reason} -- left for a later gc`));
-		else {
-			deleteFailures++;
-			console.log(chalk.red(`Failed to delete ${d.kind} device ${d.name}: ${r.reason}`));
-		}
-		return r.status;
-	}
-	for (const d of orphanedDevices) reap(d);
-	for (const d of staleDevices) {
-		const status = reap(d);
-		if (d.kind === "ios" && (status === "torn-down" || status === "missing")) {
-			clearDevice(d.project, d.kind, d.slot, d.id);
-			console.log(chalk.dim(`  cleared the ${d.kind} record for ${d.project}`));
-		}
-	}
-	for (const r of staleDeviceRecords) if (r.kind === "android" && r.owned) reap({
-		...r,
-		name: r.id,
-		idleDays: 0
-	}, true);
-	else if (withConfigLock(() => {
-		if (r.kind === "android" && deviceSlotPlatforms(getProject(r.project), r.slot)?.android?.owned) return false;
-		return clearDevice(r.project, r.kind, r.slot, r.id);
-	})) console.log(chalk.green(`Cleared the ${r.kind} record for ${r.project} (${r.id} is not on this machine)`));
-	return deleteFailures;
-}
-//#endregion
 //#region src/commands/gc/eas-sessions.ts
 const EAS_OPERATION_TIMEOUT_MS = 3e4;
 const EAS_COLLECTION_TIMEOUT_MS = 6e4;
@@ -741,18 +37,18 @@ function readRecordedRemoteSessionIds(roots) {
 	let safe = true;
 	for (const root of new Set(roots)) {
 		try {
-			if (!statSync(root).isDirectory()) throw new Error("path is not a directory");
-			readdirSync(root);
+			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(path)) continue;
+		if (!existsSync$1(path)) continue;
 		let state;
 		try {
-			state = JSON.parse(readFileSync(path, "utf-8"));
+			state = JSON.parse(readFileSync$1(path, "utf-8"));
 		} catch (error) {
 			safe = false;
 			notices.push(`${path} could not be read as valid JSON: ${describeError(error)}`);
@@ -788,8 +84,8 @@ function claimStateAbsence(claim) {
 	const stateDir = dirname(claim.stateFile);
 	let entries;
 	try {
-		if (!statSync(stateDir).isDirectory()) throw new Error("path is not a directory");
-		entries = readdirSync(stateDir);
+		if (!statSync$1(stateDir).isDirectory()) throw new Error("path is not a directory");
+		entries = readdirSync$1(stateDir);
 	} catch (error) {
 		return {
 			absent: false,
@@ -802,7 +98,7 @@ function claimStateAbsence(claim) {
 	};
 	let state;
 	try {
-		state = JSON.parse(readFileSync(claim.stateFile, "utf-8"));
+		state = JSON.parse(readFileSync$1(claim.stateFile, "utf-8"));
 	} catch (error) {
 		return {
 			absent: false,
@@ -919,8 +215,8 @@ function easLockRoots(projectRoot, config) {
 }
 function unavailableLockRootNotice(roots) {
 	for (const root of roots) try {
-		if (!statSync(root).isDirectory()) throw new Error("path is not a directory");
-		readdirSync(root);
+		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)}`;
 	}
@@ -929,7 +225,7 @@ function unavailableLockRootNotice(roots) {
 function malformedRemoteSessionLockNotice(roots) {
 	for (const root of roots) {
 		const lockPath = join(workspaceDir(root), "remote-session.lock");
-		if (!existsSync(lockPath)) continue;
+		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.`;
 	}
@@ -1103,261 +399,425 @@ async function deleteEasSessions(easSessionSweep, deps) {
 	return deleteFailures;
 }
 //#endregion
-//#region src/commands/gc/workspaces.ts
-function workspacesRoot() {
-	return join(getConfigDir(), "workspaces");
-}
-function isInsideWorkspaces(dir) {
-	const rel = relative(canonicalPath(workspacesRoot()), canonicalPath(dir));
-	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
-}
-function readRecordedRoot(dir, name) {
-	let parsed;
+//#region src/workspace/merge-state.ts
+const FETCH_TIMEOUT_MS = 3e4;
+const FETCH_FRESH_MS = 6e5;
+const GIT_TIMEOUT_MS = 6e4;
+const REMOTE_PREFIX = "refs/remotes/origin/";
+function failure(error) {
+	const { stderr, message } = error;
+	const text = String(stderr ?? "").trim() || String(message ?? error);
+	return text.split("\n")[0] ?? text;
+}
+function fetchedRecently(repo, now) {
+	const path = getExecutor().runFileQuiet("git", [
+		"-C",
+		repo,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-path",
+		"FETCH_HEAD"
+	])?.trim();
 	try {
-		parsed = readJsonFile(join(dir, "workspace.json"));
+		return Boolean(path) && now - statSync(path).mtimeMs < FETCH_FRESH_MS;
+	} catch {
+		return false;
+	}
+}
+/**
+* Fetches the default branch that `origin/HEAD` names into its remote-tracking ref, bounded by a timeout and never
+* prompting for credentials. It skips the fetch when the checkout fetched anything in the last 10 minutes.
+*/
+function fetchDefaultBranch(repo, now = Date.now()) {
+	const exec = getExecutor();
+	const ref = exec.runFileQuiet("git", [
+		"-C",
+		repo,
+		"symbolic-ref",
+		"--quiet",
+		"refs/remotes/origin/HEAD"
+	])?.trim();
+	if (!ref?.startsWith(REMOTE_PREFIX)) return { error: `origin/HEAD is not set; run \`git -C ${repo} remote set-head origin --auto\`` };
+	const branch = ref.slice(20);
+	if (fetchedRecently(repo, now)) return {
+		ref,
+		name: `origin/${branch}`
+	};
+	try {
+		exec.runFile("git", [
+			"-C",
+			repo,
+			"fetch",
+			"--quiet",
+			"--no-tags",
+			"--no-recurse-submodules",
+			"origin",
+			`+refs/heads/${branch}:${ref}`
+		], {
+			timeoutMs: FETCH_TIMEOUT_MS,
+			env: { GIT_TERMINAL_PROMPT: "0" }
+		});
 	} catch (error) {
-		return {
-			projectRoot: null,
-			problem: error?.code === "ENOENT" ? "it has no workspace.json" : "its workspace.json does not parse"
-		};
+		return { error: `git fetch origin ${branch} failed: ${failure(error)}` };
 	}
-	const projectRoot = isJsonObject(parsed) ? parsed.projectRoot : void 0;
-	if (typeof projectRoot !== "string" || !isAbsolute(projectRoot)) return {
-		projectRoot: null,
-		problem: "its workspace.json records no absolute project root"
-	};
-	if (workspaceName$1(projectRoot) !== name) return {
-		projectRoot: null,
-		problem: `its workspace.json records ${projectRoot}, whose workspace directory has another name`
+	return {
+		ref,
+		name: `origin/${branch}`
 	};
+}
+function notMerged(detail) {
 	return {
-		projectRoot,
-		problem: null
+		merged: false,
+		unknown: false,
+		detail
 	};
 }
-function listWorkspaceDirs() {
-	const root = workspacesRoot();
-	let names;
+function currentBranch(path) {
+	const ref = getExecutor().runFileQuiet("git", [
+		"-C",
+		path,
+		"symbolic-ref",
+		"--quiet",
+		"HEAD"
+	])?.trim();
+	return ref?.startsWith("refs/heads/") ? ref : null;
+}
+function upstreamGone(path, branch) {
+	if (!branch) return false;
+	const [upstream, state] = (getExecutor().runFileQuiet("git", [
+		"-C",
+		path,
+		"for-each-ref",
+		"--format=%(upstream)%00%(upstream:track)",
+		branch
+	]) ?? "").trim().split("\0");
+	return Boolean(upstream) && state === "[gone]";
+}
+function committedOn(path, branch, head) {
+	if (!branch) return false;
+	const exec = getExecutor();
+	return (exec.runFileQuiet("git", [
+		"-C",
+		path,
+		"reflog",
+		"show",
+		"--format=%H %gs",
+		branch
+	]) ?? "").split("\n").some((entry) => {
+		const [sha = "", ...subject] = entry.split(" ");
+		return /^(commit|cherry-pick|rebase|revert)\b/.test(subject.join(" ")) && exec.runFileQuiet("git", [
+			"-C",
+			path,
+			"merge-base",
+			"--is-ancestor",
+			sha,
+			head
+		]) !== null;
+	});
+}
+/**
+* Whether the worktree's HEAD is merged into `target`. The signals, all local git:
+* - HEAD is an ancestor of the default branch, off its first-parent line, and the branch's reflog shows a commit made
+*   on it that HEAD contains, so a merge commit brought the branch's own work in. A branch with no commit of its own
+*   is not merged.
+* - The branch changes the tree, has no merge commits, and every commit since the merge base has the same
+*   `git patch-id --verbatim` as a commit on the default branch (a rebase merge).
+* - The branch changes the tree and its whole diff since the merge base has the same verbatim patch id as a commit on
+*   the default branch, limited to the files the branch changes (a squash merge).
+* Anything git cannot answer is unknown, never merged. `coversUnpushed` is true for a patch-equivalent HEAD whose
+* upstream branch was deleted: its commits exist only locally, but their change is on the default branch.
+*/
+function mergeState(path, { ref, name }) {
+	const git = (args, input) => getExecutor().runFile("git", [
+		"--literal-pathspecs",
+		"-C",
+		path,
+		...args
+	], {
+		timeoutMs: GIT_TIMEOUT_MS,
+		input
+	});
+	const patch = (args) => getExecutor().runFile("git", [
+		"--literal-pathspecs",
+		"-C",
+		path,
+		...args
+	], {
+		timeoutMs: GIT_TIMEOUT_MS,
+		untrimmed: true
+	});
+	const patchIds = (text) => text ? git(["patch-id", "--verbatim"], text).split("\n").flatMap((line) => line.split(" ")[0] || []) : [];
+	const diffOptions = ["--no-color", "--no-ext-diff"];
+	const noOwnCommits = notMerged(`no commits of its own beyond ${name}`);
 	try {
-		names = readdirSync(root).toSorted();
-	} catch {
-		return [];
-	}
-	const entries = [];
-	for (const name of names) {
-		const dir = join(root, name);
-		try {
-			if (!statSync(dir).isDirectory()) continue;
-		} catch {
-			continue;
+		const head = git([
+			"rev-parse",
+			"--verify",
+			"HEAD^{commit}"
+		]);
+		const base = git([
+			"merge-base",
+			head,
+			ref
+		]);
+		const branch = currentBranch(path);
+		if (base === head) {
+			if (git(["rev-parse", ref]) === head || git([
+				"rev-list",
+				"--first-parent",
+				"--parents",
+				`${head}..${ref}`
+			]).split("\n").some((line) => line.split(" ")[1] === head) || !committedOn(path, branch, head)) return noOwnCommits;
+			return {
+				merged: true,
+				into: name,
+				head,
+				coversUnpushed: false
+			};
 		}
-		entries.push({
-			dir,
-			...readRecordedRoot(dir, name)
+		const files = git([
+			"diff",
+			"--name-only",
+			"--no-renames",
+			"-z",
+			base,
+			head
+		]).split("\0").filter(Boolean);
+		if (!files.length) return notMerged(`no net change beyond ${name}`);
+		const log = (range, pathspec = []) => patch([
+			"log",
+			"-p",
+			"--no-merges",
+			...diffOptions,
+			"--format=commit %H",
+			range,
+			"--",
+			...pathspec
+		]);
+		const upstream = new Set(patchIds(log(`${base}..${ref}`, files)));
+		const patchEquivalent = () => ({
+			merged: true,
+			into: name,
+			head,
+			coversUnpushed: upstreamGone(path, branch)
 		});
-	}
-	return entries;
-}
-function classifyWorkspaceDirs(entries, { registryKeys, exists, isMounted, inUse }) {
-	const orphaned = [];
-	const skipped = [];
-	for (const { dir, projectRoot, problem } of entries) {
-		if (projectRoot === null) {
-			skipped.push({
-				dir,
-				reason: `workspace directory not resolved: ${problem ?? "unknown project root"}`
-			});
-			continue;
+		const squash = patchIds(patch([
+			"diff",
+			...diffOptions,
+			base,
+			head
+		]));
+		if (squash.length === 1 && upstream.has(squash[0])) return patchEquivalent();
+		if (!git([
+			"rev-list",
+			"--merges",
+			`${base}..${head}`
+		])) {
+			const own = patchIds(log(`${base}..${head}`));
+			if (own.length && own.every((id) => upstream.has(id))) return patchEquivalent();
 		}
-		const present = exists(projectRoot);
-		if (present === null) {
-			skipped.push({
-				dir,
-				reason: `cannot tell whether its project root ${projectRoot} still exists`
-			});
-			continue;
-		}
-		if (present) continue;
-		if (registryKeys.some((key) => isPathPrefix(projectRoot, key))) continue;
-		if (!isMounted(projectRoot)) {
-			skipped.push({
-				dir,
-				reason: `the volume of its project root ${projectRoot} is not mounted`
-			});
-			continue;
-		}
-		const reasons = inUse(projectRoot);
-		if (reasons.length) {
-			skipped.push({
-				dir,
-				reason: `its project root ${projectRoot} is gone, but ${reasons.join("; ")}`
-			});
-			continue;
-		}
-		orphaned.push({
-			dir,
-			projectRoot
-		});
-	}
-	return {
-		orphaned,
-		skipped
-	};
-}
-function rootPresence(path) {
-	try {
-		lstatSync(path);
-		return true;
+		return notMerged(`not merged into ${name}`);
 	} catch (error) {
-		const code = error?.code;
-		return code === "ENOENT" || code === "ENOTDIR" ? false : null;
+		return {
+			merged: false,
+			unknown: true,
+			detail: `merge state unknown: ${failure(error)}`
+		};
 	}
 }
-function collectOrphanedWorkspaces(registryKeys, mountedVolumes) {
-	const classified = classifyWorkspaceDirs(listWorkspaceDirs(), {
-		registryKeys,
-		exists: rootPresence,
-		isMounted: (path) => isOnMountedVolume(path, mountedVolumes),
-		inUse: (root) => workspaceInUse(root)
-	});
+//#endregion
+//#region src/commands/gc/worktrees.ts
+const DEFAULT_WORKTREE_IDLE_DAYS = 7;
+const DAY_MS = 864e5;
+const MERGE_DECIDES = /* @__PURE__ */ new Set([
+	"unpushed",
+	"not-merged",
+	"last-use-unknown",
+	"recently-used"
+]);
+function skip(code, text) {
 	return {
-		orphaned: classified.orphaned.map((entry) => Object.assign({}, entry, { bytes: sizeOf(entry.dir) })),
-		skipped: classified.skipped
+		code,
+		text
 	};
 }
-const REBUILD_COST = "The next build of an unchanged app installs from the shared build cache; after a native change the compilation cache speeds the rebuild, but on React Native 0.86 Swift does not use it (explicit modules are off), so that build recompiles Swift.";
-const WORKSPACE_OUTPUT_DIRS = [
-	"derived-data",
-	"gradle-build",
-	"android-cas",
-	"cache-provider"
-];
-const DAY_MS$1 = 864e5;
-function planWorkspaceOutputs(entries, { olderThan, now }) {
-	return entries.map(({ dir, projectRoot, problem, bytes, lastUsed, inUse }) => {
-		const idleDays = Number.isFinite(lastUsed) ? Math.max(0, Math.floor((now - lastUsed) / DAY_MS$1)) : null;
-		const [keptCode, keptReason] = projectRoot === null ? ["unresolved", `workspace directory not resolved: ${problem ?? "unknown project root"}`] : inUse.length ? ["in-use", `in use: ${inUse.join("; ")}`] : olderThan === null ? [null, null] : idleDays === null ? ["last-use-unknown", "its last use is unknown"] : idleDays < olderThan ? ["recently-used", `used ${idleDays}d ago, within --older-than ${olderThan}`] : [null, null];
-		return {
-			dir,
-			projectRoot,
-			bytes,
-			idleDays,
-			willClear: keptCode === null,
-			keptCode,
-			keptReason
-		};
-	});
+function worktreeSkipReason(facts, olderThan) {
+	if (facts.bare) return skip("bare-repository", "bare repository");
+	if (typeof facts.source === "object") return skip("source-checkout-unknown", `source checkout unknown: ${facts.source.refusal}`);
+	if (facts.source === "source") return skip("source-checkout", "source checkout");
+	if (facts.locked) return skip("locked", "locked with git worktree lock");
+	if (facts.inUse.length) return skip("in-use", `in use: ${facts.inUse.join("; ")}`);
+	if (facts.porcelain === null) return skip("status-unreadable", "git status could not be read");
+	if (excludePodChurn(facts.porcelain).lines.length) return skip("dirty", "dirty: uncommitted changes or untracked files");
+	if (facts.unpushed === null) return skip("unpushed-unchecked", "unpushed commits could not be checked");
+	const merged = facts.merge?.merged ? facts.merge : null;
+	if (facts.unpushed.length && !merged?.coversUnpushed) return skip("unpushed", `unpushed: ${plural(facts.unpushed.length, "commit")} on no remote or other branch`);
+	if (facts.submodules) return skip("submodules", "initialized submodules");
+	if (merged) return null;
+	const notMerged = facts.merge && !facts.merge.merged ? facts.merge : null;
+	if (olderThan === null) return skip(notMerged?.unknown ? "merge-unknown" : "not-merged", notMerged?.detail ?? "not merged");
+	const also = notMerged ? `; ${notMerged.detail}` : "";
+	if (facts.idleDays === null) return skip("last-use-unknown", `recently used: its last use is unknown${also}`);
+	if (facts.idleDays < olderThan) return skip("recently-used", `recently used ${facts.idleDays}d ago${also}`);
+	return null;
 }
-const SIZE_TIMEOUT_MS = 6e4;
-function sizeOf(dir) {
-	return measuredDirectorySize(dir, { timeoutMs: SIZE_TIMEOUT_MS });
+/** Why gc removes a worktree it did not skip: `merged into origin/main` or `idle 9d`. */
+function worktreeRemovalReason(candidate) {
+	return candidate.merge?.merged ? `merged into ${candidate.merge.into}` : `idle ${candidate.idleDays ?? 0}d`;
 }
-function outputPaths(dir) {
-	return WORKSPACE_OUTPUT_DIRS.map((name) => join(dir, name)).filter((path) => existsSync(path));
+function lastUsedOf(keys) {
+	const times = keys.map(workspaceLastUsed).filter(Number.isFinite);
+	return times.length ? Math.max(...times) : NaN;
 }
-function outputBytes(paths) {
-	let total = 0;
-	for (const path of paths) {
-		const size = sizeOf(path);
-		if (size === null) return null;
-		total += size;
-	}
-	return total;
+function idleDaysOf(keys, now) {
+	const last = lastUsedOf(keys);
+	return Number.isFinite(last) ? Math.max(0, Math.floor((now - last) / DAY_MS)) : null;
 }
-function collectWorkspaceOutputs({ olderThan, now, exclude = [] }) {
-	const mountedVolumes = listMountedVolumes();
-	const entries = listWorkspaceDirs().filter((entry) => !exclude.includes(entry.dir)).filter((entry) => entry.projectRoot === null || isOnMountedVolume(entry.projectRoot, mountedVolumes)).map((entry) => Object.assign({}, entry, { paths: outputPaths(entry.dir) })).filter((entry) => entry.paths.length > 0).map(({ paths, ...entry }) => Object.assign({}, entry, { bytes: outputBytes(paths) })).map((entry) => Object.assign({}, entry, {
-		lastUsed: entry.projectRoot === null ? NaN : workspaceLastUsed(entry.projectRoot),
-		inUse: entry.projectRoot === null ? [] : workspaceInUse(entry.projectRoot)
-	}));
-	return {
-		root: workspacesRoot(),
-		workspaces: planWorkspaceOutputs(entries, {
-			olderThan,
-			now
-		})
-	};
+function inUseOf(keys, checks) {
+	return [...new Set(keys.flatMap((key) => workspaceInUse(key, checks)))];
 }
-async function clearWorkspaceOutputs(report, { olderThan, now = Date.now() }) {
-	let failures = 0;
-	let cleared = 0;
-	for (const entry of report.workspaces) {
-		const root = entry.projectRoot;
-		if (!entry.willClear || root === null) {
-			if (entry.keptReason) console.log(chalk.dim(`Kept the build outputs of ${root ?? entry.dir}: ${entry.keptReason}`));
-			continue;
-		}
-		let run;
-		try {
-			run = await withIdleWorkspace(root, () => {
-				const [again] = planWorkspaceOutputs([{
-					...entry,
-					problem: null,
-					lastUsed: workspaceLastUsed(root),
-					inUse: []
-				}], {
-					olderThan,
-					now
-				});
-				if (again?.keptReason) return again.keptReason;
-				for (const name of WORKSPACE_OUTPUT_DIRS) rmSync(join(entry.dir, name), {
-					recursive: true,
-					force: true
-				});
-				return null;
-			}, { purpose: "gc" });
-		} catch (error) {
-			failures++;
-			console.log(chalk.red(`Could not clear the build outputs of ${root}: ${error?.message || String(error)}`));
-			continue;
+function porcelainOf(path, gitAnswered) {
+	if (gitAnswered === null) return null;
+	if (!gitAnswered) return [];
+	const lines = dirtyPaths(path, { limit: Infinity });
+	return lines.length ? lines : null;
+}
+function candidateRoots() {
+	const registered = Object.keys(loadConfig()?.projects ?? {}).filter(isAbsolute);
+	const recorded = listWorkspaceDirs().flatMap((entry) => entry.projectRoot ? [entry.projectRoot] : []);
+	return [.../* @__PURE__ */ new Set([...registered, ...recorded])].filter((root) => existsSync$1(root)).toSorted();
+}
+function checkMergeStates(pending, idle, now) {
+	const repos = /* @__PURE__ */ new Map();
+	for (const entry of pending) repos.set(entry.repo, [...repos.get(entry.repo) ?? [], entry]);
+	for (const [repo, entries] of repos) {
+		const target = fetchDefaultBranch(repo, now);
+		for (const { candidate, facts } of entries) {
+			const merge = "error" in target ? {
+				merged: false,
+				unknown: true,
+				detail: `merge state unknown: ${target.error}`
+			} : mergeState(candidate.path, target);
+			const verdict = worktreeSkipReason({
+				...facts,
+				merge
+			}, idle);
+			Object.assign(candidate, {
+				merge,
+				skipCode: verdict?.code ?? null,
+				skipped: verdict?.text ?? null
+			});
 		}
-		const kept = run.ran ? run.value : `in use: ${run.reasons.join("; ")}`;
-		if (kept) {
-			console.log(chalk.yellow(`Kept the build outputs of ${root}: ${kept}`));
+	}
+}
+/**
+* Classifies each Stim-managed linked worktree. A merged one is removable; with `idle`, so is one unused for
+* `olderThan` days. Merge state is checked only where it decides the verdict, after one fetch per repository.
+*/
+function collectWorktreeSweep({ idle, olderThan, now }) {
+	const days = idle ? olderThan ?? DEFAULT_WORKTREE_IDLE_DAYS : null;
+	const groups = /* @__PURE__ */ new Map();
+	const outside = [];
+	for (const root of candidateRoots()) {
+		const entry = matchWorktreeEntry(listWorktrees(root), root);
+		if (!entry) {
+			outside.push({
+				path: root,
+				keys: [root],
+				idleDays: null,
+				merge: null,
+				skipCode: "not-a-worktree",
+				skipped: "not inside a git worktree"
+			});
 			continue;
 		}
-		cleared += entry.bytes ?? 0;
-		console.log(chalk.green(`Cleared the build outputs of ${root} (${sizeText(entry.bytes)})`));
+		groups.set(entry.path, [...groups.get(entry.path) ?? [], root]);
 	}
-	if (cleared) console.log(chalk.dim(`Cleared ${formatBytes(cleared)} of workspace build outputs. ${REBUILD_COST}`));
-	return failures;
-}
-function stillOrphaned({ dir, projectRoot }) {
-	if (readRecordedRoot(dir, basename(dir)).projectRoot !== projectRoot || rootPresence(projectRoot) !== false || !isOnMountedVolume(projectRoot)) return false;
-	return !Object.keys(loadConfig()?.projects ?? {}).some((key) => isPathPrefix(projectRoot, key));
+	const worktrees = [];
+	const pending = [];
+	for (const [path, roots] of groups) {
+		const entries = listWorktrees(path);
+		const entry = matchWorktreeEntry(entries, path);
+		const source = sourceCheckoutOf(entries);
+		const keys = [.../* @__PURE__ */ new Set([...roots, ...reclaimKeys(path)])];
+		const idleDays = idleDaysOf(keys, now);
+		const linked = !("refusal" in source) && entry !== null && source.path !== entry.path;
+		const gitAnswered = linked ? hasUncommittedWork(path) : null;
+		const facts = {
+			source: "refusal" in source ? source : linked ? "linked" : "source",
+			bare: Boolean(entry?.bare),
+			locked: Boolean(entry?.locked),
+			porcelain: porcelainOf(path, gitAnswered),
+			unpushed: linked ? unpushedCommits(path) : null,
+			submodules: linked && hasPopulatedSubmodules(path),
+			inUse: linked ? inUseOf(keys, { managedLocks: true }) : [],
+			idleDays,
+			merge: null
+		};
+		const verdict = worktreeSkipReason(facts, days);
+		const candidate = {
+			path,
+			keys,
+			idleDays,
+			merge: null,
+			skipCode: verdict?.code ?? null,
+			skipped: verdict?.text ?? null
+		};
+		if (verdict && MERGE_DECIDES.has(verdict.code) && !("refusal" in source)) pending.push({
+			candidate,
+			facts,
+			repo: source.path
+		});
+		worktrees.push(candidate);
+	}
+	checkMergeStates(pending, days, now);
+	const listed = [...worktrees, ...outside].filter((w) => idle || w.skipCode !== "not-a-worktree" && w.skipCode !== "source-checkout");
+	return {
+		idle: days === null ? null : {
+			olderThan: days,
+			defaulted: olderThan === null
+		},
+		worktrees: listed
+	};
 }
-async function deleteOrphanedWorkspaces(orphaned) {
+async function removeWorktrees(sweep, { now = Date.now() } = {}) {
 	let failures = 0;
-	for (const entry of orphaned) {
-		if (!existsSync(entry.dir)) continue;
-		let run;
+	for (const candidate of sweep.worktrees) {
+		if (candidate.skipped) continue;
+		let kept = [];
+		const guard = (lockedKeys) => {
+			const keys = [.../* @__PURE__ */ new Set([...candidate.keys, ...lockedKeys])];
+			const unlocked = keys.filter((key) => !lockedKeys.includes(key));
+			const reasons = [...inUseOf(lockedKeys, { managedLocks: false }), ...inUseOf(unlocked, { managedLocks: true })].map((r) => `in use: ${r}`);
+			if (candidate.merge?.merged) {
+				if (resolveFullRef(candidate.path, "HEAD") !== candidate.merge.head) reasons.push("its HEAD moved since gc checked it");
+			} else {
+				const idleDays = idleDaysOf(keys, now);
+				if (idleDays === null || !sweep.idle || idleDays < sweep.idle.olderThan) reasons.push(`used ${idleDays === null ? "at an unknown time" : `${idleDays}d ago`} since gc checked it`);
+			}
+			kept = reasons;
+			return reasons;
+		};
+		let removed = false;
 		try {
-			run = await withIdleWorkspace(entry.projectRoot, () => {
-				if (!stillOrphaned(entry)) return false;
-				emptyWorkspaceDir(entry.dir);
-				return true;
-			}, { purpose: "gc" });
+			const mergedHead = candidate.merge?.merged && candidate.merge.coversUnpushed ? candidate.merge.head : void 0;
+			removed = await removeWorktreeTarget(candidate.path, {
+				linkedOnly: true,
+				guard,
+				mergedHead
+			});
 		} catch (error) {
-			failures++;
-			console.log(chalk.red(`Could not remove ${entry.dir}: ${error?.message || error}`));
-			continue;
-		}
-		if (!run.ran) {
-			console.log(chalk.yellow(`Kept ${entry.dir}: ${run.reasons.join("; ")}`));
-			continue;
+			console.error(chalk.red(`Could not remove ${candidate.path}: ${error?.message || String(error)}`));
 		}
-		if (!run.value) {
-			console.log(chalk.yellow(`Kept ${entry.dir}: it can no longer be confirmed orphaned.`));
-			continue;
+		if (removed) console.log(chalk.green(`Removed the worktree ${candidate.path} (${worktreeRemovalReason(candidate)})`));
+		else if (kept.length) console.log(chalk.yellow(`Kept the worktree ${candidate.path}: ${kept.join("; ")}`));
+		else {
+			failures++;
+			console.error(chalk.yellow(`Kept the worktree ${candidate.path}; see the lines above for why.`));
 		}
-		const size = entry.bytes === void 0 ? "" : ` (${sizeText(entry.bytes)})`;
-		console.log(chalk.green(`Removed the orphaned workspace directory ${entry.dir}${size}`));
 	}
 	return failures;
 }
-function sizeText(bytes) {
-	return bytes === null ? "size unknown" : formatBytes(bytes);
-}
 //#endregion
 //#region src/commands/gc/report.ts
 function shortKey(key) {
@@ -1408,7 +868,7 @@ function unresolvedLockLines(locks, slots) {
 		"              run that yourself once you know nothing is building with it"
 	];
 }
-function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invalidProjects = [], orphanedWorkspaces = [], parkedSims = [], parkedAvds = [], orphanedDevices = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
+function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invalidProjects = [], orphanedWorkspaces = [], parkedSims = [], parkedAvds = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
 	stale: [],
 	live: [],
 	unresolved: []
@@ -1419,7 +879,7 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 }, deviceLeases = {
 	expired: [],
 	kept: []
-}, deviceSweepNotices = [], easSessionSweep = {
+}, idleDevices = [], deviceSweepNotices = [], easSessionSweep = {
 	projectScope: null,
 	orphaned: [],
 	notices: [],
@@ -1465,6 +925,14 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 		lines.push(`Orphaned devices (${orphanedDevices.length}):`);
 		for (const d of orphanedDevices) lines.push(`  ${d.kind} ${d.name} (${d.id})${deviceSizeSuffix(d)}`);
 	}
+	if (unverifiedDevices.length) {
+		lines.push(`Unrecognized stim-* devices (${unverifiedDevices.length}) - NOT deleted, because Stim has no record of creating them:`);
+		for (const d of unverifiedDevices) {
+			lines.push(`  ${d.kind} ${d.name} (${d.id})`);
+			lines.push(`              ${unverifiedDeviceCommand(d)}`);
+		}
+		lines.push("              run that yourself if you no longer need it");
+	}
 	if (staleDevices.length) {
 		lines.push(`Stale owned devices (${staleDevices.length}) - workspace unused for ${olderThan ?? "?"}d or more:`);
 		for (const d of staleDevices) {
@@ -1472,6 +940,7 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 			lines.push(`              ${d.project} (idle ${d.idleDays}d)`);
 		}
 	}
+	lines.push(...idleDeviceLines(idleDevices));
 	if (staleDeviceRecords.length) {
 		lines.push(`Stale device records (${staleDeviceRecords.length}) - the device is gone, the project is not:`);
 		for (const r of staleDeviceRecords) {
@@ -1610,16 +1079,16 @@ function cacheLines(caches, workspaceOutputs) {
 	return lines;
 }
 function worktreeSweepLines(sweep) {
-	if (!sweep) return [];
+	if (!sweep || !sweep.idle && !sweep.worktrees.length) return [];
 	const removable = sweep.worktrees.filter((w) => !w.skipped);
-	const idle = sweep.defaulted ? `idle ${sweep.olderThan}d or more (the default without --older-than)` : `idle ${sweep.olderThan}d or more`;
-	const lines = [`Linked worktrees (${removable.length} removable, ${sweep.worktrees.length - removable.length} kept) - clean, pushed, ${idle}:`];
+	const idle = !sweep.idle ? "" : sweep.idle.defaulted ? `, or clean, pushed and idle ${sweep.idle.olderThan}d or more (the default without --older-than)` : `, or clean, pushed and idle ${sweep.idle.olderThan}d or more`;
+	const lines = [`Linked worktrees (${removable.length} removable, ${sweep.worktrees.length - removable.length} kept) - clean and merged into the default branch${idle}:`];
 	for (const w of sweep.worktrees) {
 		const age = w.idleDays === null ? "" : ` (idle ${w.idleDays}d)`;
 		lines.push(`  ${w.path}${age}`);
-		lines.push(w.skipped ? `              kept: ${w.skipped}` : "              would be REMOVED by `stim worktree remove`");
+		lines.push(w.skipped ? `              kept: ${w.skipped}` : `              would be REMOVED by \`stim worktree remove\`: ${worktreeRemovalReason(w)}`);
 	}
-	if (removable.length) lines.push("              --delete runs it without --force; use and idleness are re-checked under its removal locks.");
+	if (removable.length) lines.push("              --delete runs it without --force; use, idleness and HEAD are re-checked under its removal locks.");
 	return lines;
 }
 function jsonLock({ path, platform, key, pid, projectRoot }) {
@@ -1631,7 +1100,7 @@ function jsonLock({ path, platform, key, pid, projectRoot }) {
 		projectRoot
 	};
 }
-function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [], invalidProjects = [], orphanedWorkspaces = [], worktreeSweep = null, parkedSims = [], parkedAvds = [], orphanedDevices = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
+function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [], invalidProjects = [], orphanedWorkspaces = [], worktreeSweep = null, parkedSims = [], parkedAvds = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
 	stale: [],
 	live: [],
 	unresolved: []
@@ -1642,7 +1111,7 @@ function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [],
 }, deviceLeases = {
 	expired: [],
 	kept: []
-}, deviceSweepNotices = [], easSessionSweep = {
+}, idleDevices = [], deviceSweepNotices = [], easSessionSweep = {
 	projectScope: null,
 	orphaned: [],
 	notices: [],
@@ -1664,9 +1133,10 @@ function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [],
 		linkedWorktrees: (worktreeSweep?.worktrees ?? []).map((w) => ({
 			path: w.path,
 			idleDays: w.idleDays,
+			mergedInto: w.merge?.merged ? w.merge.into : null,
 			willRemove: w.skipCode === null,
 			reason: w.skipCode,
-			detail: w.skipped
+			detail: w.skipped ?? worktreeRemovalReason(w)
 		})),
 		parkedSimulators: parkedSims.map(({ udid, name, model, runtime, parkedAt, bytes, listed }) => ({
 			udid,
@@ -1691,6 +1161,12 @@ function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [],
 			bytes: d.bytes ?? null,
 			directory: d.orphanedDirectory?.directory ?? null
 		})),
+		unverifiedDevices: unverifiedDevices.map((d) => ({
+			kind: d.kind,
+			id: d.id,
+			name: d.name,
+			command: unverifiedDeviceCommand(d)
+		})),
 		staleDevices: staleDevices.map((d) => ({
 			kind: d.kind,
 			id: d.id,
@@ -1706,6 +1182,16 @@ function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [],
 			project: r.project,
 			slot: r.slot ?? null
 		})),
+		idleDevices: idleDevices.map(({ kind, id, name, project, slot, lastActivityAt, idleForMs, buildInProgress }) => ({
+			kind,
+			id,
+			name,
+			project,
+			slot,
+			lastActivityAt,
+			idleForMs,
+			buildInProgress
+		})),
 		orphanedEasSessions: easSessionSweep.orphaned.map((s) => ({
 			id: s.id,
 			name: s.name,
@@ -1768,136 +1254,6 @@ function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [],
 	};
 }
 //#endregion
-//#region src/commands/gc/worktrees.ts
-const DEFAULT_WORKTREE_IDLE_DAYS = 7;
-const DAY_MS = 864e5;
-function skip(code, text) {
-	return {
-		code,
-		text
-	};
-}
-function worktreeSkipReason(facts, olderThan) {
-	if (facts.bare) return skip("bare-repository", "bare repository");
-	if (typeof facts.source === "object") return skip("source-checkout-unknown", `source checkout unknown: ${facts.source.refusal}`);
-	if (facts.source === "source") return skip("source-checkout", "source checkout");
-	if (facts.locked) return skip("locked", "locked with git worktree lock");
-	if (facts.inUse.length) return skip("in-use", `in use: ${facts.inUse.join("; ")}`);
-	if (facts.porcelain === null) return skip("status-unreadable", "git status could not be read");
-	if (excludePodChurn(facts.porcelain).lines.length) return skip("dirty", "dirty: uncommitted changes or untracked files");
-	if (facts.unpushed === null) return skip("unpushed-unchecked", "unpushed commits could not be checked");
-	if (facts.unpushed.length) return skip("unpushed", `unpushed: ${plural(facts.unpushed.length, "commit")} on no remote or other branch`);
-	if (facts.submodules) return skip("submodules", "initialized submodules");
-	if (facts.idleDays === null) return skip("last-use-unknown", "recently used: its last use is unknown");
-	if (facts.idleDays < olderThan) return skip("recently-used", `recently used ${facts.idleDays}d ago`);
-	return null;
-}
-function lastUsedOf(keys) {
-	const times = keys.map(workspaceLastUsed).filter(Number.isFinite);
-	return times.length ? Math.max(...times) : NaN;
-}
-function idleDaysOf(keys, now) {
-	const last = lastUsedOf(keys);
-	return Number.isFinite(last) ? Math.max(0, Math.floor((now - last) / DAY_MS)) : null;
-}
-function inUseOf(keys, checks) {
-	return [...new Set(keys.flatMap((key) => workspaceInUse(key, checks)))];
-}
-function porcelainOf(path, gitAnswered) {
-	if (gitAnswered === null) return null;
-	if (!gitAnswered) return [];
-	const lines = dirtyPaths(path, { limit: Infinity });
-	return lines.length ? lines : null;
-}
-function candidateRoots() {
-	const registered = Object.keys(loadConfig()?.projects ?? {}).filter(isAbsolute);
-	const recorded = listWorkspaceDirs().flatMap((entry) => entry.projectRoot ? [entry.projectRoot] : []);
-	return [.../* @__PURE__ */ new Set([...registered, ...recorded])].filter((root) => existsSync(root)).toSorted();
-}
-function collectWorktreeSweep({ olderThan, now }) {
-	const days = olderThan ?? DEFAULT_WORKTREE_IDLE_DAYS;
-	const groups = /* @__PURE__ */ new Map();
-	const outside = [];
-	for (const root of candidateRoots()) {
-		const entry = matchWorktreeEntry(listWorktrees(root), root);
-		if (!entry) {
-			outside.push({
-				path: root,
-				keys: [root],
-				idleDays: null,
-				skipCode: "not-a-worktree",
-				skipped: "not inside a git worktree"
-			});
-			continue;
-		}
-		groups.set(entry.path, [...groups.get(entry.path) ?? [], root]);
-	}
-	const worktrees = [];
-	for (const [path, roots] of groups) {
-		const entries = listWorktrees(path);
-		const entry = matchWorktreeEntry(entries, path);
-		const source = sourceCheckoutOf(entries);
-		const keys = [.../* @__PURE__ */ new Set([...roots, ...reclaimKeys(path)])];
-		const idleDays = idleDaysOf(keys, now);
-		const linked = !("refusal" in source) && entry !== null && source.path !== entry.path;
-		const gitAnswered = linked ? hasUncommittedWork(path) : null;
-		const verdict = worktreeSkipReason({
-			source: "refusal" in source ? source : linked ? "linked" : "source",
-			bare: Boolean(entry?.bare),
-			locked: Boolean(entry?.locked),
-			porcelain: porcelainOf(path, gitAnswered),
-			unpushed: linked ? unpushedCommits(path) : null,
-			submodules: linked && hasPopulatedSubmodules(path),
-			inUse: linked ? inUseOf(keys, { managedLocks: true }) : [],
-			idleDays
-		}, days);
-		worktrees.push({
-			path,
-			keys,
-			idleDays,
-			skipCode: verdict?.code ?? null,
-			skipped: verdict?.text ?? null
-		});
-	}
-	return {
-		olderThan: days,
-		defaulted: olderThan === null,
-		worktrees: [...worktrees, ...outside]
-	};
-}
-async function removeWorktrees(sweep, { now = Date.now() } = {}) {
-	let failures = 0;
-	for (const candidate of sweep.worktrees) {
-		if (candidate.skipped) continue;
-		let kept = [];
-		const guard = (lockedKeys) => {
-			const keys = [.../* @__PURE__ */ new Set([...candidate.keys, ...lockedKeys])];
-			const unlocked = keys.filter((key) => !lockedKeys.includes(key));
-			const reasons = [...inUseOf(lockedKeys, { managedLocks: false }), ...inUseOf(unlocked, { managedLocks: true })].map((r) => `in use: ${r}`);
-			const idleDays = idleDaysOf(keys, now);
-			if (idleDays === null || idleDays < sweep.olderThan) reasons.push(`used ${idleDays === null ? "at an unknown time" : `${idleDays}d ago`} since gc checked it`);
-			kept = reasons;
-			return reasons;
-		};
-		let removed = false;
-		try {
-			removed = await removeWorktreeTarget(candidate.path, {
-				linkedOnly: true,
-				guard
-			});
-		} catch (error) {
-			console.error(chalk.red(`Could not remove ${candidate.path}: ${error?.message || String(error)}`));
-		}
-		if (removed) console.log(chalk.green(`Removed the worktree ${candidate.path}`));
-		else if (kept.length) console.log(chalk.yellow(`Kept the worktree ${candidate.path}: ${kept.join("; ")}`));
-		else {
-			failures++;
-			console.error(chalk.yellow(`Kept the worktree ${candidate.path}; see the lines above for why.`));
-		}
-	}
-	return failures;
-}
-//#endregion
 //#region src/commands/gc.ts
 function removeInvalidProjectEntries(invalidProjects) {
 	for (const path of invalidProjects) {
@@ -1909,13 +1265,15 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	const scope = typeof cache === "string" && cache.trim() ? cache : null;
 	const all = scope !== null && olderThan === null;
 	const withWorkspaces = includesWorkspaceOutputs(scope);
-	const caches = planCacheEmptying(sizeCaches(selectCaches(discoverCaches(), scope).filter((c) => !withWorkspaces || !isInsideWorkspaces(c.dir))), all);
+	const selected = selectCaches(discoverCaches(), scope).filter((c) => !withWorkspaces || !isInsideWorkspaces(c.dir));
+	const caches = planCacheEmptying(sizeCaches(selected), all);
 	if (scope) return {
 		skipped: [],
 		deadProjects: [],
 		invalidProjects: [],
 		orphanedWorkspaces: [],
 		orphanedDevices: [],
+		unverifiedDevices: [],
 		staleDevices: [],
 		staleDeviceRecords: [],
 		buildLocks: {
@@ -1932,6 +1290,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			expired: [],
 			kept: []
 		},
+		idleDevices: [],
 		deviceSweepNotices: [],
 		easSessionSweep: {
 			projectScope: null,
@@ -1964,8 +1323,14 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			deletionSafe: false
 		};
 	}
-	const parkedSims = collectParkedSims(deps);
-	const parkedAvds = collectParkedAvds(deps);
+	const parkedSims = collectParkedSims(deps, {
+		olderThanDays: olderThan,
+		now
+	});
+	const parkedAvds = collectParkedAvds(deps, {
+		olderThanDays: olderThan,
+		now
+	});
 	const deadProjects = [];
 	const invalidProjects = [];
 	const skipped = [];
@@ -1979,7 +1344,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			else invalidProjects.push(path);
 			continue;
 		}
-		if (existsSync(path)) continue;
+		if (existsSync$1(path)) continue;
 		if (!isOnMountedVolume(path, mountedVolumes)) {
 			const volume = volumeRootFor(path);
 			skipped.push({
@@ -1992,8 +1357,10 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 	skipped.push(...workspaceDirs.skipped);
 	const deviceSweepNotices = [];
 	let orphanedDevices = [];
+	let unverifiedDevices = [];
 	let staleDevices = [];
 	let staleDeviceRecords = [];
+	let idleDevices = [];
 	const unsweepableReason = cfg === null ? "no Stim config found" : deviceSweepIsScoped() ? "STIM_HOME scopes this config, but simulators and AVDs are machine-global" : null;
 	if (unsweepableReason) {
 		let simNames = [];
@@ -2031,19 +1398,26 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		}
 		avds = [.../* @__PURE__ */ new Set([...avds, ...orphanedAvdDirectories.map((entry) => entry.name)])];
 		const isMounted = (path) => isOnMountedVolume(path, mountedVolumes);
-		orphanedDevices = withAndroidAvdSizes(findOrphanedDevices({
+		const found = findOrphanedDevices({
 			sims,
 			avds,
 			config: cfg,
 			isMounted,
-			deadProjects
-		}).orphaned.flatMap((device) => {
+			deadProjects,
+			isOwned: (device) => device.kind === "ios" ? isStimOwnedSim({
+				udid: device.id,
+				name: device.name
+			}) : isStimOwnedAvdName(device.id, ownedAvdDirectory(device.id) ?? orphanedAvdDirectories.find((entry) => entry.name === device.id)?.directory ?? null)
+		});
+		unverifiedDevices = found.unverified;
+		orphanedDevices = 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
 		});
+		idleDevices = collectIdleDevices(cfg, sims, deadProjects, now);
 		staleDeviceRecords = findStaleDeviceRecords({
 			config: cfg,
 			sims,
@@ -2081,6 +1455,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 		parkedSims,
 		parkedAvds,
 		orphanedDevices,
+		unverifiedDevices,
 		staleDevices,
 		staleDeviceRecords,
 		buildLocks: {
@@ -2094,6 +1469,7 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			unresolved: slots.filter((s) => s.unresolved)
 		},
 		deviceLeases,
+		idleDevices,
 		deviceSweepNotices,
 		easSessionSweep,
 		caches,
@@ -2102,10 +1478,11 @@ async function collectGcReport({ olderThan = null, cache = null, worktrees = fal
 			now,
 			exclude: [...workspaceDirs.orphaned.map((entry) => entry.dir), ...deadProjects.map(workspaceDir)]
 		}),
-		worktreeSweep: worktrees ? collectWorktreeSweep({
+		worktreeSweep: collectWorktreeSweep({
+			idle: worktrees,
 			olderThan,
 			now
-		}) : null,
+		}),
 		cacheScope: null,
 		olderThan,
 		all
@@ -2127,15 +1504,18 @@ async function runGc(opts = {}, deps = {}) {
 	console.log(JSON.stringify(payload));
 }
 async function sweep(opts, deps) {
-	if (opts.cache && opts.worktrees) {
-		console.error(chalk.red("--cache acts only on the named caches, and --worktrees sweeps linked worktrees."));
-		console.error(chalk.dim("Run `stim gc --worktrees` and `stim gc --cache <name>` separately."));
+	if (opts.cache && (opts.worktrees || opts.idle !== void 0)) {
+		const flag = opts.worktrees ? "--worktrees" : "--idle";
+		const message = opts.worktrees ? "--cache acts only on the named caches, and --worktrees sweeps linked worktrees." : "--cache acts only on the named caches, and --idle shuts down idle owned devices.";
+		const remedy = `Run \`stim gc ${flag}${opts.worktrees ? "" : " <duration>"}\` and \`stim gc --cache <name>\` separately.`;
+		console.error(chalk.red(message));
+		console.error(chalk.dim(remedy));
 		console.error(chalk.red("failed: STIM_BAD_ARG"));
 		process.exitCode = 1;
 		return {
 			code: "STIM_BAD_ARG",
-			message: "--cache acts only on the named caches, and --worktrees sweeps linked worktrees.",
-			remedy: "Run `stim gc --worktrees` and `stim gc --cache <name>` separately."
+			message,
+			remedy
 		};
 	}
 	const poolError = parkedMaxSetting("ios").error || parkedMaxSetting("android").error;
@@ -2230,14 +1610,15 @@ async function runGcCore(opts, deps) {
 	for (const line of formatGcReport(report)) console.log(line);
 	const { deadProjects, invalidProjects, orphanedDevices, staleDevices, staleDeviceRecords, buildLocks, buildSlots, deviceLeases, easSessionSweep, caches } = report;
 	const actionable = deadProjects.length + invalidProjects.length > 0 || report.orphanedWorkspaces.length > 0 || Boolean(report.workspaceOutputs?.workspaces.some((entry) => entry.willClear)) || Boolean(report.worktreeSweep?.worktrees.some((entry) => !entry.skipped)) || report.parkedSims.length > 0 || report.parkedAvds.length > 0 || orphanedDevices.length > 0 || staleDevices.length > 0 || staleDeviceRecords.length > 0 || buildLocks.stale.length > 0 || buildSlots.stale.length > 0 || deviceLeases.expired.length > 0 || easSessionSweep.orphaned.length > 0 || (olderThan !== null || all) && caches.length > 0;
+	const idle = opts.idle ?? null;
+	const idleFailures = idle === null ? 0 : shutDownIdleDevices(report.idleDevices, idle, () => collectIdleDevices(loadConfig(), listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }), report.deadProjects)).failures;
+	if (idleFailures) process.exitCode = 1;
 	const payload = (failures) => ({
 		mode: opts.delete ? "delete" : "dry-run",
+		idle,
 		cacheScope: report.cacheScope,
 		olderThan,
-		worktreeSweep: report.worktreeSweep ? {
-			olderThan: report.worktreeSweep.olderThan,
-			defaulted: report.worktreeSweep.defaulted
-		} : null,
+		worktreeSweep: report.worktreeSweep?.idle ?? null,
 		actionable,
 		failures,
 		sections: gcReportSections(report)
@@ -2246,13 +1627,14 @@ async function runGcCore(opts, deps) {
 		if (all) console.log(chalk.dim("\nDry run. Re-run with --delete to empty the caches above."));
 		else if (actionable) console.log(chalk.dim("\nDry run. Re-run with --delete to reclaim."));
 		else if (caches.length) console.log(chalk.dim("\nPass --delete --cache all to empty the caches above, or --delete --older-than <days> to trim them."));
-		return payload(null);
+		return payload(idle === null ? null : idleFailures);
 	}
-	let deleteFailures = report.workspaceOutputs ? await clearWorkspaceOutputs(report.workspaceOutputs, { olderThan }) : 0;
+	let deleteFailures = idleFailures;
+	deleteFailures += report.workspaceOutputs ? (await clearWorkspaceOutputs(report.workspaceOutputs, { olderThan })).failures : 0;
 	deleteFailures += deleteParkedSims(report.parkedSims, deps) + deleteParkedAvds(report.parkedAvds);
 	removeInvalidProjectEntries(invalidProjects);
 	for (const path of deadProjects) {
-		if (existsSync(path) || !isOnMountedVolume(path)) {
+		if (existsSync$1(path) || !isOnMountedVolume(path)) {
 			console.log(chalk.yellow(`Kept ${path}: its absence can no longer be confirmed.`));
 			continue;
 		}
@@ -2331,13 +1713,17 @@ 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, 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, and the build outputs of each workspace. Reports by default; pass --delete to act.").option("--worktrees", "also report every clean, idle, Stim-managed linked worktree, and 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, and clear the build outputs of every workspace not in use").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 clear workspace build outputs only for workspaces idle 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, 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, and the build outputs of each workspace. 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, and clear the build outputs of every workspace not in use").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 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 and the workspace build outputs with --cache all, or only the workspace build outputs with --cache workspaces; all and workspaces are reserved names that never select a single cache. With --delete they are emptied whole, which is the only way to clear an index-backed cache; add --older-than <days> to trim them by age instead. Only those caches are reported; 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) => {
+		const ms = parseIdleDuration(v);
+		if (ms === null) throw new InvalidArgumentError("must be a whole number of minutes, hours, or days, e.g. --idle 2h");
+		return ms;
 	}).option("--json", "print the report as JSON on stdout; every other line goes to stderr").action(async (opts) => {
 		await runGc(opts);
 	});