stim 1.8.0 → 1.10.0

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

@@ -1,741 +1,23 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { A as isOnMountedVolume, C as withConfigLock, E as ownership_claim_exports, I as deviceSlotPlatforms, M as volumeRootFor, O as directorySize, R as projectDeviceSlots, f as getProject, g as loadConfig, i as clearDevice, j as listMountedVolumes, k as formatBytes, u as getConfigDir, v as removeProject } from "./config-B7iyKWkL.mjs";
-import { i as registeredCaches } from "./cache-manifest-CYJi8-Hx.mjs";
-import { h as workspaceDir, y as workspaceStateFile } from "./workspace-state-BT5E3SA2.mjs";
-import { g as repoRoot, s as gitCommonDir } from "./worktree-FG_ZKKdb.mjs";
-import { a as findProjectRoot, i as detectIsExpo } from "./project-DDZWf_16.mjs";
-import { A as resolveSettings, N as settingShapeErrors, a as SETTING_SHAPE_REMEDY } from "./settings-BXXorVM2.mjs";
-import { C as listAvds, O as ownedAvdDirectory, T as listOrphanedAvdDirectories } from "./android-DWssqHQ8.mjs";
-import { m as shortUdid, o as formatLongDuration, u as plural } from "./command-output-B3ycpsYv.mjs";
-import { r as listBuildLocks } from "./build-lock-CgtsB6TV.mjs";
-import { S as resolveEasCliBin, a as POOL_SETTING_REMEDY, i as teardownParkedIosSim, l as parkedMaxSetting, n as teardownOwnedIosSim, r as teardownParkedAvd, s as dropParked, t as teardownOwnedAvd, u as readParked } from "./teardown-BJqEzPo_.mjs";
-import { d as listIosDeviceTypes, g as parseRuntimeVersion, u as listAllIosSims } from "./ios-BcCiI4TS.mjs";
-import { i as listLeaseFiles, r as leaseIsExpired, u as removeExpiredLease } from "./device-lease-Ffz_M5t0.mjs";
-import { n as listBuildSlots } from "./build-slots-C-oAHRT1.mjs";
-import { C as verifyStoppedSession, S as stopSessionArgs, _ 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-ByN8P6CB.mjs";
-import { n as reclaimProject, t as describeDereferenced } from "./reclaim-KJ-0uWEF.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, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "fs";
-import { homedir, tmpdir } from "os";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
-import { METRO_NAMED_CACHE_LAYOUT } from "@stim-cli/core";
+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;
-	}
-	if (!names.length) return null;
-	let bytes = 0;
-	for (const n of names) try {
-		bytes += statSync(join(root, n)).size;
-	} catch {}
-	return {
-		name: "Metro file maps",
-		dir: root,
-		files: names.map((n) => join(root, n)),
-		bytes,
-		prune: "entries",
-		note: `${names.length} file(s), one per project root Metro has served`
-	};
-}
-function declaredCaches(paths) {
-	return (paths || []).map((p) => resolve(p.startsWith("~") ? join(homedir(), p.slice(1)) : p)).filter((p) => existsSync(p)).map((dir) => ({
-		name: "declared",
-		dir,
-		prune: "entries",
-		note: "from the `caches` setting"
-	}));
-}
-function projectSettings(cwd) {
-	const root = findProjectRoot(cwd);
-	if (!root) return {};
-	return resolveSettings({
-		projectPath: root,
-		gitCommonDir: gitCommonDir(root),
-		repoRoot: repoRoot(root)
-	});
-}
-function declaredCachePaths(cwd = process.cwd()) {
-	const declared = projectSettings(cwd).caches;
-	return Array.isArray(declared) ? declared : [];
-}
-function projectSettingShapeErrors(cwd = process.cwd()) {
-	return settingShapeErrors(projectSettings(cwd));
-}
-function discoverCaches({ declared = [] } = {}) {
-	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(),
-		...declaredCaches(declared)
-	].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;
-	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 {}
-	}
-	return {
-		removed,
-		bytes,
-		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/paths.ts
-function canonicalPath(p) {
-	try {
-		return realpathSync(p);
-	} catch {
-		return resolve(p);
-	}
-}
-//#endregion
-//#region src/commands/gc/caches.ts
-const DAY_MS$1 = 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";
-function selectCaches(caches, name) {
-	if (!name) return caches;
-	const wanted = name.trim().toLowerCase();
-	if (wanted === EVERY_CACHE) return caches;
-	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$1
-	});
-	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 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 console.log(chalk.dim(`${c.name}: nothing older than ${olderThan}d`));
-	}
-	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 console.log(chalk.dim(`${c.name}: already empty`));
-		if (r.failed) console.log(chalk.red(`  ${r.failed} entr${r.failed === 1 ? "y" : "ies"} in ${c.dir} could not be removed`));
-	}
-	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 = 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;
-	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);
-		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;
@@ -755,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)}`);
@@ -802,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,
@@ -816,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,
@@ -933,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)}`;
 	}
