stim 1.8.0 → 1.9.0

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

@@ -1,24 +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 { 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 { InvalidArgumentError } from "commander";
-import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "fs";
-import { homedir, tmpdir } from "os";
+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 chalk from "chalk";
 //#region src/cache/caches.ts
 function xcodeDerivedDataRoot() {
@@ -54,45 +53,26 @@ function metroFileMaps() {
 	} catch {
 		return null;
 	}
-	if (!names.length) return null;
+	const uid = process.getuid?.();
+	const files = [];
 	let bytes = 0;
 	for (const n of names) try {
-		bytes += statSync(join(root, n)).size;
+		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: names.map((n) => join(root, n)),
+		files,
 		bytes,
 		prune: "entries",
-		note: `${names.length} file(s), one per project root Metro has served`
+		note: `${files.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 = [] } = {}) {
+function discoverCaches() {
 	const gradle = gradleBuildCache();
 	const gradleDir = gradle ? canonicalCacheDir(gradle.dir) : null;
 	const registered = protectNestedMetroAncestors(suppressLegacyMetroAncestors(registeredCaches().map((c) => Object.assign({}, c, {
@@ -104,8 +84,7 @@ function discoverCaches({ declared = [] } = {}) {
 	const detected = [
 		compilationCache(),
 		gradle,
-		metroFileMaps(),
-		...declaredCaches(declared)
+		metroFileMaps()
 	].filter((c) => Boolean(c)).map((c) => Object.assign({}, c, { source: "detected" }));
 	return mergeCacheDescriptors([...registered, ...detected], gradleDir);
 }
@@ -218,6 +197,7 @@ function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
 	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;
@@ -236,11 +216,14 @@ function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
 			});
 			removed++;
 			bytes += size;
-		} catch {}
+		} catch {
+			failed++;
+		}
 	}
 	return {
 		removed,
 		bytes,
+		failed,
 		skipped: null
 	};
 }
@@ -262,17 +245,8 @@ function entriesAtDepth(dir, depth) {
 	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;
+const DAY_MS$3 = 864e5;
 function cacheSweepIsScoped() {
 	return Boolean(process.env.STIM_HOME);
 }
@@ -289,10 +263,16 @@ function machineGlobalReason(cache) {
 	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) {
@@ -335,7 +315,7 @@ function emptyCache(cache) {
 	};
 	if (cache.prune !== "atomic") return pruneCache(cache, {
 		olderThanDays: 0,
-		now: Date.now() + DAY_MS$1
+		now: Date.now() + DAY_MS$3
 	});
 	let names;
 	try {
@@ -365,6 +345,11 @@ function emptyCache(cache) {
 		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) {
@@ -377,7 +362,8 @@ function trimCaches(caches, olderThan) {
 		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`));
+		} 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.`));
 }
@@ -393,8 +379,8 @@ function emptyCaches(caches) {
 		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`));
+		} 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.`));
 }
@@ -402,7 +388,7 @@ function emptyCaches(caches) {
 //#region src/commands/gc/devices.ts
 const DEVICE_LIST_TIMEOUT_MS = 3e4;
 const AVD_SIZE_TIMEOUT_MS = 5e3;
-const DAY_MS = 864e5;
+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)`;
 }