@@ -943,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.`;
 	}
@@ -1117,6 +399,426 @@ async function deleteEasSessions(easSessionSweep, deps) {
 	return deleteFailures;
 }
 //#endregion
+//#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 {
+		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 { error: `git fetch origin ${branch} failed: ${failure(error)}` };
+	}
+	return {
+		ref,
+		name: `origin/${branch}`
+	};
+}
+function notMerged(detail) {
+	return {
+		merged: false,
+		unknown: false,
+		detail
+	};
+}
+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 {
+		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
+			};
+		}
+		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)
+		});
+		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();
+		}
+		return notMerged(`not merged into ${name}`);
+	} catch (error) {
+		return {
+			merged: false,
+			unknown: true,
+			detail: `merge state unknown: ${failure(error)}`
+		};
+	}
+}
+//#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 {
+		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");
+	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;
+}
+/** 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 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$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
+			});
+		}
+	}
+}
+/**
+* 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;
+		}
+		groups.set(entry.path, [...groups.get(entry.path) ?? [], root]);
+	}
+	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 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}`);
+			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 {
+			const mergedHead = candidate.merge?.merged && candidate.merge.coversUnpushed ? candidate.merge.head : void 0;
+			removed = await removeWorktreeTarget(candidate.path, {
+				linkedOnly: true,
+				guard,
+				mergedHead
+			});
+		} 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} (${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.`));
+		}
+	}
+	return failures;
+}
+//#endregion
 //#region src/commands/gc/report.ts
 function shortKey(key) {
 	const text = String(key ?? "");
@@ -1162,11 +864,11 @@ function unresolvedLockLines(locks, slots) {
 	if (entries.length === 0) return [];
 	return [
 		`Build locks and slots Stim cannot resolve (${entries.length}) - NOT touched, because a dead holder and a live one cannot be told apart:`,
-		...entries.map((entry) => `  ${entry.path}`),
-		"              remove one yourself once you know nothing is building with it"
+		...entries.flatMap((entry) => [`  ${entry.path}`, `              ${(0, ownership_claim_exports.claimRemoveCommand)(entry.path)}`]),
+		"              run that yourself once you know nothing is building with it"
 	];
 }
-function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invalidProjects = [], parkedSims = [], parkedAvds = [], orphanedDevices = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
+function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invalidProjects = [], orphanedWorkspaces = [], parkedSims = [], parkedAvds = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
 	stale: [],
 	live: [],
 	unresolved: []
@@ -1177,19 +879,34 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 }, deviceLeases = {
 	expired: [],
 	kept: []
-}, deviceSweepNotices = [], easSessionSweep = {
+}, idleDevices = [], deviceSweepNotices = [], easSessionSweep = {
 	projectScope: null,
 	orphaned: [],
 	notices: [],
 	deletionSafe: true
-}, caches = [], cacheScope = null, olderThan = null }, { now = Date.now() } = {}) {
+}, caches = [], workspaceOutputs = null, worktreeSweep = null, cacheScope = null, olderThan = null }, { now = Date.now() } = {}) {
 	const lines = [];
 	const staleLocks = buildLocks?.stale ?? [];
 	const liveLocks = buildLocks?.live ?? [];
 	const staleSlots = buildSlots?.stale ?? [];
 	const expiredLeases = deviceLeases?.expired ?? [];
 	if (cacheScope) lines.push(`Cache scope: "${cacheScope}". Devices, project entries and locks were not inspected.`);
-	else if (deadProjects.length === 0 && invalidProjects.length === 0 && parkedSims.length === 0 && parkedAvds.length === 0 && orphanedDevices.length === 0 && staleDevices.length === 0 && staleDeviceRecords.length === 0 && staleLocks.length === 0 && staleSlots.length === 0 && expiredLeases.length === 0 && easSessionSweep.orphaned.length === 0) {
+	else if ([
+		deadProjects,
+		invalidProjects,
+		orphanedWorkspaces,
+		parkedSims,
+		parkedAvds,
+		orphanedDevices,
+		staleDevices,
+		staleDeviceRecords,
+		staleLocks,
+		staleSlots,
+		expiredLeases,
+		easSessionSweep.orphaned,
+		workspaceOutputs?.workspaces.filter((entry) => entry.willClear) ?? [],
+		worktreeSweep?.worktrees.filter((entry) => !entry.skipped) ?? []
+	].every((found) => found.length === 0)) {
 		const reasons = [];
 		if (skipped.length > 0) reasons.push(`${skipped.length} entr${skipped.length === 1 ? "y" : "ies"} could not be checked`);
 		if (deviceSweepNotices.length > 0) reasons.push("device sweep incomplete");
@@ -1200,19 +917,30 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 	lines.push(...projectEntryLines(`Dead project entries (${deadProjects.length}):`, deadProjects));
 	lines.push(...projectEntryLines(`Invalid project entries (${invalidProjects.length}) - the key is not an absolute path:`, invalidProjects));
 	lines.push(...namedPortLines(orphanedPorts));
+	lines.push(...orphanedWorkspaceLines(orphanedWorkspaces));
+	lines.push(...worktreeSweepLines(worktreeSweep));
 	lines.push(...formatParkedSimReport(parkedSims, now));
 	lines.push(...formatParkedAvdReport(parkedAvds, now));
 	if (orphanedDevices.length) {
 		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}) - project untouched for ${olderThan ?? "?"}d or more:`);
+		lines.push(`Stale owned devices (${staleDevices.length}) - workspace unused for ${olderThan ?? "?"}d or more:`);
 		for (const d of staleDevices) {
 			lines.push(`  ${d.kind} ${d.name} (${d.id})${deviceSizeSuffix(d)}`);
 			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) {
@@ -1265,24 +993,7 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 		lines.push(`Skipped (${skipped.length}) - not classified as dead:`);
 		for (const entry of skipped) lines.push(`  ${entry.dir}: ${entry.reason}`);
 	}
-	if (caches.length) {
-		const total = caches.reduce((n, c) => n + (c.bytes ?? 0), 0);
-		lines.push(`Shared build caches (${caches.length}) - alive, not garbage:`);
-		for (const c of caches) {
-			const tag = c.source ? ` (${c.source})` : "";
-			lines.push(`  ${formatBytes(c.bytes ?? 0).padStart(10)}  ${c.name}${tag}`);
-			lines.push(`              ${c.dir}`);
-			if (c.note) lines.push(`              ${c.note}`);
-			if (c.willEmpty) lines.push("              would be EMPTIED");
-			else if (c.emptySkipped) lines.push(`              would be left alone: ${c.emptySkipped}`);
-		}
-		lines.push(`  total: ${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(...cacheLines(caches, workspaceOutputs));
 	return lines;
 }
 function leaseGarbageLines({ expired, kept }) {
@@ -1313,6 +1024,235 @@ function namedPortLines(ports = []) {
 		"              --delete stops TCP listeners and releases these allocations."
 	];
 }
+function orphanedWorkspaceLines(orphaned) {
+	if (!orphaned.length) return [];
+	const lines = [`Orphaned workspace directories (${orphaned.length}):`];
+	for (const entry of orphaned) {
+		lines.push(`  ${entry.dir}${entry.bytes === void 0 ? "" : ` - ${sizeText(entry.bytes)}`}`);
+		lines.push(`              recorded project root ${entry.projectRoot} is gone and no registry entry names it`);
+	}
+	lines.push("              --delete re-checks each directory, then removes it whole.");
+	return lines;
+}
+function workspaceOutputLines(outputs, bytes) {
+	const lines = [
+		`  ${formatBytes(bytes).padStart(10)}  Workspace build outputs (detected)`,
+		`              ${outputs.root}`,
+		`              ${WORKSPACE_OUTPUT_DIRS.join(", ")} of each workspace; workspace.json, state.json, logs and device records stay`,
+		`              ${REBUILD_COST}`
+	];
+	for (const w of outputs.workspaces) {
+		const idle = w.idleDays === null ? "last use unknown" : `idle ${w.idleDays}d`;
+		lines.push(`    ${sizeText(w.bytes).padStart(8)}  ${w.projectRoot ?? w.dir} (${idle})`);
+		lines.push(w.willClear ? "                would be CLEARED" : `                kept: ${w.keptReason}`);
+	}
+	return lines;
+}
+function cacheLines(caches, workspaceOutputs) {
+	const lines = [];
+	const outputs = workspaceOutputs?.workspaces.length ? workspaceOutputs : null;
+	if (caches.length || outputs) {
+		const outputBytes = outputs ? outputs.workspaces.reduce((n, w) => n + (w.bytes ?? 0), 0) : 0;
+		const total = caches.reduce((n, c) => n + (c.bytes ?? 0), 0) + outputBytes;
+		lines.push(`Shared build caches (${caches.length + (outputs ? 1 : 0)}) - alive, not garbage:`);
+		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(`              ${c.dir}`);
+			if (c.note) lines.push(`              ${c.note}`);
+			if (c.willEmpty) lines.push("              would be EMPTIED");
+			else if (c.emptySkipped) lines.push(`              would be left alone: ${c.emptySkipped}`);
+		}
+		lines.push(`  total: ${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)})`);
+		}
+		const clearing = outputs?.workspaces.filter((w) => w.willClear) ?? [];
+		if (clearing.length) {
+			const clearBytes = clearing.reduce((n, w) => n + (w.bytes ?? 0), 0);
+			lines.push(`  would clear the build outputs of ${clearing.length} workspace${clearing.length === 1 ? "" : "s"} (${formatBytes(clearBytes)})`);
+		}
+	}
+	return lines;
+}
+function worktreeSweepLines(sweep) {
+	if (!sweep || !sweep.idle && !sweep.worktrees.length) return [];
+	const removable = sweep.worktrees.filter((w) => !w.skipped);
+	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\`: ${worktreeRemovalReason(w)}`);
+	}
+	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 }) {
+	return {
+		path,
+		platform,
+		key,
+		pid,
+		projectRoot
+	};
+}
+function gcReportSections({ skipped = [], deadProjects = [], orphanedPorts = [], invalidProjects = [], orphanedWorkspaces = [], worktreeSweep = null, parkedSims = [], parkedAvds = [], orphanedDevices = [], unverifiedDevices = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
+	stale: [],
+	live: [],
+	unresolved: []
+}, buildSlots = {
+	stale: [],
+	live: [],
+	unresolved: []
+}, deviceLeases = {
+	expired: [],
+	kept: []
+}, idleDevices = [], deviceSweepNotices = [], easSessionSweep = {
+	projectScope: null,
+	orphaned: [],
+	notices: [],
+	deletionSafe: true
+}, workspaceOutputs = null, caches = [] }) {
+	return {
+		deadProjects: deadProjects.map((path) => ({ path })),
+		invalidProjects: invalidProjects.map((path) => ({ path })),
+		orphanedPorts: orphanedPorts.map(({ project, label, port }) => ({
+			project,
+			label,
+			port
+		})),
+		orphanedWorkspaces: orphanedWorkspaces.map(({ dir, projectRoot, bytes }) => ({
+			dir,
+			projectRoot,
+			bytes: bytes ?? null
+		})),
+		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 ?? worktreeRemovalReason(w)
+		})),
+		parkedSimulators: parkedSims.map(({ udid, name, model, runtime, parkedAt, bytes, listed }) => ({
+			udid,
+			name,
+			model,
+			runtime,
+			parkedAt,
+			bytes,
+			listed
+		})),
+		parkedEmulators: parkedAvds.map(({ name, systemImage, parkedAt, bytes, listed }) => ({
+			name,
+			systemImage,
+			parkedAt,
+			bytes,
+			listed
+		})),
+		orphanedDevices: orphanedDevices.map((d) => ({
+			kind: d.kind,
+			id: d.id,
+			name: d.name,
+			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,
+			name: d.name,
+			project: d.project,
+			slot: d.slot ?? null,
+			idleDays: d.idleDays,
+			bytes: d.bytes ?? null
+		})),
+		staleDeviceRecords: staleDeviceRecords.map((r) => ({
+			kind: r.kind,
+			id: r.id,
+			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,
+			platform: s.platform,
+			status: s.status,
+			projectScope: s.projectScope
+		})),
+		staleBuildLocks: buildLocks.stale.map(jsonLock),
+		staleBuildSlots: buildSlots.stale.map((s) => ({
+			path: s.path,
+			index: s.index,
+			pid: s.pid,
+			projectRoot: s.projectRoot
+		})),
+		unresolvedBuildClaims: [...(buildLocks.unresolved ?? []).map((l) => ({
+			kind: "lock",
+			path: l.path
+		})), ...(buildSlots.unresolved ?? []).map((s) => ({
+			kind: "slot",
+			path: s.path
+		}))],
+		buildsInProgress: buildLocks.live.map(jsonLock),
+		expiredDeviceLeases: deviceLeases.expired.map((entry) => ({
+			path: entry.path,
+			platform: entry.platform,
+			id: entry.id ?? entry.name,
+			deviceName: entry.lease?.deviceName ?? null,
+			holder: entry.lease?.holder ?? null,
+			expiresAt: entry.lease?.expiresAt ?? null
+		})),
+		keptDeviceLeases: deviceLeases.kept.map(({ name, path, reason }) => ({
+			name,
+			path,
+			detail: reason
+		})),
+		deviceSweepNotices: deviceSweepNotices.map((message) => ({ message })),
+		easSessionSweepNotices: easSessionSweep.notices.map((message) => ({ message })),
+		skipped: skipped.map(({ dir, reason }) => ({
+			path: dir,
+			detail: reason
+		})),
+		workspaceBuildOutputs: (workspaceOutputs?.workspaces ?? []).map((w) => ({
+			dir: w.dir,
+			projectRoot: w.projectRoot,
+			bytes: w.bytes,
+			idleDays: w.idleDays,
+			willClear: w.willClear,
+			reason: w.keptCode,
+			detail: w.keptReason
+		})),
+		caches: caches.map((c) => ({
+			name: c.name,
+			dir: c.dir,
+			source: c.source ?? null,
+			bytes: c.bytes ?? null,
+			note: c.note || null,
+			willEmpty: Boolean(c.willEmpty),
+			emptySkipped: c.emptySkipped ?? null
+		}))
+	};
+}
 //#endregion
 //#region src/commands/gc.ts
 function removeInvalidProjectEntries(invalidProjects) {
@@ -1321,22 +1261,19 @@ function removeInvalidProjectEntries(invalidProjects) {
 		console.log(chalk.green(`Removed the invalid registry entry ${path}`));
 	}
 }
-function projectLastTouched(path) {
-	try {
-		return statSync(path).mtimeMs;
-	} catch {
-		return NaN;
-	}
-}
-async function collectGcReport({ olderThan = null, cache = null, now = Date.now(), lastTouched = projectLastTouched } = {}, deps = {}) {
+async function collectGcReport({ olderThan = null, cache = null, worktrees = false, now = Date.now(), lastTouched = workspaceLastUsed } = {}, deps = {}) {
 	const scope = typeof cache === "string" && cache.trim() ? cache : null;
 	const all = scope !== null && olderThan === null;
-	const caches = planCacheEmptying(sizeCaches(selectCaches(discoverCaches({ declared: declaredCachePaths() }), scope)), all);
+	const withWorkspaces = includesWorkspaceOutputs(scope);
+	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: {
@@ -1353,6 +1290,7 @@ async function collectGcReport({ olderThan = null, cache = null, now = Date.now(
 			expired: [],
 			kept: []
 		},
+		idleDevices: [],
 		deviceSweepNotices: [],
 		easSessionSweep: {
 			projectScope: null,
@@ -1363,6 +1301,11 @@ async function collectGcReport({ olderThan = null, cache = null, now = Date.now(
 		parkedSims: [],
 		parkedAvds: [],
 		caches,
+		workspaceOutputs: withWorkspaces ? collectWorkspaceOutputs({
+			olderThan,
+			now
+		}) : null,
+		worktreeSweep: null,
 		cacheScope: scope,
 		olderThan,
 		all
@@ -1380,8 +1323,14 @@ async function collectGcReport({ olderThan = null, cache = null, now = Date.now(
 			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 = [];
@@ -1395,7 +1344,7 @@ async function collectGcReport({ olderThan = null, cache = null, now = Date.now(
 			else invalidProjects.push(path);
 			continue;
 		}
-		if (existsSync(path)) continue;
+		if (existsSync$1(path)) continue;
 		if (!isOnMountedVolume(path, mountedVolumes)) {
 			const volume = volumeRootFor(path);
 			skipped.push({
@@ -1404,10 +1353,14 @@ async function collectGcReport({ olderThan = null, cache = null, now = Date.now(
 			});
 		} else deadProjects.push(path);
 	}
+	const workspaceDirs = collectOrphanedWorkspaces(Object.keys(cfg?.projects ?? {}), mountedVolumes);
+	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 = [];
@@ -1445,19 +1398,26 @@ async function collectGcReport({ olderThan = null, cache = null, now = Date.now(
 		}
 		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,
@@ -1491,9 +1451,11 @@ async function collectGcReport({ olderThan = null, cache = null, now = Date.now(
 			port
 		}))),
 		invalidProjects,
+		orphanedWorkspaces: workspaceDirs.orphaned,
 		parkedSims,
 		parkedAvds,
 		orphanedDevices,
+		unverifiedDevices,
 		staleDevices,
 		staleDeviceRecords,
 		buildLocks: {
@@ -1507,24 +1469,57 @@ async function collectGcReport({ olderThan = null, cache = null, now = Date.now(
 			unresolved: slots.filter((s) => s.unresolved)
 		},
 		deviceLeases,
+		idleDevices,
 		deviceSweepNotices,
 		easSessionSweep,
 		caches,
+		workspaceOutputs: collectWorkspaceOutputs({
+			olderThan,
+			now,
+			exclude: [...workspaceDirs.orphaned.map((entry) => entry.dir), ...deadProjects.map(workspaceDir)]
+		}),
+		worktreeSweep: collectWorktreeSweep({
+			idle: worktrees,
+			olderThan,
+			now
+		}),
 		cacheScope: null,
 		olderThan,
 		all
 	};
 }
 async function runGc(opts = {}, deps = {}) {
-	const poolError = parkedMaxSetting("ios").error || parkedMaxSetting("android").error;
-	if (poolError) console.error(chalk.yellow(`${poolError} ${POOL_SETTING_REMEDY}`));
-	const shapeErrors = (deps.settingShapeErrors ?? projectSettingShapeErrors)();
-	if (shapeErrors.length) {
-		for (const message of shapeErrors) console.error(chalk.red(message));
-		console.error(chalk.dim(SETTING_SHAPE_REMEDY));
-		process.exitCode = 1;
+	if (!opts.json) {
+		await sweep(opts, deps);
 		return;
 	}
+	const log = console.log;
+	console.log = console.error;
+	let payload;
+	try {
+		payload = await sweep(opts, deps);
+	} finally {
+		console.log = log;
+	}
+	console.log(JSON.stringify(payload));
+}
+async function sweep(opts, deps) {
+	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,
+			remedy
+		};
+	}
+	const poolError = parkedMaxSetting("ios").error || parkedMaxSetting("android").error;
+	if (poolError) console.error(chalk.yellow(`${poolError} ${POOL_SETTING_REMEDY}`));
 	if (opts.cache) return runGcCore(opts, {
 		...deps,
 		precollectedEasSessionSweep: {
@@ -1596,28 +1591,50 @@ async function runGcCore(opts, deps) {
 	const cache = typeof opts.cache === "string" && opts.cache.trim() ? opts.cache : null;
 	const report = await collectGcReport({
 		olderThan,
-		cache
+		cache,
+		worktrees: Boolean(opts.worktrees)
 	}, deps);
-	if (cache && report.caches.length === 0) {
-		const names = [...new Set(discoverCaches({ declared: declaredCachePaths() }).map((c) => c.name))];
-		console.log(chalk.yellow(`No shared cache carries "${cache}" in its name or directory.`));
+	if (cache && report.caches.length === 0 && report.workspaceOutputs === null) {
+		const names = [...new Set(discoverCaches().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(", ")}`));
-		return;
+		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."
+		};
 	}
 	const all = report.all;
 	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.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 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?.idle ?? null,
+		actionable,
+		failures,
+		sections: gcReportSections(report)
+	});
 	if (!opts.delete) {
 		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;
+		return payload(idle === null ? null : idleFailures);
 	}
-	let deleteFailures = deleteParkedSims(report.parkedSims, deps) + deleteParkedAvds(report.parkedAvds);
+	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;
 		}
@@ -1638,7 +1655,9 @@ async function runGcCore(opts, deps) {
 		if (result.stoppedSession) console.log(chalk.dim(`  stopped remote session ${result.stoppedSession}`));
 		if (result.stoppedTunnel) console.log(chalk.dim(`  stopped ${result.stoppedTunnel} tunnel`));
 		for (const s of result.skippedDevices) console.log(chalk.yellow(`  ${s.name}: ${s.reason}`));
+		deleteFailures += result.failedDevices.length;
 	}
+	deleteFailures += await deleteOrphanedWorkspaces(report.orphanedWorkspaces);
 	deleteFailures += deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords);
 	for (const lock of buildLocks.stale) {
 		const cleared = (0, ownership_claim_exports.clearFreeClaimSet)({
@@ -1682,26 +1701,30 @@ async function runGcCore(opts, deps) {
 		console.log(chalk.red(`Failed to clear the device lease at ${entry.path}: ${err?.message || err}`));
 	}
 	deleteFailures += await deleteEasSessions(easSessionSweep, deps);
-	if (deleteFailures) console.log(chalk.red(`\n${deleteFailures} entr${deleteFailures === 1 ? "y" : "ies"} could not be deleted; see above.`));
-	if (all) {
-		emptyCaches(caches);
-		return;
+	if (report.worktreeSweep) deleteFailures += await removeWorktrees(report.worktreeSweep);
+	if (deleteFailures) {
+		console.log(chalk.red(`\n${deleteFailures} entr${deleteFailures === 1 ? "y" : "ies"} could not be deleted; see above.`));
+		process.exitCode = 1;
 	}
-	if (olderThan === null) {
+	if (all) emptyCaches(caches);
+	else if (olderThan === null) {
 		if (caches.length) console.log(chalk.dim("Shared caches left alone: pass --cache all to empty them, or --older-than <days> to trim them."));
-		return;
-	}
-	trimCaches(caches, olderThan);
+	} else trimCaches(caches, olderThan);
+	return payload(deleteFailures);
 }
 function gcCommand(program) {
-	program.command("gc").description("Report what Stim has left behind: dead project entries, orphaned owned devices and EAS sessions, records of devices that no longer exist, build locks whose builder is gone, expired physical-device leases, and the shared build caches. Reports by default; pass --delete to act.").option("--delete", "actually prune the reported entries and reap the reported devices").option("--older-than <days>", "also reap owned devices whose project has been untouched this long, and trim shared cache entries nothing has used in that time", (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>, or every cache with --cache all, a reserved name that never selects 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) => {
+	}).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;
-	}).action(async (opts) => {
+	}).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);
 	});
 }