@@ -472,7 +458,7 @@ function findOrphanedDevices({ sims = [], avds = [], config, isMounted, deadProj
 }
 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 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-")));
@@ -481,7 +467,7 @@ function findStaleProjectDevices({ config, sims = [], avds = [], olderThanDays,
 		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);
+		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({
@@ -1117,6 +1103,262 @@ 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;
+	try {
+		parsed = readJsonFile(join(dir, "workspace.json"));
+	} catch (error) {
+		return {
+			projectRoot: null,
+			problem: error?.code === "ENOENT" ? "it has no workspace.json" : "its workspace.json does not parse"
+		};
+	}
+	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 {
+		projectRoot,
+		problem: null
+	};
+}
+function listWorkspaceDirs() {
+	const root = workspacesRoot();
+	let names;
+	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;
+		}
+		entries.push({
+			dir,
+			...readRecordedRoot(dir, name)
+		});
+	}
+	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 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;
+	} catch (error) {
+		const code = error?.code;
+		return code === "ENOENT" || code === "ENOTDIR" ? false : null;
+	}
+}
+function collectOrphanedWorkspaces(registryKeys, mountedVolumes) {
+	const classified = classifyWorkspaceDirs(listWorkspaceDirs(), {
+		registryKeys,
+		exists: rootPresence,
+		isMounted: (path) => isOnMountedVolume(path, mountedVolumes),
+		inUse: (root) => workspaceInUse(root)
+	});
+	return {
+		orphaned: classified.orphaned.map((entry) => Object.assign({}, entry, { bytes: sizeOf(entry.dir) })),
+		skipped: classified.skipped
+	};
+}
+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
+		};
+	});
+}
+const SIZE_TIMEOUT_MS = 6e4;
+function sizeOf(dir) {
+	return measuredDirectorySize(dir, { timeoutMs: SIZE_TIMEOUT_MS });
+}
+function outputPaths(dir) {
+	return WORKSPACE_OUTPUT_DIRS.map((name) => join(dir, name)).filter((path) => existsSync(path));
+}
+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 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
+		})
+	};
+}
+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;
+		}
+		const kept = run.ran ? run.value : `in use: ${run.reasons.join("; ")}`;
+		if (kept) {
+			console.log(chalk.yellow(`Kept the build outputs of ${root}: ${kept}`));
+			continue;
+		}
+		cleared += entry.bytes ?? 0;
+		console.log(chalk.green(`Cleared the build outputs of ${root} (${sizeText(entry.bytes)})`));
+	}
+	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));
+}
+async function deleteOrphanedWorkspaces(orphaned) {
+	let failures = 0;
+	for (const entry of orphaned) {
+		if (!existsSync(entry.dir)) continue;
+		let run;
+		try {
+			run = await withIdleWorkspace(entry.projectRoot, () => {
+				if (!stillOrphaned(entry)) return false;
+				emptyWorkspaceDir(entry.dir);
+				return true;
+			}, { purpose: "gc" });
+		} 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;
+		}
+		if (!run.value) {
+			console.log(chalk.yellow(`Kept ${entry.dir}: it can no longer be confirmed orphaned.`));
+			continue;
+		}
+		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) {
 	const text = String(key ?? "");
@@ -1162,11 +1404,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 = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
 	stale: [],
 	live: [],
 	unresolved: []
@@ -1182,14 +1424,29 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 	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,6 +1457,8 @@ 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) {
@@ -1207,7 +1466,7 @@ function formatGcReport({ skipped = [], deadProjects = [], orphanedPorts, invali
 		for (const d of orphanedDevices) lines.push(`  ${d.kind} ${d.name} (${d.id})${deviceSizeSuffix(d)}`);
 	}
 	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)`);
@@ -1265,24 +1524,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 +1555,348 @@ 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) 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}:`];
+	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`");
+	}
+	if (removable.length) lines.push("              --delete runs it without --force; use and idleness 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 = [], staleDevices = [], staleDeviceRecords = [], buildLocks = {
+	stale: [],
+	live: [],
+	unresolved: []
+}, buildSlots = {
+	stale: [],
+	live: [],
+	unresolved: []
+}, deviceLeases = {
+	expired: [],
+	kept: []
+}, 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,
+			willRemove: w.skipCode === null,
+			reason: w.skipCode,
+			detail: w.skipped
+		})),
+		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
+		})),
+		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
+		})),
+		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/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) {
@@ -1321,21 +1905,16 @@ 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 caches = planCacheEmptying(sizeCaches(selectCaches(discoverCaches(), scope).filter((c) => !withWorkspaces || !isInsideWorkspaces(c.dir))), all);
 	if (scope) return {
 		skipped: [],
 		deadProjects: [],
 		invalidProjects: [],
+		orphanedWorkspaces: [],
 		orphanedDevices: [],
 		staleDevices: [],
 		staleDeviceRecords: [],
@@ -1363,6 +1942,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
@@ -1404,6 +1988,8 @@ 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 staleDevices = [];
@@ -1491,6 +2077,7 @@ async function collectGcReport({ olderThan = null, cache = null, now = Date.now(
 			port
 		}))),
 		invalidProjects,
+		orphanedWorkspaces: workspaceDirs.orphaned,
 		parkedSims,
 		parkedAvds,
 		orphanedDevices,
@@ -1510,21 +2097,49 @@ async function collectGcReport({ olderThan = null, cache = null, now = Date.now(
 		deviceSweepNotices,
 		easSessionSweep,
 		caches,
+		workspaceOutputs: collectWorkspaceOutputs({
+			olderThan,
+			now,
+			exclude: [...workspaceDirs.orphaned.map((entry) => entry.dir), ...deadProjects.map(workspaceDir)]
+		}),
+		worktreeSweep: worktrees ? collectWorktreeSweep({
+			olderThan,
+			now
+		}) : null,
 		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) {
+		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."));
+		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."
+		};
+	}
+	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,25 +2211,45 @@ 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 payload = (failures) => ({
+		mode: opts.delete ? "delete" : "dry-run",
+		cacheScope: report.cacheScope,
+		olderThan,
+		worktreeSweep: report.worktreeSweep ? {
+			olderThan: report.worktreeSweep.olderThan,
+			defaulted: report.worktreeSweep.defaulted
+		} : 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(null);
 	}
-	let deleteFailures = deleteParkedSims(report.parkedSims, deps) + deleteParkedAvds(report.parkedAvds);
+	let deleteFailures = report.workspaceOutputs ? await clearWorkspaceOutputs(report.workspaceOutputs, { olderThan }) : 0;
+	deleteFailures += deleteParkedSims(report.parkedSims, deps) + deleteParkedAvds(report.parkedAvds);
 	removeInvalidProjectEntries(invalidProjects);
 	for (const path of deadProjects) {
 		if (existsSync(path) || !isOnMountedVolume(path)) {
@@ -1638,7 +2273,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 +2319,26 @@ 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, 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) => {
 		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("--json", "print the report as JSON on stdout; every other line goes to stderr").action(async (opts) => {
 		await runGc(opts);
 	});
 }