stim 1.20.2 → 1.21.0

package/dist/act-DHAw2A2S.mjs

@@ -0,0 +1,2667 @@
+import { n as isTimeoutError, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { g as workspaceStateFile$1, m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
+import { F as isOnMountedVolume, I as listMountedVolumes, K as projectDeviceSlots, N as directorySizeAsync, P as formatBytes, R as measuredDirectorySizeAsync, _ as loadConfig$1, p as getProject } from "./config-CYcBF478.mjs";
+import { o as formatLongDuration, u as plural } from "./command-output-B1UrjZHL.mjs";
+import { r as readWorkspaceState$1, u as workspaceLastUsed } from "./workspace-state-Cjuigeeu.mjs";
+import { E as maintenanceKeepSetting, J as resolveProjectSettingsAsync, Lt as resolveFullRef, Ot as listWorktrees, Rt as resolveFullRefAsync, St as hasPopulatedSubmodulesAsync, Tt as hasUncommittedWorkAsync, Ut as unpushedCommitsAsync, Vt as sourceCheckoutOf, Xt as removeTemporaryEntry, _t as dirtyPathsAsync, kt as listWorktreesAsync, q as resolveProjectSettings, zt as resolveSourceCheckoutAsync } from "./settings-CsJDEXgK.mjs";
+import { i as gitQuietAsync, r as gitQuiet } from "./git-C3iTsJaZ.mjs";
+import { i as findProjectRoot$1 } from "./project-BZNjmW_8.mjs";
+import { a as unregister, n as readManifest } from "./cache-manifest-DkkqguoK.mjs";
+import { A as workspaceBuildInProgress, E as collectOwnedDeviceActivityAsync, St as deleteProjectDevices, T as collectOwnedDeviceActivity, Tt as deviceSweepIsScoped, X as emptyCaches, _r as phase, br as discoverCaches, bt as deleteParkedAvds, ct as deleteGradleVersion, d as trimmableCaches, f as stopOwnedMetro, fr as memorySweepIsScoped, gr as stopIdleGradleDaemons, gt as DEVICE_LIST_TIMEOUT_MS, i as enforceBudget, kt as findStaleProjectDevices, nt as planCacheEmptying, o as machineNumber, pt as waitForGradleExit, r as cacheLabel, sr as collectMemoryReport, st as collectGradleVersions, u as resolveBudget, vt as collectParkedAvds, xr as pruneCache, xt as deleteParkedSims, yt as collectParkedSims } from "./budget-Bs6SxxzO.mjs";
+import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
+import { B as takeGcResults, a as collectWorkspaceOutputs, c as listWorkspaceDirs, f as withIdleWorkspace, i as collectOrphanedWorkspaces, o as deleteOrphanedWorkspaces, p as workspaceInUse, r as clearWorkspaceOutputs, s as isInsideWorkspaces, z as recordGcResult } from "./workspaces-BccMFmGQ.mjs";
+import { N as listBuildLocks, b as leaseIsExpired, g as workspaceActivity, x as listLeaseFiles } from "./activity-BzVfHSrY.mjs";
+import { H as ownedAvdSerialResolver, M as listAvds, U as ownedAvdSerialResolverAsync, gt as readParked, z as ownedAvdDirectory } from "./android-DUYkNF4u.mjs";
+import { d as listAllIosSims, f as listAllIosSimsAsync } from "./ios-CpByZy12.mjs";
+import { s as metroStoreRoot } from "./errors-ccaPc4ox.mjs";
+import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
+import { A as lowestFree, C as measurePressure, D as diskPressureLevel, O as levelFloors, S as measureDisk, a as matchWorktreeEntry, c as reclaimKeys, i as excludeWatchmanCookies, j as protectWindowMs, m as removeWorktreeTarget, o as nestedWorktrees, r as excludePodChurn, s as porcelainPath, w as measurePressureAsync, x as cacheBlocked } from "./worktree-DQ6Zi2Mv.mjs";
+import { c as FETCH_FRESH_MS, d as localDefaultBranchAsync, l as fetchDefaultBranchAsync, o as recordPullRequestLookup, p as mergeStateAsync, u as lastFetchedAtAsync } from "./warm-progress-BHX5r0Ei.mjs";
+import { n as describePullRequest, o as pullRequestLookups, r as endedPullRequest } from "./pull-request-Lfetn8Kr.mjs";
+import { existsSync, lstatSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { buildCacheRoot, configDir, metroCacheRoot } from "@stim-cli/core";
+import { LAST_BUILD_KEYS, MAINTENANCE_LOG_NAME, loadConfig, readBuildHistory, readMaintenanceState, readPullRequestCache, settingDefinition, sharedCompilationCache } from "@stim-cli/core/state";
+import { isAbsolute as isAbsolute$1, join as join$1 } from "path";
+import { readClaimSet } from "@stim-cli/core/ownership-claim";
+import chalk from "chalk";
+import { existsSync as existsSync$1, readdirSync as readdirSync$1, statSync as statSync$1 } from "fs";
+import { lstat, readdir, realpath, rename, stat } from "node:fs/promises";
+//#region src/commands/gc/worktrees.ts
+const DEFAULT_WORKTREE_IDLE_DAYS = 7;
+const DIRTY_PATHS_SHOWN = 3;
+const DAY_MS = 864e5;
+const MINUTE_MS = 6e4;
+const GRACE_SETTING = "gc.worktreeGraceMinutes";
+const NO_OWN_COMMITS_PRESSURE_FLOOR_MS = 5 * MINUTE_MS;
+const PULL_REQUEST_NOT_CHECKED = "not checked since the last maintenance worktree check";
+const WORKTREE_CHECK_SETTING = "maintenance.worktreeCheckMinutes";
+const MERGE_DECIDES = /* @__PURE__ */ new Set([
+	"unpushed",
+	"not-merged",
+	"last-use-unknown",
+	"recently-used"
+]);
+function skip(code, text) {
+	return {
+		code,
+		text
+	};
+}
+function pullRequestNote(lookup) {
+	const pr = lookup && "pullRequest" in lookup ? lookup.pullRequest : null;
+	if (!pr) return null;
+	return pr.containsHead ? describePullRequest(pr) : `${describePullRequest(pr)}, and HEAD has commits it does not`;
+}
+/**
+* Why gc keeps a worktree, or null when it removes it. A worktree that would be removed is still kept while its last
+* activity, or its merge into the default branch, is less than `grace.ms` old, and kept when that activity is unknown.
+* A worktree with no commits of its own beyond the default branch is removable when idle for `olderThan` days, by its
+* last Stim use or, when no Stim use is recorded, its last activity; with `noOwnCommitsIdleMs`, as under disk
+* pressure, once its last activity is that old.
+*/
+function worktreeSkipReason(facts, olderThan, grace = {
+	ms: 0,
+	now: 0
+}, noOwnCommitsIdleMs = null) {
+	return removalBlocker(facts, olderThan, grace.now, noOwnCommitsIdleMs) ?? graceBlocker(facts, grace);
+}
+function noOwnCommitsActivityBlocker(activity, idleMs, now) {
+	if (!activity) return skip("activity-unknown", "its last activity could not be read");
+	const eligibleAt = activity.at + idleMs;
+	if (now >= eligibleAt) return null;
+	const ago = formatLongDuration(Math.max(0, now - activity.at));
+	return {
+		code: "recent-activity",
+		text: `recent activity: ${activity.basis} ${ago} ago; removable after ${new Date(eligibleAt).toISOString()}`,
+		eligibleAt
+	};
+}
+function hasNoOwnCommits(merge) {
+	return merge?.merged === false && merge.noOwnCommits === true;
+}
+function activityIdleDays(activity, now) {
+	return Math.max(0, Math.floor((now - activity.at) / DAY_MS));
+}
+function graceBlocker(facts, grace) {
+	if (grace.ms <= 0) return null;
+	if (!facts.activity) return skip("activity-unknown", "its last activity could not be read");
+	const merged = facts.merge?.merged ? facts.merge : null;
+	const ended = endedPullRequest(facts.pullRequest);
+	const events = [facts.activity];
+	if (merged) events.push({
+		at: merged.mergedAt,
+		basis: `merged into ${merged.into}`
+	});
+	if (ended?.endedAt) events.push({
+		at: ended.endedAt,
+		basis: describePullRequest(ended)
+	});
+	const latest = events.reduce((a, b) => b.at > a.at ? b : a);
+	const eligibleAt = latest.at + grace.ms;
+	if (grace.now >= eligibleAt) return null;
+	const ago = formatLongDuration(Math.max(0, grace.now - latest.at));
+	return {
+		code: "recent-activity",
+		text: `recent activity: ${latest.basis} ${ago} ago; removable after ${new Date(eligibleAt).toISOString()}`,
+		eligibleAt
+	};
+}
+function removalBlocker(facts, olderThan, now, noOwnCommitsIdleMs) {
+	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.nested?.length) return skip("nested-worktree", `contains the worktree ${facts.nested.join(", ")}`);
+	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");
+	const dirty = excludePodChurn(excludeWatchmanCookies(facts.porcelain).lines).lines;
+	if (dirty.length) {
+		const paths = dirty.slice(0, DIRTY_PATHS_SHOWN).flatMap((line) => porcelainPath(line) ?? []);
+		const more = dirty.length > DIRTY_PATHS_SHOWN ? ", ..." : "";
+		return skip("dirty", `dirty: ${plural(dirty.length, "uncommitted or untracked file")} (${paths.join(", ")}${more})`);
+	}
+	if (facts.unpushed === null) return skip("unpushed-unchecked", "unpushed commits could not be checked");
+	const merged = facts.merge?.merged ? facts.merge : null;
+	const ended = endedPullRequest(facts.pullRequest);
+	if (facts.unpushed.length && !merged?.coversUnpushed && ended?.state !== "merged") return skip("unpushed", `unpushed: ${plural(facts.unpushed.length, "commit")} on no remote or other branch`);
+	if (facts.submodules === null) return skip("submodules", "initialized submodules could not be checked");
+	if (facts.submodules) return skip("submodules", "initialized submodules");
+	if (merged || ended) return null;
+	const notMerged = facts.merge && !facts.merge.merged ? facts.merge : null;
+	const details = [notMerged?.detail, pullRequestNote(facts.pullRequest)].filter(Boolean);
+	const noOwnCommits = hasNoOwnCommits(notMerged);
+	if (olderThan === null) {
+		if (noOwnCommits && noOwnCommitsIdleMs !== null) return noOwnCommitsActivityBlocker(facts.activity, noOwnCommitsIdleMs, now);
+		return skip(notMerged?.unknown ? "merge-unknown" : "not-merged", details.join("; ") || "not merged");
+	}
+	const also = details.map((detail) => `; ${detail}`).join("");
+	if (facts.idleDays === null && noOwnCommits && facts.activity) {
+		const days = activityIdleDays(facts.activity, now);
+		if (days < olderThan) return skip("recently-used", `recently active: ${facts.activity.basis} ${days}d ago${also}`);
+		return null;
+	}
+	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`, `PR #12 closed`, `idle 9d`,
+* `no commits of its own beyond origin/main, idle 9d`, or, under disk pressure,
+* `no commits of its own beyond origin/main, inactive for 12m under disk pressure`.
+*/
+function worktreeRemovalReason(candidate, sweep) {
+	const { merge, activity } = candidate;
+	if (merge?.merged) return `merged into ${merge.into}`;
+	const ended = endedPullRequest(candidate.pullRequest);
+	if (ended) return describePullRequest(ended);
+	if (merge && hasNoOwnCommits(merge)) {
+		if (sweep.noOwnCommitsIdleMs !== null && activity) return `${merge.detail}, inactive for ${formatLongDuration(Math.max(0, sweep.now - activity.at))} under disk pressure`;
+		const days = candidate.idleDays ?? (activity ? activityIdleDays(activity, sweep.now) : null);
+		return days === null ? merge.detail : `${merge.detail}, idle ${days}d`;
+	}
+	return `idle ${candidate.idleDays ?? 0}d`;
+}
+/** The pull request note a kept worktree's report line carries, such as `PR #12 merged`, or null. */
+function worktreePullRequestNote(candidate) {
+	return pullRequestNote(candidate.pullRequest);
+}
+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 deviceReads() {
+	let sims;
+	let resolver;
+	return {
+		sims: () => {
+			if (sims === void 0) try {
+				sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+			} catch {
+				sims = null;
+			}
+			return sims;
+		},
+		avdSerial: (avdName) => (resolver ??= ownedAvdSerialResolver({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }))(avdName)
+	};
+}
+async function reportDeviceReads(keys) {
+	const slots = keys.flatMap((key) => {
+		try {
+			return projectDeviceSlots(getProject(key));
+		} catch {
+			return [];
+		}
+	});
+	const requestedSims = new Set(slots.flatMap(({ platforms }) => {
+		const ios = platforms.ios;
+		return ios?.owned && ios.deviceUdid ? [ios.deviceUdid] : [];
+	}));
+	let sims = null;
+	if (requestedSims.size) try {
+		sims = await listAllIosSimsAsync({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+	} catch {}
+	const names = new Set(slots.flatMap(({ platforms }) => {
+		const android = platforms.android;
+		return android?.owned && android.avdName ? [android.avdName] : [];
+	}));
+	const avds = /* @__PURE__ */ new Map();
+	const resolver = ownedAvdSerialResolverAsync({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+	for (const name of names) try {
+		avds.set(name, { value: await resolver(name) });
+	} catch (error) {
+		avds.set(name, { error });
+	}
+	return {
+		sims: (udid) => requestedSims.has(udid) || sims?.some((sim) => sim.udid === udid) ? sims : null,
+		avdSerial: (name) => {
+			const result = avds.get(name);
+			if (!result) throw new Error("The workspace device record changed during inspection.");
+			if ("error" in result) throw result.error;
+			return result.value;
+		}
+	};
+}
+function inUseOf(keys, checks, devices = deviceReads()) {
+	return [.../* @__PURE__ */ new Set([...keys.flatMap((key) => workspaceInUse(key, checks)), ...deviceUseOf(keys, devices)])];
+}
+function deviceUseOf(keys, devices) {
+	const reasons = [];
+	for (const key of keys) {
+		let slots;
+		try {
+			slots = projectDeviceSlots(getProject(key));
+		} catch (error) {
+			reasons.push(`its device records cannot be read: ${error.message}`);
+			continue;
+		}
+		for (const { platforms } of slots) {
+			const ios = platforms.ios;
+			if (ios?.owned && ios.deviceUdid) {
+				const sims = devices.sims(ios.deviceUdid);
+				const sim = sims?.find((entry) => entry.udid === ios.deviceUdid);
+				if (sims === null) reasons.push(`the state of its owned simulator ${ios.deviceUdid} cannot be read`);
+				else if (sim && sim.state !== "Shutdown") reasons.push(`its owned simulator ${sim.name} is ${sim.state}; \`stim stop\` in ${key} shuts it down`);
+			}
+			const android = platforms.android;
+			if (android?.owned && android.avdName) try {
+				if (devices.avdSerial(android.avdName).serial) reasons.push(`its owned emulator ${android.avdName} is running; \`stim stop\` in ${key} shuts it down`);
+			} catch {
+				reasons.push(`the state of its owned emulator ${android.avdName} cannot be read`);
+			}
+		}
+	}
+	const holders = new Set(keys.map(canonicalPath));
+	const now = Date.now();
+	for (const { lease } of listLeaseFiles()) if (lease && !leaseIsExpired(lease, now) && holders.has(canonicalPath(lease.holder))) reasons.push(`it holds the ${lease.platform} device lease on ${lease.deviceName ?? lease.id}`);
+	return reasons;
+}
+function newestMtime(paths) {
+	let newest = null;
+	for (const { path, basis } of paths) {
+		let mtime;
+		try {
+			mtime = statSync$1(path).mtimeMs;
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			return "unreadable";
+		}
+		if (!newest || mtime > newest.at) newest = {
+			at: mtime,
+			basis
+		};
+	}
+	return newest;
+}
+function logFiles$1(key) {
+	const dir = workspaceLogsDir$1(key);
+	try {
+		return readdirSync$1(dir).filter((name) => !name.startsWith(MAINTENANCE_LOG_NAME)).map((name) => ({
+			path: join$1(dir, name),
+			basis: "a Stim log write"
+		}));
+	} catch (error) {
+		return error.code === "ENOENT" ? [] : null;
+	}
+}
+function worktreeActivityOf(path, keys) {
+	const gitDir = gitQuiet(path, [
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-dir"
+	])?.trim();
+	return activityFromGitDir(gitDir, keys);
+}
+async function worktreeActivityOfAsync(path, keys) {
+	const gitDir = (await gitQuietAsync(path, [
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-dir"
+	], { killSignal: "SIGKILL" }))?.trim();
+	return activityFromGitDir(gitDir, keys);
+}
+function activityFromGitDir(gitDir, keys) {
+	if (!gitDir) return null;
+	const paths = [
+		{
+			path: join$1(gitDir, "index"),
+			basis: "a git index write"
+		},
+		{
+			path: join$1(gitDir, "HEAD"),
+			basis: "a git HEAD change"
+		},
+		{
+			path: join$1(gitDir, "logs", "HEAD"),
+			basis: "a git reflog entry"
+		}
+	];
+	for (const key of keys) {
+		const logs = logFiles$1(key);
+		if (logs === null) return null;
+		paths.push({
+			path: workspaceStateFile$1(key),
+			basis: "a Stim workspace state write"
+		}, ...logs);
+	}
+	const newest = newestMtime(paths);
+	return newest === "unreadable" ? null : newest;
+}
+function graceMsSetting(operation) {
+	const { value, error } = machineNumber(GRACE_SETTING, loadConfig$1(), operation?.env ?? process.env);
+	if (error) {
+		const fallback = Number(settingDefinition(GRACE_SETTING)?.default);
+		const line = chalk.yellow(`${error} gc uses the default of ${fallback} minutes.`);
+		const context = operation;
+		if (context) context.output("stderr", `${line}\n`);
+		else console.error(line);
+		return fallback * MINUTE_MS;
+	}
+	return (value ?? 0) * MINUTE_MS;
+}
+async function unlessTimedOut(read, unknown) {
+	try {
+		return await read();
+	} catch (error) {
+		if (isTimeoutError(error)) return unknown;
+		throw error;
+	}
+}
+async function porcelainOf(path, gitAnswered) {
+	if (gitAnswered === null) return null;
+	if (!gitAnswered) return [];
+	const lines = await unlessTimedOut(() => dirtyPathsAsync(path, { limit: Infinity }), null);
+	return lines?.length ? lines : null;
+}
+function candidateRoots() {
+	const registered = Object.keys(loadConfig$1()?.projects ?? {}).filter(isAbsolute$1);
+	const recorded = listWorkspaceDirs().flatMap((entry) => entry.projectRoot ? [entry.projectRoot] : []);
+	return [.../* @__PURE__ */ new Set([
+		...registered,
+		...recorded,
+		...linkedWorktreesOf(registered)
+	])].filter((root) => existsSync$1(root)).toSorted();
+}
+async function candidateRootsAsync() {
+	const registered = Object.keys(loadConfig$1()?.projects ?? {}).filter(isAbsolute$1);
+	const recorded = listWorkspaceDirs().flatMap((entry) => entry.projectRoot ? [entry.projectRoot] : []);
+	const linked = /* @__PURE__ */ new Set();
+	for (const root of registered) {
+		if (!existsSync$1(root)) continue;
+		const { entries, ...source } = await resolveSourceCheckoutAsync(root);
+		if ("refusal" in source) continue;
+		for (const entry of entries) if (!entry.bare && !entry.prunable && entry.path !== source.path) linked.add(entry.path);
+	}
+	return [.../* @__PURE__ */ new Set([
+		...registered,
+		...recorded,
+		...linked
+	])].filter((root) => existsSync$1(root)).toSorted();
+}
+function linkedWorktreesOf(roots) {
+	const linked = /* @__PURE__ */ new Set();
+	for (const root of roots) {
+		if (!existsSync$1(root)) continue;
+		const entries = listWorktrees(root);
+		const source = sourceCheckoutOf(entries);
+		if ("refusal" in source) continue;
+		for (const entry of entries) if (!entry.bare && !entry.prunable && entry.path !== source.path) linked.add(entry.path);
+	}
+	return [...linked];
+}
+async function staleFetch(repo, now, freshMs) {
+	const at = await lastFetchedAtAsync(repo);
+	if (at !== null && now - at < freshMs) return null;
+	return at === null ? "the repository has no recorded fetch" : `the repository was last fetched ${formatLongDuration(Math.max(0, now - at))} ago`;
+}
+/**
+* How old a fetch or a cached pull request lookup can be and still count as fresh in a report: twice the maintenance
+* worktree check interval, which refreshes both, and never less than 10 minutes.
+*/
+function reportFreshMs(operation) {
+	const minutes = machineNumber(WORKTREE_CHECK_SETTING, loadConfig$1(), operation?.env ?? process.env).value ?? Number(settingDefinition(WORKTREE_CHECK_SETTING)?.default);
+	return Math.max(FETCH_FRESH_MS, 2 * minutes * MINUTE_MS);
+}
+function notRefreshedNote(fetch, facts) {
+	const lookup = facts.pullRequest;
+	const stale = [fetch, lookup && "unavailable" in lookup && lookup.unavailable === PULL_REQUEST_NOT_CHECKED ? "its pull request was not checked" : null].filter(Boolean);
+	return stale.length ? `merge state not refreshed: ${stale.join(", ")}; the next maintenance worktree check, which a stim command starts when it is due, or \`stim gc --delete\` checks again` : null;
+}
+async function checkMergeStates(pending, idle, grace, noOwnCommitsIdleMs, refresh, freshMs) {
+	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 = refresh ? await fetchDefaultBranchAsync(repo, grace.now) : await localDefaultBranchAsync(repo);
+		const fetch = refresh ? null : await staleFetch(repo, grace.now, freshMs);
+		for (const { candidate, facts } of entries) {
+			const merge = "error" in target ? {
+				merged: false,
+				unknown: true,
+				detail: `merge state unknown: ${target.error}`
+			} : await mergeStateAsync(candidate.path, target);
+			const verdict = worktreeSkipReason({
+				...facts,
+				merge
+			}, idle, grace, noOwnCommitsIdleMs);
+			const note = !refresh && verdict && MERGE_DECIDES.has(verdict.code) ? notRefreshedNote(hasNoOwnCommits(merge) ? null : fetch, facts) : null;
+			Object.assign(candidate, {
+				merge,
+				skipCode: note && verdict?.code === "not-merged" ? "merge-unknown" : verdict?.code ?? null,
+				skipped: verdict ? note ? `${verdict.text}; ${note}` : verdict.text : null,
+				eligibleAt: verdict?.eligibleAt ?? null
+			});
+		}
+	}
+}
+/**
+* Classifies each linked worktree of a registered project or its repository. A merged one is removable; with `idle`, so is one unused for
+* `olderThan` days; with `removesNoOwnCommits`, so is one with no commits of its own beyond the default branch whose
+* last activity is older than the grace period, and never younger than 5 minutes. Device use is read last, in one pass against one simulator list and one AVD resolver, so
+* the resolver's time budget covers only device reads. Pull requests are asked once per repository, all
+* repositories at once. Merge state is checked only where it decides the verdict, after one fetch per repository.
+* Without `refresh`, it runs no fetch and no `gh`: merge state comes from the existing remote-tracking ref and pull
+* requests from the cache `status --watch` writes, and a kept verdict that fresher state could change says so.
+*/
+async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOwnCommits = false, refresh = true, operation }) {
+	const days = idle ? olderThan ?? DEFAULT_WORKTREE_IDLE_DAYS : null;
+	const grace = {
+		ms: graceMs ?? graceMsSetting(operation),
+		now
+	};
+	const freshMs = refresh ? 0 : reportFreshMs(operation);
+	const noOwnCommitsIdleMs = removesNoOwnCommits ? Math.max(grace.ms, NO_OWN_COMMITS_PRESSURE_FLOOR_MS) : null;
+	const groups = /* @__PURE__ */ new Map();
+	const outside = [];
+	const candidates = await candidateRootsAsync();
+	if (candidates.length) phase("worktrees", `checking ${plural(candidates.length, "project")} for merged or idle worktrees`, operation);
+	for (const root of candidates) {
+		const entry = matchWorktreeEntry(await listWorktreesAsync(root), root);
+		if (!entry) {
+			outside.push({
+				path: root,
+				keys: [root],
+				idleDays: null,
+				merge: null,
+				head: null,
+				pullRequest: null,
+				skipCode: "not-a-worktree",
+				skipped: "not inside a git worktree",
+				eligibleAt: null,
+				activity: null
+			});
+			continue;
+		}
+		groups.set(entry.path, [...groups.get(entry.path) ?? [], root]);
+	}
+	const inspected = [];
+	for (const [path, roots] of groups) {
+		const { entries, ...source } = await resolveSourceCheckoutAsync(path);
+		const entry = matchWorktreeEntry(entries, path);
+		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 activity = linked && (grace.ms > 0 || days !== null || removesNoOwnCommits) ? await worktreeActivityOfAsync(path, keys) : null;
+		const gitAnswered = linked ? await unlessTimedOut(() => hasUncommittedWorkAsync(path), null) : null;
+		const head = linked ? await resolveFullRefAsync(path, "HEAD") : null;
+		const facts = {
+			source: "refusal" in source ? source : linked ? "linked" : "source",
+			bare: Boolean(entry?.bare),
+			locked: Boolean(entry?.locked),
+			nested: entry ? nestedWorktrees(entries, entry.path) : [],
+			porcelain: await porcelainOf(path, gitAnswered),
+			unpushed: linked ? await unlessTimedOut(() => unpushedCommitsAsync(path), null) : null,
+			submodules: linked ? await unlessTimedOut(() => hasPopulatedSubmodulesAsync(path), null) : false,
+			inUse: [],
+			idleDays,
+			merge: null,
+			pullRequest: null,
+			activity
+		};
+		inspected.push({
+			candidate: {
+				path,
+				keys,
+				idleDays,
+				merge: null,
+				head,
+				pullRequest: null,
+				skipCode: null,
+				skipped: null,
+				eligibleAt: null,
+				activity
+			},
+			facts,
+			repo: "refusal" in source ? null : source.path,
+			branch: head && entry?.branch ? entry.branch : null
+		});
+	}
+	const linked = inspected.filter(({ facts }) => facts.source === "linked");
+	for (const { candidate, facts } of linked) facts.inUse = candidate.keys.flatMap((key) => workspaceInUse(key, { managedLocks: true }));
+	const devices = await reportDeviceReads(linked.flatMap(({ candidate }) => candidate.keys));
+	for (const { candidate, facts } of linked) facts.inUse = [.../* @__PURE__ */ new Set([...facts.inUse, ...deviceUseOf(candidate.keys, devices)])];
+	if (refresh) await lookUpPullRequests(inspected);
+	else readCachedPullRequests(inspected, now, freshMs);
+	const worktrees = [];
+	const pending = [];
+	for (const { candidate, facts, repo } of inspected) {
+		const verdict = worktreeSkipReason(facts, days, grace, noOwnCommitsIdleMs);
+		Object.assign(candidate, {
+			pullRequest: facts.pullRequest,
+			skipCode: verdict?.code ?? null,
+			skipped: verdict?.text ?? null,
+			eligibleAt: verdict?.eligibleAt ?? null
+		});
+		if (verdict && MERGE_DECIDES.has(verdict.code) && repo !== null) pending.push({
+			candidate,
+			facts,
+			repo
+		});
+		worktrees.push(candidate);
+	}
+	await checkMergeStates(pending, days, grace, noOwnCommitsIdleMs, refresh, freshMs);
+	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
+		},
+		graceMs: grace.ms,
+		now,
+		noOwnCommitsIdleMs,
+		worktrees: listed
+	};
+}
+async function lookUpPullRequests(inspected) {
+	const repos = /* @__PURE__ */ new Map();
+	for (const { candidate, facts, repo, branch } of inspected) {
+		if (repo === null || branch === null || candidate.head === null) continue;
+		const query = {
+			cwd: candidate.path,
+			branch,
+			head: candidate.head
+		};
+		repos.set(repo, [...repos.get(repo) ?? [], {
+			facts,
+			query
+		}]);
+	}
+	const lookup = pullRequestLookups();
+	await Promise.all([...repos].map(async ([repo, entries]) => {
+		const answers = await lookup(repo, entries.map(({ query }) => query));
+		const at = (/* @__PURE__ */ new Date()).toISOString();
+		entries.forEach(({ facts, query }, i) => {
+			const answer = answers[i] ?? null;
+			facts.pullRequest = answer;
+			if (answer && "pullRequest" in answer) recordPullRequestLookup({
+				path: query.cwd,
+				branch: query.branch,
+				head: query.head
+			}, answer.pullRequest, at);
+		});
+	}));
+}
+function readCachedPullRequests(inspected, now, freshMs) {
+	let gh;
+	for (const { candidate, facts, repo, branch } of inspected) {
+		if (repo === null || branch === null || candidate.head === null) continue;
+		const cached = cachedPullRequest(readPullRequestCache(candidate.path), branch, candidate.head, now, freshMs);
+		if (!("pullRequest" in cached)) gh ??= getExecutor().findExecutable("gh") !== null;
+		facts.pullRequest = "pullRequest" in cached || gh ? cached : { unavailable: "gh is not installed" };
+	}
+}
+function cachedPullRequest(cached, branch, head, now, freshMs) {
+	const notChecked = { unavailable: PULL_REQUEST_NOT_CHECKED };
+	if (!cached || cached.branch !== branch || cached.head !== head) return notChecked;
+	if (!(now - Date.parse(cached.checkedAt) < freshMs)) return notChecked;
+	const { pullRequest: pr, containsHead, endedAt } = cached;
+	if (pr === null) return { pullRequest: null };
+	if (containsHead === void 0 || pr.state !== "open" && pr.state !== "draft" && typeof endedAt !== "number") return notChecked;
+	const state = pr.state === "draft" ? "open" : pr.state;
+	const open = state === "open";
+	return { pullRequest: {
+		number: pr.number,
+		url: pr.url,
+		head,
+		containsHead,
+		state,
+		draft: pr.state === "draft",
+		endedAt: open ? null : endedAt ?? null
+	} };
+}
+function noOwnCommitsRecheck(sweep, path, keys, now) {
+	if (!sweep.idle) {
+		if (sweep.noOwnCommitsIdleMs === null) return "it has no commits of its own and is not idle";
+		return noOwnCommitsActivityBlocker(worktreeActivityOf(path, keys), sweep.noOwnCommitsIdleMs, now)?.text ?? null;
+	}
+	const idleDays = idleDaysOf(keys, now);
+	if (idleDays !== null) return idleDays < sweep.idle.olderThan ? `used ${idleDays}d ago since gc checked it` : null;
+	const activity = worktreeActivityOf(path, keys);
+	if (!activity) return "its last activity could not be read";
+	const days = activityIdleDays(activity, now);
+	return days < sweep.idle.olderThan ? `active ${days}d ago since gc checked it: ${activity.basis}` : null;
+}
+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 mergedHead = candidate.merge?.merged ? candidate.merge.head : endedPullRequest(candidate.pullRequest) ? candidate.head : null;
+			if (mergedHead) {
+				if (resolveFullRef(candidate.path, "HEAD") !== mergedHead) reasons.push("its HEAD moved since gc checked it");
+			} else if (hasNoOwnCommits(candidate.merge)) {
+				if (resolveFullRef(candidate.path, "HEAD") !== candidate.head) reasons.push("its HEAD moved since gc checked it");
+				const recent = noOwnCommitsRecheck(sweep, candidate.path, keys, Date.now());
+				if (recent) reasons.push(recent);
+			} 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`);
+			}
+			if (sweep.graceMs > 0) {
+				const recent = graceBlocker({
+					merge: candidate.merge,
+					pullRequest: candidate.pullRequest,
+					activity: worktreeActivityOf(candidate.path, keys)
+				}, {
+					ms: sweep.graceMs,
+					now: Date.now()
+				});
+				if (recent) reasons.push(recent.text);
+			}
+			kept = reasons;
+			return reasons;
+		};
+		let removed = false;
+		let error = null;
+		try {
+			const ended = endedPullRequest(candidate.pullRequest);
+			const mergedHead = candidate.merge?.merged && candidate.merge.coversUnpushed ? candidate.merge.head : ended?.state === "merged" ? candidate.head ?? void 0 : void 0;
+			const expectedHead = candidate.merge?.merged || ended || hasNoOwnCommits(candidate.merge) ? candidate.head ?? void 0 : void 0;
+			removed = await removeWorktreeTarget(candidate.path, {
+				linkedOnly: true,
+				guard,
+				mergedHead,
+				expectedHead
+			});
+		} catch (thrown) {
+			error = thrown?.message || String(thrown);
+			console.error(chalk.red(`Could not remove ${candidate.path}: ${error}`));
+		}
+		if (removed) {
+			console.log(chalk.green(`Removed the worktree ${candidate.path} (${worktreeRemovalReason(candidate, sweep)})`));
+			recordGcResult("worktree", "done", candidate.path, { detail: worktreeRemovalReason(candidate, sweep) });
+		} else if (kept.length) {
+			console.log(chalk.yellow(`Kept the worktree ${candidate.path}: ${kept.join("; ")}`));
+			recordGcResult("worktree", "kept", candidate.path, { detail: kept.join("; ") });
+		} else {
+			failures++;
+			console.error(chalk.yellow(`Kept the worktree ${candidate.path}; see the lines above for why.`));
+			recordGcResult("worktree", "failed", candidate.path, { detail: error ?? "stim worktree remove did not remove it; see the details" });
+		}
+	}
+	return failures;
+}
+//#endregion
+//#region src/maintenance/plan.ts
+function plan({ pressure, sizes, settings, budget, diskSteps = [], protectedRoot, scoped = false, projects = [], pinned = () => false, recentlyUsed = () => null }) {
+	const actions = [];
+	const blocked = [];
+	const skips = [];
+	const add = (action) => {
+		if (action.kind === "would-clear-outputs" && action.workspace && pinned(action.workspace)) {
+			skips.push({
+				target: action.workspace,
+				reason: "pinned by maintenance.keep",
+				workspace: action.workspace
+			});
+			return false;
+		}
+		const recent = action.kind === "would-clear-outputs" && action.workspace ? recentlyUsed(action.workspace) : null;
+		if (recent) {
+			skips.push({
+				target: action.workspace,
+				reason: recent,
+				workspace: action.workspace
+			});
+			return false;
+		}
+		if (actions.some((entry) => entry.kind === action.kind && entry.target === action.target)) return false;
+		actions.push(action);
+		return true;
+	};
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	const emergency = pressure?.disk.some((disk) => disk.freeMb < budget.hardFloorDiskMb) ?? false;
+	const low = pressure?.disk.filter((disk) => disk.freeMb < floor) ?? [];
+	const reason = low.map((disk) => `free disk ${(disk.freeMb / 1024).toFixed(1)}G on ${disk.volume} under the ${(floor / 1024).toFixed(1)}G floor`).join("; ");
+	const kinds = {
+		"idle-devices": "would-shutdown-device",
+		"idle-dev-servers": "would-stop-workspace",
+		"workspace-outputs": "would-clear-outputs",
+		"stale-cache-entries": "would-trim-cache"
+	};
+	if (low.length) {
+		for (const step of diskSteps) {
+			if (scoped && step.step === "idle-devices") continue;
+			for (const target of step.targets) {
+				const workspace = projects.find((root) => root === target || target.endsWith(` in ${root}`)) ?? (step.step === "idle-dev-servers" || step.step === "workspace-outputs" ? target : void 0);
+				if (workspace === protectedRoot || target === protectedRoot) continue;
+				const size = workspace && step.step !== "idle-devices" ? sizes.find((entry) => entry.workspace === workspace && entry.category === "workspace-outputs") : void 0;
+				add({
+					kind: kinds[step.step],
+					target,
+					bytes: step.step === "workspace-outputs" ? size?.bytes ?? 0 : 0,
+					reason: `${size?.idleDays == null ? "" : `idle ${size.idleDays} days, `}${reason}`,
+					...workspace ? { workspace } : {},
+					check: "disk",
+					...step.step === "stale-cache-entries" ? { olderThanDays: 14 } : {}
+				});
+			}
+			if (step.failures) blocked.push(`Could not plan ${step.step}: ${step.failures} failures`);
+		}
+		if (actions.length === 0) blocked.push(`${reason}; no reclaimable disk targets`);
+	}
+	const caps = [
+		[
+			"workspace-outputs",
+			settings.workspaceOutputsMaxGb,
+			"would-clear-outputs"
+		],
+		[
+			"build-cache",
+			settings.buildCacheMaxGb,
+			"would-trim-cache"
+		],
+		[
+			"metro-cache",
+			settings.metroCacheMaxGb,
+			"would-trim-cache"
+		],
+		[
+			"compilation-cache",
+			settings.swiftCompilationCacheMaxGb,
+			"would-empty-cache"
+		]
+	];
+	for (const [category, capGb, kind] of caps) {
+		const entries = sizes.filter((size) => size.category === category);
+		const total = entries.reduce((sum, size) => sum + size.bytes, 0);
+		const cap = capGb * 1024 ** 3;
+		if (cap === 0 || total <= cap) continue;
+		let remaining = total;
+		const targetBytes = cap * settings.capTargetPercent / 100;
+		const why = `${category} ${(total / 1024 ** 3).toFixed(1)}G over the ${capGb}G cap; target ${(targetBytes / 1024 ** 3).toFixed(1)}G`;
+		if (category === "compilation-cache" && !emergency) {
+			skips.push({
+				target: entries[0]?.dir ?? category,
+				reason: `${why}; it can only be emptied whole, which runs only below the ${(budget.hardFloorDiskMb / 1024).toFixed(1)}G hard floor`
+			});
+			continue;
+		}
+		for (const size of entries.toSorted((a, b) => (b.idleDays ?? 0) - (a.idleDays ?? 0))) {
+			if (remaining <= targetBytes) break;
+			const kept = size.workspace === protectedRoot ? "the triggering workspace is protected" : size.blocked;
+			if (kept) {
+				skips.push({
+					target: size.dir,
+					reason: kept,
+					...size.workspace ? { workspace: size.workspace } : {}
+				});
+				continue;
+			}
+			const bytes = kind === "would-trim-cache" ? Math.round(Math.min(size.bytes, remaining - targetBytes)) : size.bytes;
+			if (!add({
+				kind,
+				target: size.workspace ?? size.dir,
+				bytes,
+				reason: `${!size.workspace || size.idleDays == null ? "" : `idle ${size.idleDays} days, `}${why}`,
+				...size.workspace ? { workspace: size.workspace } : {},
+				...kind === "would-clear-outputs" ? {} : { dir: size.dir }
+			})) continue;
+			remaining -= bytes;
+		}
+		if (remaining > targetBytes) blocked.push(`${why}; eligible targets cannot reach the target`);
+	}
+	if (pressure?.memory.pressured) skips.push({
+		target: "memory",
+		reason: "memory pressure observed; automatic maintenance does not stop helpers or idle workspaces yet"
+	});
+	return {
+		actions,
+		blocked,
+		skips
+	};
+}
+//#endregion
+//#region src/maintenance/protect.ts
+const BUILD_RECORDS = ["lastBuild", ...Object.values(LAST_BUILD_KEYS)];
+function recordKeys(record) {
+	if (record === null || typeof record !== "object") return [];
+	const value = record;
+	return [value.cacheKey, value.missReason?.baseline?.cacheKey].filter((key) => typeof key === "string");
+}
+function protectedCacheKeys(config = loadConfig$1()) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const root of Object.keys(config?.projects ?? {})) {
+		const state = readWorkspaceState$1(root);
+		for (const name of BUILD_RECORDS) for (const key of recordKeys(state?.[name])) keys.add(key);
+		for (const entries of Object.values(readBuildHistory(state))) {
+			const key = entries.find((entry) => entry.result === "succeeded")?.cacheKey;
+			if (key) keys.add(key);
+		}
+	}
+	for (const platform of ["ios", "android"]) for (const record of readParked(platform, { config })) if (record.cacheKey) keys.add(record.cacheKey);
+	for (const lock of listBuildLocks()) if ((lock.alive || lock.unresolved) && lock.key) keys.add(lock.key);
+	return keys;
+}
+function liveMetroStores(config = loadConfig$1()) {
+	return Object.keys(config?.projects ?? {}).filter((root) => workspaceInUse(root, {
+		managedLocks: false,
+		hosted: false,
+		nativeRun: false
+	}).length > 0).map((root) => canonicalPath(metroStoreRoot(root)));
+}
+function cacheEntryProtection(config = loadConfig$1()) {
+	try {
+		const keys = protectedCacheKeys(config);
+		const stores = liveMetroStores(config);
+		return (entry) => {
+			if (keys.has(basename(entry))) return "a project, parked device or running build still uses this build";
+			const path = canonicalPath(entry);
+			if (stores.some((store) => path === store || path.startsWith(`${store}${sep}`))) return "its project has a running or unverifiable dev server";
+			return null;
+		};
+	} catch (error) {
+		const reason = `cache protection could not be read: ${error instanceof Error ? error.message : String(error)}`;
+		return () => reason;
+	}
+}
+function maintenancePinned(root) {
+	try {
+		return maintenanceKeepSetting(resolveProjectSettings(root).settings);
+	} catch {
+		return true;
+	}
+}
+async function maintenancePinnedAsync(root, operation) {
+	try {
+		return maintenanceKeepSetting((await resolveProjectSettingsAsync(root, {
+			env: operation.env,
+			signal: operation.signal
+		})).settings);
+	} catch {
+		operation.signal.throwIfAborted();
+		return true;
+	}
+}
+function recentUse(workspace, settings, windowMs = settings.protectRecentHours * 36e5) {
+	const since = Date.now() - workspaceLastUsed(workspace);
+	if (!Number.isFinite(since) || since >= windowMs) return null;
+	return windowMs < 36e5 ? `used within the last ${Math.round(windowMs / 6e4)} minutes` : `used within the last ${windowMs / 36e5} hours`;
+}
+//#endregion
+//#region src/maintenance/activity.ts
+function readDeviceActivity(withSims, now) {
+	const sims = withSims ? listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }) : [];
+	return collectOwnedDeviceActivity(loadConfig$1(), sims, now);
+}
+/** A reader that reads device activity at most once per kind and reuses the answer, including a failure. */
+function cachedDeviceActivity(now) {
+	const answers = /* @__PURE__ */ new Map();
+	return (withSims) => {
+		let answer = answers.get(withSims);
+		if (!answer) {
+			try {
+				answer = { devices: readDeviceActivity(withSims, now) };
+			} catch (error) {
+				answer = { error };
+			}
+			answers.set(withSims, answer);
+		}
+		if ("error" in answer) throw answer.error;
+		return answer.devices;
+	};
+}
+function cachedDeviceActivityAsync(now, env) {
+	const answers = /* @__PURE__ */ new Map();
+	return (withSims) => {
+		let answer = answers.get(withSims);
+		if (!answer) {
+			answer = (async () => {
+				const sims = withSims ? await listAllIosSimsAsync({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }) : [];
+				return collectOwnedDeviceActivityAsync(loadConfig$1(), sims, now, env);
+			})();
+			answers.set(withSims, answer);
+		}
+		return answer;
+	};
+}
+function* workspaceActiveChecks(root, now, windowMs) {
+	if (workspaceBuildInProgress(root)) return "a build is in progress";
+	const holder = canonicalPath(root);
+	for (const { lease } of listLeaseFiles()) if (lease && !leaseIsExpired(lease, now) && canonicalPath(lease.holder) === holder) return `it holds the ${lease.platform} device lease on ${lease.deviceName ?? lease.id}`;
+	const owned = ownedPlatforms(root);
+	if (owned.ios || owned.android) {
+		let devices;
+		try {
+			devices = yield owned.ios;
+		} catch {
+			return "its owned devices cannot be listed to prove them idle";
+		}
+		const busy = devices.find((device) => device.project === root && device.activity.state !== "idle");
+		if (busy) return `its owned ${busy.kind} device ${busy.name} is ${busy.activity.state}`;
+	}
+	const activity = workspaceActivity(root, now);
+	if (activity.state !== "idle") return `its activity is ${activity.state}`;
+	const known = [Date.parse(activity.lastActivityAt ?? ""), workspaceLastUsed(root)].filter(Number.isFinite);
+	if (!known.length) return "its last activity is unknown";
+	return now - Math.max(...known) < windowMs ? usedWithin(windowMs) : null;
+}
+/** Why a workspace is not inactive for the pressure window, or null when maintenance may stop it. */
+function workspaceActiveReason(root, now, windowMs, devices = (withSims) => readDeviceActivity(withSims, now)) {
+	const checks = workspaceActiveChecks(root, now, windowMs);
+	let step = checks.next();
+	while (!step.done) try {
+		step = checks.next(devices(step.value));
+	} catch (error) {
+		step = checks.throw(error);
+	}
+	return step.value;
+}
+async function workspaceActiveReasonAsync(root, now, windowMs, devices) {
+	const checks = workspaceActiveChecks(root, now, windowMs);
+	let step = checks.next();
+	while (!step.done) try {
+		step = checks.next(await devices(step.value));
+	} catch (error) {
+		step = checks.throw(error);
+	}
+	return step.value;
+}
+function ownedPlatforms(root) {
+	try {
+		const slots = projectDeviceSlots(loadConfig$1()?.projects?.[root]);
+		return {
+			ios: slots.some(({ platforms }) => platforms.ios?.owned === true),
+			android: slots.some(({ platforms }) => platforms.android?.owned === true)
+		};
+	} catch {
+		return {
+			ios: true,
+			android: true
+		};
+	}
+}
+function hasOwnedDevices(root) {
+	try {
+		return projectDeviceSlots(loadConfig$1()?.projects?.[root]).some(({ platforms }) => platforms.ios?.owned === true || platforms.android?.owned === true);
+	} catch {
+		return false;
+	}
+}
+function usedWithin(windowMs) {
+	return `used within the last ${Math.round(windowMs / 6e4)} minutes`;
+}
+//#endregion
+//#region src/maintenance/devices.ts
+const AVD_SIZE_TIMEOUT_MS = 3e4;
+/** The disk of each owned simulator or emulator of a registered workspace and of each parked device. */
+async function ownedDeviceUsage(failure, { sims = () => listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }), avds = () => listAvds({ timeoutMs: DEVICE_LIST_TIMEOUT_MS }), avdDirectory = ownedAvdDirectory, size = (dir) => measuredDirectorySizeAsync(dir, { timeoutMs: AVD_SIZE_TIMEOUT_MS }) } = {}) {
+	const config = loadConfig$1();
+	const owned = [];
+	for (const [root, project] of Object.entries(config?.projects ?? {})) for (const { platforms } of projectDeviceSlots(project)) {
+		if (platforms.ios?.owned && platforms.ios.deviceUdid) owned.push({
+			kind: "ios",
+			id: platforms.ios.deviceUdid,
+			workspace: canonicalPath(root)
+		});
+		if (platforms.android?.owned && platforms.android.avdName) owned.push({
+			kind: "android",
+			id: platforms.android.avdName,
+			workspace: canonicalPath(root)
+		});
+	}
+	for (const record of readParked("ios", { config })) owned.push({
+		kind: "ios",
+		id: record.udid
+	});
+	for (const record of readParked("android", { config })) owned.push({
+		kind: "android",
+		id: record.name
+	});
+	const listed = (read, label) => {
+		if (!owned.length) return [];
+		try {
+			return read();
+		} catch {
+			failure(label);
+			return null;
+		}
+	};
+	const iosRecords = owned.some((device) => device.kind === "ios") ? listed(sims, "the simulator list") : [];
+	const avdNames = owned.some((device) => device.kind === "android") ? listed(avds, "the emulator list") : [];
+	const usage = [];
+	for (const device of owned) {
+		const workspace = device.workspace ? { workspace: device.workspace } : {};
+		if (device.kind === "ios") {
+			const sim = iosRecords?.find((record) => record.udid === device.id);
+			if (sim && typeof sim.dataPathSize === "number") usage.push({
+				kind: "ios",
+				name: sim.name,
+				dir: sim.dataPath ?? device.id,
+				bytes: sim.dataPathSize,
+				...workspace
+			});
+			continue;
+		}
+		const dir = avdNames?.includes(device.id) ? avdDirectory(device.id) : null;
+		if (!dir) continue;
+		const bytes = await size(dir);
+		if (bytes === null) failure(dir, device.workspace);
+		else usage.push({
+			kind: "android",
+			name: device.id,
+			dir,
+			bytes,
+			...workspace
+		});
+	}
+	return usage;
+}
+async function measureOwnedDevices(now, failure) {
+	return (await ownedDeviceUsage(failure)).map(({ kind, name, dir, bytes, workspace }) => {
+		const size = {
+			name: `${workspace ? "owned" : "parked"} ${kind === "ios" ? "simulator" : "emulator"} ${name}`,
+			category: "owned-devices",
+			dir,
+			bytes,
+			measuredAt: now
+		};
+		if (workspace) size.workspace = workspace;
+		return size;
+	});
+}
+function* deviceDeletionChecks({ roots, windowMs, reason, protectedRoot, pinned, sizes, now, extra, env = process.env }) {
+	const plan = {
+		actions: [],
+		blocked: [],
+		skips: []
+	};
+	if (deviceSweepIsScoped(env)) return plan;
+	for (const entry of roots) {
+		const root = canonicalPath(entry.root);
+		if (root === protectedRoot || !hasOwnedDevices(root)) continue;
+		const kept = pinned(root) ? "pinned by maintenance.keep" : now - workspaceLastUsed(root) < windowMs ? usedWithin(windowMs) : workspaceInUse(root).map((why) => `in use: ${why}`)[0] ?? (yield root);
+		if (kept) {
+			plan.skips.push({
+				target: root,
+				reason: kept,
+				workspace: root
+			});
+			continue;
+		}
+		plan.actions.push({
+			kind: "would-delete-devices",
+			target: root,
+			workspace: root,
+			bytes: sizes.filter((size) => size.category === "owned-devices" && size.workspace === root).reduce((sum, size) => sum + size.bytes, 0),
+			reason: entry.reason ? `${entry.reason}, ${reason}` : reason,
+			...extra
+		});
+	}
+	return plan;
+}
+function planDeviceDeletion(options) {
+	const activity = cachedDeviceActivity(options.now);
+	const checks = deviceDeletionChecks(options);
+	let step = checks.next();
+	while (!step.done) step = checks.next(workspaceActiveReason(step.value, options.now, options.windowMs, activity));
+	return step.value;
+}
+async function planDeviceDeletionAsync(options, signal) {
+	const activity = cachedDeviceActivityAsync(options.now, options.env ?? process.env);
+	const checks = deviceDeletionChecks(options);
+	let step = checks.next();
+	while (!step.done) {
+		signal.throwIfAborted();
+		step = checks.next(await workspaceActiveReasonAsync(step.value, options.now, options.windowMs, activity));
+	}
+	return step.value;
+}
+/**
+* The workspaces of linked worktrees that gc keeps although their branch is merged or their pull request ended,
+* such as a dirty one. A worktree gc removes takes its devices with it.
+*/
+function finishedWorkspaces(sweep, now) {
+	const kept = /* @__PURE__ */ new Set([
+		"not-a-worktree",
+		"bare-repository",
+		"source-checkout",
+		"source-checkout-unknown",
+		"locked",
+		"nested-worktree",
+		"recent-activity",
+		"activity-unknown"
+	]);
+	if (!sweep) return [];
+	return sweep.worktrees.flatMap((worktree) => {
+		if (worktree.skipped === null || kept.has(worktree.skipCode ?? "")) return [];
+		const merged = worktree.merge?.merged ? worktree.merge.mergedAt : null;
+		const ended = endedPullRequest(worktree.pullRequest);
+		if (merged === null && !ended) return [];
+		if (now - Math.max(merged ?? -Infinity, ended ? ended.endedAt ?? now : -Infinity) < sweep.graceMs) return [];
+		const reason = `its worktree is finished (${worktreeRemovalReason(worktree, sweep)}) but kept`;
+		return worktree.keys.map((root) => ({
+			root: canonicalPath(root),
+			reason
+		}));
+	});
+}
+//#endregion
+//#region src/maintenance/sweep.ts
+async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices = true, operation }) {
+	const actions = [];
+	const skips = [];
+	const blocked = [];
+	const days = settings.olderThanDays;
+	for (const entry of collectWorkspaceOutputs({
+		olderThan: days,
+		now,
+		measure: false
+	}).workspaces) {
+		const root = entry.projectRoot === null ? null : canonicalPath(entry.projectRoot);
+		if (root === null || !entry.willClear || root === protectedRoot) continue;
+		if (pinned(root)) {
+			skips.push({
+				target: root,
+				reason: "pinned by maintenance.keep",
+				workspace: root
+			});
+			continue;
+		}
+		const size = sizes.find((candidate) => candidate.workspace === root && candidate.category === "workspace-outputs");
+		actions.push({
+			kind: "would-clear-outputs",
+			target: root,
+			workspace: root,
+			bytes: size?.bytes ?? 0,
+			olderThanDays: days,
+			reason: `idle ${entry.idleDays} days, older than ${days} days (age sweep)`,
+			check: "sweep"
+		});
+	}
+	for (const cache of trimmableCaches(operation?.env, operation?.cwd).filter((candidate) => !isInsideWorkspaces(candidate.dir))) actions.push({
+		kind: "would-trim-cache",
+		target: cacheLabel(cache),
+		dir: cache.dir,
+		bytes: 0,
+		olderThanDays: days,
+		reason: `entries unused for ${days} days (age sweep)`,
+		check: "sweep"
+	});
+	try {
+		const orphans = collectOrphanedWorkspaces(Object.keys(loadConfig$1()?.projects ?? {}), listMountedVolumes(), { measure: false });
+		for (const orphan of orphans.orphaned) actions.push({
+			kind: "would-remove-orphan",
+			target: orphan.dir,
+			bytes: orphan.bytes ?? 0,
+			reason: `its project ${orphan.projectRoot} no longer exists`,
+			check: "sweep"
+		});
+		for (const kept of orphans.skipped) skips.push({
+			target: kept.dir,
+			reason: kept.reason
+		});
+	} catch (error) {
+		blocked.push(`Could not look for orphaned workspace directories: ${error instanceof Error ? error.message : error}`);
+	}
+	if (devices && settings.deviceIdleDays > 0) {
+		const options = {
+			roots: Object.keys(loadConfig$1()?.projects ?? {}).map((root) => ({ root })),
+			windowMs: settings.deviceIdleDays * 864e5,
+			reason: `idle for ${settings.deviceIdleDays} days (age sweep)`,
+			protectedRoot,
+			pinned,
+			sizes,
+			now,
+			extra: {
+				check: "sweep",
+				olderThanDays: settings.deviceIdleDays
+			},
+			env: operation?.env
+		};
+		const reaped = operation ? await planDeviceDeletionAsync(options, operation.signal) : planDeviceDeletion(options);
+		actions.push(...reaped.actions);
+		skips.push(...reaped.skips);
+	}
+	const mounted = listMountedVolumes();
+	for (const cache of readManifest().caches) {
+		if (!isAbsolute(cache.dir) || existsSync(cache.dir) || !isOnMountedVolume(cache.dir, mounted)) continue;
+		actions.push({
+			kind: "would-unregister-cache",
+			target: cache.dir,
+			dir: cache.dir,
+			bytes: 0,
+			reason: "its directory no longer exists",
+			check: "sweep"
+		});
+	}
+	return {
+		actions,
+		blocked,
+		skips
+	};
+}
+async function planWorktrees({ protectedRoot, pinned, now, level, graceMs, sizes, protectRecentMs = 0, refresh, operation }) {
+	const sweep = await collectWorktreeSweep({
+		idle: false,
+		olderThan: null,
+		now,
+		removesNoOwnCommits: level === 3,
+		operation,
+		...graceMs === void 0 ? {} : { graceMs },
+		...refresh === void 0 ? {} : { refresh }
+	});
+	const actions = [];
+	const skips = [];
+	const keep = [];
+	for (const worktree of sweep.worktrees) {
+		if (worktree.skipped) continue;
+		const path = canonicalPath(worktree.path);
+		const reason = protectedRoot === path || protectedRoot.startsWith(`${path}${sep}`) ? "the command that started this pass runs inside it" : worktree.keys.some(pinned) ? "pinned by maintenance.keep" : null;
+		if (reason) {
+			skips.push({
+				target: worktree.path,
+				reason
+			});
+			continue;
+		}
+		keep.push(worktree);
+		actions.push({
+			kind: "would-remove-worktree",
+			target: worktree.path,
+			bytes: 0,
+			reason: worktreeRemovalReason(worktree, sweep),
+			check: "worktree",
+			...level ? { level } : {}
+		});
+	}
+	if (sizes) {
+		const options = {
+			roots: finishedWorkspaces(sweep, now),
+			windowMs: Math.max(sweep.graceMs, protectRecentMs),
+			reason: "finished-worktree check",
+			protectedRoot,
+			pinned,
+			sizes,
+			now,
+			extra: { check: "worktree" },
+			env: operation?.env
+		};
+		const devices = operation ? await planDeviceDeletionAsync(options, operation.signal) : planDeviceDeletion(options);
+		actions.push(...devices.actions);
+		skips.push(...devices.skips);
+	}
+	return {
+		actions,
+		blocked: [],
+		skips,
+		sweep: {
+			...sweep,
+			worktrees: keep
+		}
+	};
+}
+//#endregion
+//#region src/maintenance/artifacts.ts
+/** Directories that hold only what a build or an install regenerates, relative to an app or package root. */
+const ARTIFACT_DIRS = {
+	build: [
+		"ios/build",
+		"android/app/build",
+		"android/build",
+		"android/.gradle",
+		".build"
+	],
+	dependencies: ["node_modules", "ios/Pods"]
+};
+const PACKAGE_PARENTS = ["apps", "packages"];
+const SCAN_DEPTH = {
+	build: 3,
+	dependencies: 1
+};
+const SCAN_LIMIT = 2e4;
+function isDirectory(path) {
+	try {
+		return lstatSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function artifactWorktrees() {
+	const found = /* @__PURE__ */ new Map();
+	for (const root of candidateRoots()) {
+		const entry = artifactWorktree(root, listWorktrees(root));
+		if (entry) found.set(entry.path, entry);
+	}
+	return [...found.values()];
+}
+function artifactWorktree(root, entries, source = sourceCheckoutOf(entries)) {
+	const entry = matchWorktreeEntry(entries, root);
+	if (!entry || entry.bare || "refusal" in source) return null;
+	const keys = reclaimKeys(entry.path).filter((key) => matchWorktreeEntry(entries, key)?.path === entry.path);
+	return {
+		path: entry.path,
+		linked: entry.path !== source.path,
+		keys
+	};
+}
+async function artifactWorktreesAsync(signal) {
+	const found = /* @__PURE__ */ new Map();
+	for (const root of await candidateRootsAsync()) {
+		signal.throwIfAborted();
+		const { entries, ...source } = await resolveSourceCheckoutAsync(root);
+		const entry = artifactWorktree(root, entries, source);
+		if (entry) found.set(entry.path, entry);
+	}
+	return [...found.values()];
+}
+function appRoots(worktree, kind) {
+	const roots = /* @__PURE__ */ new Set([worktree.path, ...worktree.keys]);
+	if (kind === "build") for (const parent of PACKAGE_PARENTS) {
+		const dir = join(worktree.path, parent);
+		try {
+			for (const name of readdirSync(dir)) if (isDirectory(join(dir, name))) roots.add(join(dir, name));
+		} catch {}
+	}
+	return [...roots];
+}
+/** The newest mtime under `dir` down to `maxDepth`, or null when the tree is too large or unreadable to tell. */
+function newestWrite(dir, maxDepth) {
+	let newest = 0;
+	let seen = 0;
+	const walk = (path, depth) => {
+		let stat;
+		try {
+			stat = lstatSync(path);
+		} catch {
+			return false;
+		}
+		if (++seen > SCAN_LIMIT) return false;
+		newest = Math.max(newest, stat.mtimeMs);
+		if (depth === maxDepth || !stat.isDirectory()) return true;
+		let names;
+		try {
+			names = readdirSync(path);
+		} catch {
+			return false;
+		}
+		return names.every((name) => walk(join(path, name), depth + 1));
+	};
+	return walk(dir, 0) ? newest : null;
+}
+async function newestWriteAsync(dir, maxDepth, signal) {
+	let newest = 0;
+	let seen = 0;
+	const walk = async (path, depth) => {
+		signal.throwIfAborted();
+		try {
+			const stat = await lstat(path);
+			if (++seen > SCAN_LIMIT) return false;
+			newest = Math.max(newest, stat.mtimeMs);
+			if (depth === maxDepth || !stat.isDirectory()) return true;
+			for (const name of await readdir(path)) if (!await walk(join(path, name), depth + 1)) return false;
+			return true;
+		} catch {
+			signal.throwIfAborted();
+			return false;
+		}
+	};
+	return await walk(dir, 0) ? newest : null;
+}
+function keptReason(candidate, kind, { now, windowMs, pinned, locked }, reads) {
+	const guarded = artifactGuard(candidate, kind, pinned, locked);
+	if (guarded) return guarded;
+	const { worktree, path, keys } = candidate;
+	const tracked = reads ? reads.tracked : gitQuiet(worktree, [
+		"ls-files",
+		"--",
+		relative(worktree, path)
+	]);
+	if (tracked === null) return "git cannot tell whether it holds tracked files";
+	if (tracked.trim()) return "it holds files git tracks";
+	const activity = reads ? reads.activity : worktreeActivityOf(worktree, keys);
+	const written = reads ? reads.written : newestWrite(path, SCAN_DEPTH[kind]);
+	if (!activity || written === null) return "its last activity cannot be read";
+	if (now - Math.max(activity.at, written) < windowMs) return `used within the last ${Math.round(windowMs / 6e4)} minutes`;
+	return null;
+}
+function artifactGuard(candidate, kind, pinned, locked) {
+	const { worktree, path, keys } = candidate;
+	if (keys.some(pinned)) return "pinned by maintenance.keep";
+	let real;
+	try {
+		real = canonicalPath(path);
+	} catch {
+		return "its path cannot be resolved";
+	}
+	if (!isDirectory(path) || real !== join(canonicalPath(worktree), relative(worktree, path))) return "it or a directory above it is a link, or it lies outside its worktree";
+	const inUse = keys.flatMap((key) => workspaceInUse(key, {
+		supervisor: kind === "dependencies",
+		nativeRun: key !== locked
+	}));
+	if (inUse.length) return `in use: ${inUse.join("; ")}`;
+	return null;
+}
+async function collectArtifactsAsync(kind, options, signal) {
+	const candidates = [];
+	const skips = [];
+	for (const worktree of await artifactWorktreesAsync(signal)) {
+		if (kind === "dependencies" && !worktree.linked) continue;
+		const root = canonicalPath(worktree.path);
+		const protectedHere = options.protectedRoot === root || options.protectedRoot.startsWith(`${root}${sep}`);
+		const bases = /* @__PURE__ */ new Set([worktree.path, ...worktree.keys]);
+		if (kind === "build") for (const parent of PACKAGE_PARENTS) {
+			const dir = join(worktree.path, parent);
+			try {
+				for (const name of await readdir(dir)) {
+					signal.throwIfAborted();
+					if ((await lstat(join(dir, name))).isDirectory()) bases.add(join(dir, name));
+				}
+			} catch {
+				signal.throwIfAborted();
+			}
+		}
+		for (const base of bases) for (const dir of ARTIFACT_DIRS[kind]) {
+			signal.throwIfAborted();
+			const path = join(base, dir);
+			try {
+				await stat(path);
+			} catch {
+				signal.throwIfAborted();
+				continue;
+			}
+			const candidate = {
+				worktree: worktree.path,
+				path,
+				keys: worktree.keys
+			};
+			let reason = protectedHere ? "the command that started this pass runs inside its worktree" : artifactGuard(candidate, kind, options.pinned);
+			if (!reason) {
+				const tracked = await gitQuietAsync(worktree.path, [
+					"ls-files",
+					"--",
+					relative(worktree.path, path)
+				]);
+				const untracked = tracked !== null && !tracked.trim();
+				reason = keptReason(candidate, kind, options, {
+					tracked,
+					activity: untracked ? await worktreeActivityOfAsync(worktree.path, worktree.keys) : null,
+					written: untracked ? await newestWriteAsync(path, SCAN_DEPTH[kind], signal) : null
+				});
+			}
+			if (reason) skips.push({
+				target: path,
+				reason
+			});
+			else candidates.push(candidate);
+		}
+	}
+	return {
+		candidates,
+		skips
+	};
+}
+/** Regenerable directories of idle worktrees, oldest activity first; dependencies only in linked worktrees. */
+function collectArtifacts(kind, options) {
+	const candidates = [];
+	const skips = [];
+	for (const worktree of artifactWorktrees()) {
+		if (kind === "dependencies" && !worktree.linked) continue;
+		const root = canonicalPath(worktree.path);
+		const protectedHere = options.protectedRoot === root || options.protectedRoot.startsWith(`${root}${sep}`);
+		for (const base of appRoots(worktree, kind)) for (const dir of ARTIFACT_DIRS[kind]) {
+			const path = join(base, dir);
+			try {
+				statSync(path);
+			} catch {
+				continue;
+			}
+			const candidate = {
+				worktree: worktree.path,
+				path,
+				keys: worktree.keys
+			};
+			const reason = protectedHere ? "the command that started this pass runs inside its worktree" : keptReason(candidate, kind, options);
+			if (reason) skips.push({
+				target: path,
+				reason
+			});
+			else candidates.push(candidate);
+		}
+	}
+	return {
+		candidates,
+		skips
+	};
+}
+async function clearArtifact(action, kind, options) {
+	const worktree = options.worktrees.filter((entry) => action.target.startsWith(`${entry.path}${sep}`)).reduce((best, entry) => best && best.path.length >= entry.path.length ? best : entry, null);
+	if (kind === "dependencies" && worktree && !worktree.linked) return {
+		status: "kept",
+		bytes: 0,
+		detail: "it is in the source checkout"
+	};
+	if (!worktree || !ARTIFACT_DIRS[kind].some((dir) => action.target.endsWith(`${sep}${dir.split("/").join(sep)}`))) return {
+		status: "kept",
+		bytes: 0,
+		detail: "it is no longer a regenerable directory of a known worktree"
+	};
+	const root = canonicalPath(worktree.path);
+	if (options.protectedRoot === root || options.protectedRoot.startsWith(`${root}${sep}`)) return {
+		status: "kept",
+		bytes: 0,
+		detail: "the command that started this pass runs inside its worktree"
+	};
+	const candidate = {
+		worktree: worktree.path,
+		path: action.target,
+		keys: worktree.keys
+	};
+	const early = keptReason(candidate, kind, {
+		...options,
+		now: Date.now()
+	});
+	if (early) return {
+		status: "kept",
+		bytes: 0,
+		detail: early
+	};
+	const before = lowestFree(measureDisk());
+	const [key] = candidate.keys;
+	const remove = () => {
+		const reason = keptReason(candidate, kind, {
+			...options,
+			now: Date.now(),
+			...key ? { locked: key } : {}
+		});
+		if (reason) return reason;
+		rmSync(candidate.path, {
+			recursive: true,
+			force: true
+		});
+		return null;
+	};
+	const kept = key ? await withIdleWorkspace(key, remove, {
+		purpose: "maintenance",
+		supervisor: kind === "dependencies"
+	}).then((run) => run.ran ? run.value : `in use: ${run.reasons.join("; ")}`) : remove();
+	if (kept) return {
+		status: "kept",
+		bytes: 0,
+		detail: kept
+	};
+	const freed = Math.max(0, lowestFree(measureDisk()) - before);
+	return {
+		status: "done",
+		bytes: Number.isFinite(freed) ? Math.round(freed * 1024 * 1024) : 0,
+		detail: candidate.path
+	};
+}
+//#endregion
+//#region src/commands/gc/temp-leftovers-guard-env.ts
+const TEMP_LEFTOVERS_TEST_GUARD_ENV = "STIM_TEST_GUARD_REAL_TMPDIR";
+//#endregion
+//#region src/commands/gc/temp-leftovers.ts
+const TEMP_LEFTOVER_MIN_AGE_HOURS = 24;
+const MIN_AGE_MS = 864e5;
+const STIM_PREFIXES = [
+	"stim-claim-",
+	"stim-host-",
+	"stim-fakehome-",
+	"stim-hosted-macos-",
+	"stim-server-",
+	"stim-ws-"
+];
+const STAGING_PREFIX = ".stim-delete-";
+const TRACE_PATTERN = /^instruments.*\.ktrace$/;
+const TRACE_PROCESSES = /* @__PURE__ */ new Set(["xctrace", "Instruments"]);
+const REMEDIES = {
+	stim: "stim gc --delete removes them once they are idle for 24 hours",
+	xctrace: "stim gc --delete removes them once they are idle for 24 hours and no xctrace or Instruments process runs; export a recording you need first",
+	jest: "Jest owns this cache; clear it with `npx jest --clearCache`"
+};
+const LABELS = {
+	stim: "Stim temp directories",
+	xctrace: "xctrace recordings (instruments*.ktrace)",
+	jest: "Jest cache"
+};
+function kindOf(name, stat, jestName) {
+	const unstaged = name.startsWith(STAGING_PREFIX) ? name.slice(13) : name;
+	if (stat.isDirectory() && STIM_PREFIXES.some((prefix) => unstaged.startsWith(prefix))) return "stim";
+	if ((stat.isFile() || stat.isDirectory()) && TRACE_PATTERN.test(name)) return "xctrace";
+	if (stat.isDirectory() && name === jestName) return "jest";
+	return null;
+}
+function errorCode(error) {
+	return error instanceof Error && "code" in error ? String(error.code) : String(error);
+}
+async function lstatOrError(path) {
+	try {
+		return await lstat(path);
+	} catch (error) {
+		const code = errorCode(error);
+		return code === "ENOENT" ? void 0 : { error: code };
+	}
+}
+async function walk(path, stat, signal, state = {
+	bytes: 0,
+	newest: 0,
+	claimRoots: [],
+	locks: [],
+	unreadable: null
+}) {
+	signal?.throwIfAborted();
+	state.bytes += stat.size;
+	state.newest = Math.max(state.newest, stat.mtimeMs);
+	if (!stat.isDirectory()) return state;
+	let names;
+	try {
+		names = await readdir(path);
+	} catch (error) {
+		state.unreadable ??= `${path} cannot be listed: ${errorCode(error)}`;
+		return state;
+	}
+	for (const name of names) {
+		const child = join(path, name);
+		const childStat = await lstatOrError(child);
+		if (!childStat) continue;
+		if ("error" in childStat) {
+			state.unreadable ??= `${child} cannot be read: ${childStat.error}`;
+			continue;
+		}
+		if ((name === "exclusive" || name === "shared") && !state.claimRoots.includes(path)) state.claimRoots.push(path);
+		await walk(child, childStat, signal, state);
+	}
+	if (path.endsWith(".lock") && !state.claimRoots.includes(path)) state.locks.push(path);
+	return state;
+}
+function canonicalKey(path) {
+	try {
+		const rest = [];
+		let current = resolve(path);
+		while (!lstatSync(current, { throwIfNoEntry: false }) && dirname(current) !== current) {
+			rest.unshift(basename(current));
+			current = dirname(current);
+		}
+		return join(realpathSync(current), ...rest);
+	} catch {
+		return resolve(path);
+	}
+}
+function inside(parent, path) {
+	const rel = relative(parent, path);
+	return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+/** Basenames of running executables, or null when the process list cannot be read. */
+async function runningExecutables() {
+	try {
+		const out = await getExecutor().runFileAsync("ps", [
+			"-axww",
+			"-o",
+			"comm="
+		], { timeoutMs: 1e4 });
+		return new Set(out.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => basename(line)));
+	} catch {
+		return null;
+	}
+}
+function stimKept(identity, scan, projects) {
+	const registered = projects.find((root) => inside(identity, root) || inside(root, identity));
+	if (registered) return `the registered project ${registered} is in it; gc handles it as a project entry`;
+	if (scan.unreadable) return scan.unreadable;
+	if (scan.locks.length) return `the lock directory ${scan.locks[0]} has no verifiable owner`;
+	for (const root of scan.claimRoots) {
+		const survey = readClaimSet(root);
+		if (survey.live.length) return `it holds a live ownership claim at ${root}`;
+		if (survey.unresolved.length) return `the ownership claim at ${root} cannot be verified`;
+	}
+	return null;
+}
+/** The temporary root `env` selects, with Node's `os.tmpdir()` precedence. */
+function temporaryRoot(env) {
+	if (env === process.env) return tmpdir();
+	const chosen = process.platform === "win32" ? env.TEMP || env.TMP || join(env.SystemRoot || env.windir || "C:\\Windows", "temp") : env.TMPDIR || env.TMP || env.TEMP || "/tmp";
+	const driveRoot = process.platform === "win32" && chosen.endsWith(":\\");
+	return chosen.length > 1 && chosen.endsWith(sep) && !driveRoot ? chosen.slice(0, -1) : chosen;
+}
+/**
+* Recognized leftovers directly inside the user's TMPDIR, never following a symlink: Stim's own temp directories,
+* xctrace recordings and Jest's cache. Only the first two are ever deleted, and only once nothing in them changed for
+* 24 hours. Null with STIM_HOME set, because TMPDIR is shared by every Stim home, and for the real TMPDIR a test
+* process recorded in STIM_TEST_GUARD_REAL_TMPDIR.
+*/
+async function collectTempLeftovers({ now = Date.now(), env = process.env, signal } = {}) {
+	if (deviceSweepIsScoped(env)) return null;
+	let root;
+	let names;
+	try {
+		root = await realpath(temporaryRoot(env));
+		const guarded = process.env[TEMP_LEFTOVERS_TEST_GUARD_ENV];
+		if (guarded && root === guarded) return null;
+		names = await readdir(root);
+	} catch {
+		return null;
+	}
+	const uid = process.getuid?.();
+	const jestName = uid === void 0 ? null : `jest_${uid.toString(36)}`;
+	const registeredProjects = () => Object.keys(loadConfig$1()?.projects ?? {}).flatMap((key) => [key, canonicalKey(key)]);
+	let projects = registeredProjects();
+	let executables;
+	const traceBusy = async () => {
+		if (executables === void 0) executables = await runningExecutables();
+		const listed = executables;
+		if (listed === null) return "the running processes could not be listed";
+		const running = [...TRACE_PROCESSES].filter((name) => listed.has(name));
+		return running.length ? `${running.join(" and ")} is running` : null;
+	};
+	const judge = async (path, stat, kind, identity = path) => {
+		const scan = await walk(path, stat, signal);
+		const kept = now - scan.newest < MIN_AGE_MS ? `modified within the last ${TEMP_LEFTOVER_MIN_AGE_HOURS}h` : kind === "stim" ? stimKept(identity, scan, projects) : scan.unreadable ?? await traceBusy();
+		return {
+			bytes: scan.bytes,
+			kept
+		};
+	};
+	const recheck = async (staged, original, kind) => {
+		const stat = await lstatOrError(staged);
+		if (!stat || "error" in stat || stat.isSymbolicLink()) return "it changed while it was being deleted";
+		if (kind === "xctrace") executables = void 0;
+		else projects = registeredProjects();
+		return (await judge(staged, stat, kind, original)).kept;
+	};
+	const entries = [];
+	for (const name of names.toSorted()) {
+		const path = join(root, name);
+		const stat = await lstatOrError(path);
+		if (!stat || "error" in stat || stat.isSymbolicLink() || uid !== void 0 && stat.uid !== uid) continue;
+		const kind = kindOf(name, stat, jestName);
+		if (!kind) continue;
+		if (kind === "jest") {
+			const bytes = await directorySizeAsync(path, { timeoutMs: 1e4 });
+			entries.push({
+				kind,
+				path,
+				bytes,
+				willDelete: false,
+				kept: "report only: Jest owns it"
+			});
+			continue;
+		}
+		const { bytes, kept } = await judge(path, stat, kind, kind === "stim" && name.startsWith(STAGING_PREFIX) ? join(root, name.slice(13)) : path);
+		entries.push({
+			kind,
+			path,
+			bytes,
+			willDelete: kept === null,
+			kept
+		});
+	}
+	return {
+		root,
+		entries,
+		recheck
+	};
+}
+function summarize(report) {
+	return [
+		"stim",
+		"xctrace",
+		"jest"
+	].flatMap((kind) => {
+		const entries = report.entries.filter((entry) => entry.kind === kind);
+		if (!entries.length) return [];
+		const deleting = entries.filter((entry) => entry.willDelete);
+		const kept = /* @__PURE__ */ new Map();
+		for (const entry of entries) if (entry.kept) kept.set(entry.kept, (kept.get(entry.kept) ?? 0) + 1);
+		return [{
+			kind,
+			count: entries.length,
+			bytes: entries.reduce((sum, entry) => sum + entry.bytes, 0),
+			deleteCount: deleting.length,
+			deleteBytes: deleting.reduce((sum, entry) => sum + entry.bytes, 0),
+			kept: [...kept].map(([reason, count]) => ({
+				reason,
+				count
+			})),
+			remedy: REMEDIES[kind]
+		}];
+	});
+}
+function tempLeftoverLines(report) {
+	if (!report?.entries.length) return [];
+	const groups = summarize(report);
+	const total = groups.reduce((sum, group) => sum + group.bytes, 0);
+	const lines = [`TMPDIR leftovers (${formatBytes(total)} in ${report.entries.length}) - ${report.root}:`];
+	for (const group of groups) {
+		lines.push(`  ${formatBytes(group.bytes).padStart(10)}  ${LABELS[group.kind]}: ${group.count}`);
+		if (group.deleteCount) lines.push(`              --delete would DELETE ${group.deleteCount} (${formatBytes(group.deleteBytes)})`);
+		for (const { reason, count } of group.kept) lines.push(`              kept ${count}: ${reason}`);
+		lines.push(`              remedy: ${group.remedy}`);
+	}
+	return lines;
+}
+function tempLeftoverSection(report) {
+	return report ? {
+		root: report.root,
+		groups: summarize(report)
+	} : null;
+}
+/** Deletes what a fresh `collectTempLeftovers` marks for deletion. Returns the bytes freed and the failures. */
+async function deleteTempLeftovers(options = {}) {
+	const report = await collectTempLeftovers(options);
+	const done = {
+		count: 0,
+		bytes: 0,
+		failures: 0
+	};
+	if (!report) return done;
+	for (const entry of report.entries) {
+		if (!entry.willDelete) continue;
+		try {
+			if (entry.kind === "jest") continue;
+			const name = basename(entry.path);
+			const staged = entry.kind === "xctrace" || name.startsWith(STAGING_PREFIX) ? entry.path : join(report.root, `${STAGING_PREFIX}${name}`);
+			const before = staged === entry.path ? null : await report.recheck?.(entry.path, entry.path, entry.kind) ?? null;
+			if (before) {
+				recordGcResult("tempLeftover", "kept", entry.path, {
+					bytes: entry.bytes,
+					detail: before
+				});
+				continue;
+			}
+			if (staged !== entry.path) await rename(entry.path, staged);
+			let kept;
+			try {
+				const original = name.startsWith(STAGING_PREFIX) ? join(report.root, name.slice(13)) : entry.path;
+				kept = await report.recheck?.(staged, original, entry.kind) ?? null;
+			} catch (error) {
+				kept = `it could not be checked again: ${errorCode(error)}`;
+				if (options.signal?.aborted) {
+					if (staged !== entry.path) await rename(staged, entry.path).catch(() => {});
+					throw error;
+				}
+			}
+			if (kept) {
+				let detail = kept;
+				try {
+					if (staged !== entry.path) await rename(staged, entry.path);
+				} catch (error) {
+					detail = `${kept}; it stays at ${staged} because it could not be renamed back: ${errorCode(error)}`;
+					console.log(chalk.yellow(`Kept ${entry.path} at ${staged}: ${detail}`));
+				}
+				recordGcResult("tempLeftover", "kept", entry.path, {
+					bytes: entry.bytes,
+					detail
+				});
+				continue;
+			}
+			removeTemporaryEntry(staged);
+			done.count++;
+			done.bytes += entry.bytes;
+		} catch (error) {
+			if (options.signal?.aborted) throw error;
+			if (errorCode(error) === "ENOENT") continue;
+			done.failures++;
+			const detail = error instanceof Error ? error.message : String(error);
+			console.log(chalk.red(`Could not delete ${entry.path}: ${detail}`));
+			recordGcResult("tempLeftover", "failed", entry.path, {
+				bytes: entry.bytes,
+				detail
+			});
+		}
+	}
+	if (done.count) {
+		console.log(chalk.green(`Deleted ${plural(done.count, "TMPDIR leftover")} (${formatBytes(done.bytes)}) in ${report.root}`));
+		recordGcResult("tempLeftover", "done", report.root, {
+			bytes: done.bytes,
+			detail: `${plural(done.count, "entry", "entries")} deleted`
+		});
+	}
+	return done;
+}
+//#endregion
+//#region src/maintenance/levels.ts
+async function planLevel2({ settings, sizes, protectedRoot, pinned, now, operation }) {
+	const windowMs = settings.pressureProtectMinutes * 6e4;
+	const actions = [];
+	const skips = [];
+	const reason = `disk pressure level 2, idle for ${settings.pressureProtectMinutes} minutes`;
+	const outputs = collectWorkspaceOutputs({
+		olderThan: null,
+		now,
+		measure: false
+	}).workspaces.flatMap((entry) => {
+		const root = entry.projectRoot === null ? null : canonicalPath(entry.projectRoot);
+		if (root === null || !entry.willClear || root === protectedRoot || pinned(root)) return [];
+		const used = workspaceLastUsed(root);
+		return Number.isFinite(used) && now - used >= windowMs ? [{
+			root,
+			used
+		}] : [];
+	}).toSorted((a, b) => a.used - b.used);
+	for (const { root } of outputs) {
+		const size = sizes.find((entry) => entry.workspace === root && entry.category === "workspace-outputs");
+		actions.push({
+			kind: "would-clear-outputs",
+			target: root,
+			workspace: root,
+			bytes: size?.bytes ?? 0,
+			reason,
+			level: 2
+		});
+	}
+	if (!deviceSweepIsScoped(operation?.env ?? process.env)) for (const platform of ["ios", "android"]) for (const record of readParked(platform)) actions.push({
+		kind: "would-delete-parked-device",
+		target: platform === "ios" ? record.udid : record.name,
+		bytes: 0,
+		reason: `parked ${platform} device, disk pressure level 2`,
+		level: 2
+	});
+	const leftovers = await collectTempLeftovers({
+		now,
+		env: operation?.env,
+		signal: operation?.signal
+	});
+	const deletable = leftovers?.entries.filter((entry) => entry.willDelete) ?? [];
+	if (leftovers && deletable.length) actions.push({
+		kind: "would-delete-temp-leftovers",
+		target: leftovers.root,
+		bytes: deletable.reduce((sum, entry) => sum + entry.bytes, 0),
+		reason: "disk pressure level 2, Stim temp directories and xctrace recordings unmodified for 24 hours",
+		level: 2
+	});
+	const options = {
+		now,
+		windowMs,
+		protectedRoot,
+		pinned
+	};
+	const build = operation ? await collectArtifactsAsync("build", options, operation.signal) : collectArtifacts("build", options);
+	for (const candidate of build.candidates) actions.push({
+		kind: "would-clear-build-dirs",
+		target: candidate.path,
+		bytes: 0,
+		reason,
+		level: 2
+	});
+	skips.push(...build.skips);
+	const deviceOptions = {
+		roots: Object.keys(loadConfig$1()?.projects ?? {}).map((root) => ({ root })),
+		windowMs,
+		reason,
+		protectedRoot,
+		pinned,
+		sizes,
+		now,
+		extra: { level: 2 },
+		env: operation?.env
+	};
+	const devices = operation ? await planDeviceDeletionAsync(deviceOptions, operation.signal) : planDeviceDeletion(deviceOptions);
+	actions.push(...devices.actions);
+	skips.push(...devices.skips);
+	return {
+		actions,
+		blocked: [],
+		skips
+	};
+}
+async function planGradleDaemonStop(blockers, operation) {
+	if (memorySweepIsScoped(operation?.env ?? process.env)) return { kept: "STIM_HOME scopes this config, so the machine-global Gradle daemons that keep it are not stopped" };
+	const report = await collectMemoryReport({
+		watchman: false,
+		gradle: true
+	}, false, operation);
+	const skipped = report.notices.find((notice) => notice.startsWith("memory sweep skipped"));
+	if (skipped) return { kept: `the running Gradle processes could not be checked: ${skipped}` };
+	const plans = new Map(report.processes.map((entry) => [entry.pid, entry]));
+	for (const pid of blockers) {
+		const plan = plans.get(pid);
+		if (!plan || !plan.reclaimable) return { kept: `Gradle pid ${pid} keeps it: ${plan?.detail ?? "it is not a daemon gc --delete --cache gradle-daemons stops"}` };
+	}
+	return { pids: [...blockers] };
+}
+async function planLevel3({ settings, sizes, protectedRoot, pinned, now, refresh, operation }) {
+	const windowMs = settings.pressureProtectMinutes * 6e4;
+	const actions = [];
+	const blocked = [];
+	const skips = [];
+	const reason = `disk pressure level 3, idle for ${settings.pressureProtectMinutes} minutes`;
+	for (const size of sizes.filter((entry) => entry.category === "compilation-cache")) if (size.blocked) {
+		skips.push({
+			target: size.dir,
+			reason: size.blocked
+		});
+		blocked.push(`the Swift compilation cache (${formatBytes(size.bytes)}) can only be emptied whole and is kept: ${size.blocked}`);
+	} else actions.push({
+		kind: "would-empty-cache",
+		target: size.dir,
+		dir: size.dir,
+		bytes: size.bytes,
+		reason: "disk pressure level 3",
+		level: 3
+	});
+	const worktrees = settings.removeFinishedWorktrees ? await planWorktrees({
+		protectedRoot,
+		pinned,
+		now,
+		level: 3,
+		graceMs: windowMs,
+		refresh,
+		operation
+	}) : null;
+	actions.push(...worktrees?.actions ?? []);
+	skips.push(...worktrees?.skips ?? []);
+	const activity = operation ? cachedDeviceActivityAsync(now, operation.env) : null;
+	for (const root of Object.keys(loadConfig$1()?.projects ?? {}).map(canonicalPath)) {
+		if (root === protectedRoot || pinned(root)) continue;
+		if (workspaceInUse(root, {
+			managedLocks: false,
+			hosted: false,
+			nativeRun: false
+		}).length === 0) continue;
+		const active = activity ? await workspaceActiveReasonAsync(root, now, windowMs, activity) : workspaceActiveReason(root, now, windowMs);
+		if (active) skips.push({
+			target: root,
+			reason: active,
+			workspace: root
+		});
+		else actions.push({
+			kind: "would-stop-workspace",
+			target: root,
+			workspace: root,
+			bytes: 0,
+			reason,
+			level: 3
+		});
+	}
+	const artifactOptions = {
+		now,
+		windowMs,
+		protectedRoot,
+		pinned
+	};
+	const dependencies = operation ? await collectArtifactsAsync("dependencies", artifactOptions, operation.signal) : collectArtifacts("dependencies", artifactOptions);
+	for (const candidate of dependencies.candidates) actions.push({
+		kind: "would-delete-dependencies",
+		target: candidate.path,
+		bytes: 0,
+		reason,
+		level: 3
+	});
+	skips.push(...dependencies.skips);
+	if (settings.gradleVersionIdleDays > 0) {
+		const gradle = await collectGradleVersions({
+			operation,
+			olderThanDays: settings.gradleVersionIdleDays,
+			now,
+			measure: false,
+			pastRunningGradle: true
+		});
+		const stop = gradle.gradleRunning && gradle.versions.some((entry) => entry.willDelete) ? await planGradleDaemonStop(gradle.gradleRunningPids, operation) : null;
+		if (stop?.pids) actions.push({
+			kind: "would-stop-gradle-daemons",
+			target: `pid ${stop.pids.join(", ")}`,
+			bytes: 0,
+			reason: "disk pressure level 3, these idle Gradle and Kotlin daemons keep unpinned Gradle versions",
+			level: 3
+		});
+		for (const entry of gradle.versions) if (entry.willDelete && !stop?.kept) actions.push({
+			kind: "would-delete-gradle-version",
+			target: entry.version,
+			dir: gradle.home,
+			bytes: 0,
+			reason: `disk pressure level 3, no registered project pins it and it is unmodified for ${settings.gradleVersionIdleDays} days`,
+			level: 3
+		});
+		else skips.push({
+			target: `Gradle ${entry.version}`,
+			reason: entry.willDelete && stop?.kept || entry.detail || "kept"
+		});
+	}
+	return {
+		actions,
+		blocked,
+		skips,
+		...worktrees ? { sweep: worktrees.sweep } : {}
+	};
+}
+/** Level 2 and 3 actions for a pass that measured `level`; level 1 is the regular plan. */
+async function planPressureLevels(level, context) {
+	if (level < 1) return {
+		actions: [],
+		blocked: [],
+		skips: []
+	};
+	const second = await planLevel2(context);
+	if (level < 3) return second;
+	const third = await planLevel3(context);
+	return {
+		actions: [...second.actions, ...third.actions],
+		blocked: third.blocked,
+		skips: [...second.skips, ...third.skips],
+		...third.sweep ? { pressureSweep: third.sweep } : {}
+	};
+}
+//#endregion
+//#region src/maintenance/preview.ts
+function triggeringRoot(operation) {
+	return canonicalPath(findProjectRoot$1(operation?.cwd ?? process.cwd()) ?? join(configDir(), "maintenance", "no-project"));
+}
+async function plannedMaintenance(pressure, sizes, settings, { devices = true, sweep = false, worktrees = false, refresh = true, operation } = {}) {
+	const env = operation?.env ?? process.env;
+	const resolved = resolveBudget({ env });
+	if (resolved.error) throw new Error(resolved.error);
+	const budget = {
+		...resolved.budget,
+		maxCommittedMemoryMb: 0,
+		maxLiveWorkspaces: 0
+	};
+	const root = triggeringRoot(operation);
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	const low = pressure?.disk.some((disk) => disk.freeMb < floor);
+	const outcome = low ? await enforceBudget({
+		root,
+		note: () => {},
+		dryRun: true,
+		budget,
+		env,
+		cwd: operation?.cwd
+	}, { volumes: () => pressure.disk }) : null;
+	if (outcome && outcome.status !== "ok") throw new Error(outcome.refusal.message);
+	const outputs = collectWorkspaceOutputs({
+		olderThan: null,
+		now: Date.now(),
+		measure: false
+	});
+	const currentSizes = sizes.map((size) => {
+		if (size.category === "compilation-cache") return {
+			...size,
+			blocked: cacheBlocked(size, discoverCaches(env, operation?.cwd), env)
+		};
+		if (!size.workspace) return size;
+		const current = outputs.workspaces.find((entry) => entry.projectRoot && canonicalPath(entry.projectRoot) === size.workspace);
+		return Object.assign({}, size, { blocked: current?.willClear ? void 0 : current?.keptReason ?? "workspace outputs cannot be resolved" });
+	});
+	const pins = /* @__PURE__ */ new Map();
+	if (operation) {
+		const candidates = await candidateRootsAsync();
+		const roots = /* @__PURE__ */ new Set([
+			...Object.keys(loadConfig()?.projects ?? {}),
+			...candidates,
+			...sizes.flatMap((size) => size.workspace ? [size.workspace] : []),
+			...outputs.workspaces.flatMap((entry) => entry.projectRoot ? [entry.projectRoot] : [])
+		]);
+		for (const path of candidates) for (const entry of await listWorktreesAsync(path)) roots.add(entry.path);
+		for (const path of Array.from(roots, canonicalPath)) roots.add(path);
+		for (const path of roots) pins.set(path, await maintenancePinnedAsync(path, operation));
+	}
+	const pinned = (workspace) => {
+		let value = pins.get(workspace);
+		if (operation) return value ?? true;
+		if (value === void 0) pins.set(workspace, value = maintenancePinned(workspace));
+		return value;
+	};
+	const result = plan({
+		pressure,
+		sizes: currentSizes,
+		settings,
+		budget,
+		diskSteps: outcome?.status === "ok" ? outcome.reclaimed.filter((step) => devices || step.step !== "idle-devices") : [],
+		protectedRoot: root,
+		scoped: Boolean(env.STIM_HOME),
+		projects: Object.keys(loadConfig()?.projects ?? {}).map(canonicalPath),
+		pinned,
+		recentlyUsed: (workspace) => recentUse(workspace, settings)
+	});
+	const merge = (extra) => {
+		for (const action of extra.actions) if (!result.actions.some((entry) => entry.kind === action.kind && entry.target === action.target && (entry.level === action.level || action.kind === "would-delete-devices"))) result.actions.push(action);
+		result.blocked.push(...extra.blocked);
+		result.skips.push(...extra.skips);
+	};
+	if (sweep) merge(await planSweep({
+		settings,
+		sizes,
+		protectedRoot: root,
+		pinned,
+		now: Date.now(),
+		devices,
+		operation
+	}));
+	if (worktrees) {
+		const planned = await planWorktrees({
+			protectedRoot: root,
+			pinned,
+			now: Date.now(),
+			sizes: currentSizes,
+			protectRecentMs: settings.protectRecentHours * 36e5,
+			refresh,
+			operation
+		});
+		merge(planned);
+		result.worktreeSweep = planned.sweep;
+	}
+	if (pressure) {
+		const pressured = await planPressureLevels(diskPressureLevel(lowestFree(pressure.disk), budget, settings), {
+			settings,
+			sizes: currentSizes,
+			protectedRoot: root,
+			pinned,
+			now: Date.now(),
+			refresh,
+			operation
+		});
+		merge(pressured);
+		if (pressured.pressureSweep) result.pressureSweep = pressured.pressureSweep;
+	}
+	if (low) result.skips.push(...outputs.workspaces.filter((entry) => !entry.willClear && entry.keptReason).map((entry) => ({
+		target: entry.dir,
+		reason: entry.keptReason,
+		workspace: entry.projectRoot ?? void 0
+	})));
+	return result;
+}
+async function previewMaintenance({ devices = true, refresh = true, operation } = {}) {
+	let settings;
+	try {
+		settings = resolveMaintenanceSettings(void 0, operation?.env ?? process.env);
+		const state = readMaintenanceState();
+		if (settings.invalid && settings.mode === "off") return {
+			mode: "off",
+			pressure: null,
+			actions: [],
+			blocked: [],
+			skips: [],
+			invalid: settings.invalid,
+			note: settings.invalid
+		};
+		if (settings.mode === "off") return {
+			mode: "off",
+			pressure: null,
+			actions: [],
+			blocked: [],
+			skips: [],
+			note: "maintenance.mode is off"
+		};
+		const pressure = operation ? await measurePressureAsync(settings, state?.pressure ?? null, Date.now(), operation) : measurePressure(settings, state?.pressure ?? null, Date.now());
+		return {
+			...await plannedMaintenance(pressure, state?.sizes ?? [], settings, {
+				devices,
+				sweep: true,
+				refresh,
+				operation
+			}),
+			mode: settings.mode,
+			...settings.invalid ? { invalid: settings.invalid } : {},
+			pressure,
+			note: settings.invalid ?? (state === null ? "no pass has run yet; sizes have not been measured" : null)
+		};
+	} catch (error) {
+		return {
+			mode: settings?.mode ?? "off",
+			...settings?.invalid ? { invalid: settings.invalid } : {},
+			pressure: null,
+			actions: [],
+			blocked: [String(error)],
+			skips: [],
+			note: "maintenance preview failed"
+		};
+	}
+}
+//#endregion
+//#region src/maintenance/act.ts
+function freedSince(beforeMb) {
+	const freed = lowestFree(measureDisk()) - beforeMb;
+	return Number.isFinite(freed) && freed > 0 ? Math.round(freed * 1024 * 1024) : 0;
+}
+const kept = (detail) => ({
+	status: "kept",
+	bytes: 0,
+	detail
+});
+async function quietly(run) {
+	const { log, error } = {
+		log: console.log,
+		error: console.error
+	};
+	const exitCode = process.exitCode;
+	takeGcResults();
+	console.log = () => {};
+	console.error = () => {};
+	try {
+		return {
+			value: await run(),
+			results: takeGcResults()
+		};
+	} finally {
+		console.log = log;
+		console.error = error;
+		process.exitCode = exitCode;
+		takeGcResults();
+	}
+}
+function outcomeOf(results, fallbackBytes) {
+	const failed = results.find((result) => result.status === "failed");
+	if (failed) return {
+		status: "failed",
+		bytes: 0,
+		detail: failed.detail ?? `could not process ${failed.label}`
+	};
+	const done = results.filter((result) => result.status === "done");
+	if (done.length) return {
+		status: "done",
+		bytes: done.reduce((sum, result) => sum + (result.bytes ?? 0), 0) || fallbackBytes,
+		detail: done.map((result) => result.label).join(", ")
+	};
+	return kept(results.find((result) => result.detail)?.detail ?? "nothing was eligible when the action ran");
+}
+function rootCache(dir) {
+	const name = canonicalPath(dir) === canonicalPath(buildCacheRoot()) ? "Build cache" : canonicalPath(dir) === canonicalPath(metroCacheRoot()) ? "Metro transform caches" : null;
+	return name ? {
+		name,
+		dir,
+		prune: "entries",
+		entriesDepth: name === "Build cache" ? 2 : 3,
+		note: ""
+	} : null;
+}
+function cacheOf(action) {
+	const discovered = discoverCaches();
+	if (action.dir) {
+		const dir = canonicalPath(action.dir);
+		return discovered.find((cache) => canonicalPath(cache.dir) === dir) ?? rootCache(action.dir);
+	}
+	return discovered.find((cache) => cacheLabel(cache) === action.target) ?? null;
+}
+function trimCache(action, context) {
+	const cache = cacheOf(action);
+	if (!cache) return kept("it is no longer a cache Stim may trim");
+	const [planned] = planCacheEmptying([cache], false);
+	if (!planned || planned.machineGlobal) return kept(planned?.machineGlobal ?? "it is no longer a cache Stim may trim");
+	const aged = action.olderThanDays !== void 0;
+	const result = pruneCache(cache, {
+		olderThanDays: Math.max(action.olderThanDays ?? 0, context.settings.protectRecentHours / 24),
+		byMtime: true,
+		protect: context.protect ??= cacheEntryProtection(),
+		...aged ? {} : { evictBytes: action.bytes }
+	});
+	if (result.skipped) return kept(result.skipped);
+	if (result.failed) return {
+		status: "failed",
+		bytes: result.bytes,
+		detail: `${result.failed} entries could not be removed`
+	};
+	const protectedNote = result.protectedEntries ? `; ${result.protectedEntries} protected entries kept` : "";
+	if (result.removed === 0) return kept(`no unprotected entry was old enough${protectedNote}`);
+	return {
+		status: "done",
+		bytes: result.bytes,
+		detail: `${result.removed} entries${protectedNote}`,
+		...!aged && result.bytes < action.bytes ? { shortfall: `${action.target} reached ${result.bytes} of ${action.bytes} bytes${protectedNote}` } : {}
+	};
+}
+async function emptyCompilationCache(action, context) {
+	const floor = action.level === 3 ? levelFloors(context.budget, context.settings)[3] : context.budget.hardFloorDiskMb;
+	if (!measureDisk().some((disk) => disk.freeMb < floor)) return kept(action.level === 3 ? "free disk is back above the level 3 floor, and this cache can only be emptied whole" : "free disk is above budget.hardFloorDiskGb, and this cache can only be emptied whole");
+	const dir = sharedCompilationCache();
+	const blocked = cacheBlocked({
+		name: "Swift compilation cache",
+		dir,
+		category: "compilation-cache"
+	});
+	if (blocked) return kept(blocked);
+	const cache = discoverCaches().find((candidate) => canonicalPath(candidate.dir) === canonicalPath(dir));
+	if (cache?.prune !== "atomic") return kept("it is not a registered cache Stim empties whole");
+	const [planned] = planCacheEmptying([{
+		...cache,
+		bytes: action.bytes
+	}], true);
+	const { results } = await quietly(() => emptyCaches(planned ? [planned] : []));
+	return outcomeOf(results, action.bytes);
+}
+async function clearOutputs(action, context) {
+	const root = action.workspace;
+	if (!root) return kept("the action names no workspace");
+	if (root === context.protectedRoot) return kept("the command that started this pass runs in it");
+	if (maintenancePinned(root)) return kept("pinned by maintenance.keep");
+	const recent = recentUse(root, context.settings, protectWindowMs(action, context.settings));
+	if (recent) return kept(recent);
+	const olderThan = action.olderThanDays ?? null;
+	const now = Date.now();
+	const report = collectWorkspaceOutputs({
+		olderThan,
+		now,
+		measure: false
+	});
+	const entry = report.workspaces.find((candidate) => candidate.projectRoot && canonicalPath(candidate.projectRoot) === root);
+	if (!entry) return kept("it has no build outputs any more");
+	const { results } = await quietly(() => clearWorkspaceOutputs({
+		...report,
+		workspaces: [entry]
+	}, {
+		olderThan,
+		now
+	}));
+	return outcomeOf(results, action.bytes);
+}
+async function removeWorktree(action, context) {
+	const sweep = action.level === 3 ? context.pressureSweep : context.worktreeSweep;
+	const worktree = sweep?.worktrees.find((candidate) => candidate.path === action.target);
+	if (!sweep || !worktree) return kept("it is not in this pass's worktree check");
+	const path = canonicalPath(worktree.path);
+	if (context.protectedRoot === path || context.protectedRoot.startsWith(`${path}${sep}`)) return kept("the command that started this pass runs inside it");
+	if (worktree.keys.some(maintenancePinned)) return kept("pinned by maintenance.keep");
+	const before = lowestFree(measureDisk());
+	const { results } = await quietly(() => removeWorktrees({
+		...sweep,
+		worktrees: [worktree]
+	}));
+	return outcomeOf(results, freedSince(before));
+}
+async function removeOrphan(action) {
+	const orphan = (await collectOrphanedWorkspaces(Object.keys(loadConfig$1()?.projects ?? {}), listMountedVolumes())).orphaned.find((candidate) => candidate.dir === action.target);
+	if (!orphan) return kept("it is no longer an orphaned workspace directory");
+	const { results } = await quietly(() => deleteOrphanedWorkspaces([orphan]));
+	return outcomeOf(results, orphan.bytes ?? 0);
+}
+async function deleteParkedDevice(action) {
+	if (deviceSweepIsScoped()) return kept("STIM_HOME scopes this config, and devices are machine-wide");
+	const sims = (await collectParkedSims({})).filter((sim) => sim.udid === action.target);
+	const avds = sims.length ? [] : (await collectParkedAvds({})).filter((avd) => avd.name === action.target);
+	if (!sims.length && !avds.length) return kept("it is no longer parked");
+	const before = lowestFree(measureDisk());
+	const { results } = await quietly(async () => await deleteParkedSims(sims) + await deleteParkedAvds(avds));
+	return outcomeOf(results, freedSince(before));
+}
+async function deleteOwnedDevicesOf(root, { noneIsKept = false } = {}) {
+	if (deviceSweepIsScoped()) return null;
+	const config = loadConfig$1();
+	const project = config?.projects?.[root];
+	if (!config || !project) return null;
+	const owns = (kind) => projectDeviceSlots(project).some(({ platforms }) => platforms[kind]?.owned === true);
+	let sims = [];
+	let avds = [];
+	try {
+		if (owns("ios")) sims = listAllIosSims({ timeoutMs: DEVICE_LIST_TIMEOUT_MS });
+		if (owns("android")) avds = listAvds();
+	} catch (error) {
+		return {
+			status: "failed",
+			bytes: 0,
+			detail: `its owned devices could not be listed: ${error instanceof Error ? error.message : String(error)}`
+		};
+	}
+	const devices = findStaleProjectDevices({
+		config: {
+			...config,
+			projects: { [root]: project }
+		},
+		sims,
+		avds,
+		olderThanDays: 0,
+		lastTouched: () => 0
+	});
+	if (noneIsKept && devices.length === 0) return kept("it owns no listed devices any more");
+	const failures = await deleteProjectDevices([], devices, []);
+	return failures ? {
+		status: "failed",
+		bytes: 0,
+		detail: `${failures} owned devices could not be deleted`
+	} : null;
+}
+async function stopWorkspace(action, context) {
+	const root = action.workspace ?? action.target;
+	if (root === context.protectedRoot) return kept("the command that started this pass runs in it");
+	if (maintenancePinned(root)) return kept("pinned by maintenance.keep");
+	const windowMs = protectWindowMs(action, context.settings);
+	const active = workspaceActiveReason(root, Date.now(), windowMs);
+	if (active) return kept(active);
+	const before = lowestFree(measureDisk());
+	const run = await withIdleWorkspace(root, async () => {
+		if (workspaceActiveReason(root, Date.now(), windowMs)) return kept("it became active");
+		const metro = await stopOwnedMetro(root, {
+			by: "automatic maintenance",
+			workspace: context.protectedRoot
+		});
+		if ("reason" in metro) return kept(`its dev server: ${metro.reason}`);
+		return (await quietly(() => deleteOwnedDevicesOf(root))).value;
+	}, {
+		purpose: "automatic maintenance",
+		supervisor: false
+	});
+	if (!run.ran) return kept(`in use: ${run.reasons.join("; ")}`);
+	const bytes = freedSince(before);
+	return run.value ? {
+		...run.value,
+		bytes
+	} : {
+		status: "done",
+		bytes,
+		detail: root
+	};
+}
+/**
+* Deletes the owned simulators and emulators of a workspace that stays idle for `windowMs`, under its native-run
+* claim, without stopping anything: a running dev server, lease, lock or driver keeps every device.
+*/
+async function deleteIdleWorkspaceDevices(root, { windowMs, protectedRoot, purpose }) {
+	if (root === protectedRoot) return kept("the command that started this pass runs in it");
+	if (maintenancePinned(root)) return kept("pinned by maintenance.keep");
+	if (deviceSweepIsScoped()) return kept("STIM_HOME scopes this config, and devices are machine-wide");
+	const active = workspaceActiveReason(root, Date.now(), windowMs);
+	if (active) return kept(active);
+	const before = lowestFree(measureDisk());
+	const run = await withIdleWorkspace(root, async () => workspaceActiveReason(root, Date.now(), windowMs) ? kept("it became active") : deleteOwnedDevicesOf(root, { noneIsKept: true }), { purpose });
+	if (!run.ran) return kept(`in use: ${run.reasons.join("; ")}`);
+	const bytes = freedSince(before);
+	return run.value ? {
+		...run.value,
+		bytes
+	} : {
+		status: "done",
+		bytes,
+		detail: root
+	};
+}
+function deviceWindowMs(action, context) {
+	if (action.level !== void 0) return protectWindowMs(action, context.settings);
+	if (action.olderThanDays !== void 0) return action.olderThanDays * 864e5;
+	return Math.max(context.worktreeSweep?.graceMs ?? 0, context.settings.protectRecentHours * 36e5);
+}
+async function deleteDevices(action, context) {
+	const { value } = await quietly(() => deleteIdleWorkspaceDevices(action.workspace ?? action.target, {
+		windowMs: deviceWindowMs(action, context),
+		protectedRoot: context.protectedRoot,
+		purpose: "automatic maintenance"
+	}));
+	return value;
+}
+async function clearArtifacts(action, context) {
+	return clearArtifact(action, action.kind === "would-delete-dependencies" ? "dependencies" : "build", {
+		windowMs: protectWindowMs(action, context.settings),
+		protectedRoot: context.protectedRoot,
+		pinned: maintenancePinned,
+		worktrees: context.worktrees ??= artifactWorktrees()
+	});
+}
+const GRADLE_EXIT_WAIT_MS = 3e3;
+async function stopGradleDaemonsAction(action) {
+	const targets = [...action.target.matchAll(/\d+/g)].map((match) => Number(match[0]));
+	const { value: failures, results } = await quietly(() => stopIdleGradleDaemons(targets));
+	const daemons = results.filter((result) => result.kind === "gradleDaemon" || result.kind === "kotlinDaemon");
+	const stopped = daemons.filter((result) => result.status === "done");
+	if (failures) return {
+		status: "failed",
+		bytes: 0,
+		detail: `${plural(failures, "daemon")} could not be stopped`
+	};
+	if (stopped.length === 0) return kept(daemons.find((result) => result.detail)?.detail ?? "no daemon was stopped");
+	const left = await waitForGradleExit(stopped.flatMap((result) => result.id && /^\d+$/.test(result.id) ? [Number(result.id)] : []), GRADLE_EXIT_WAIT_MS);
+	const labels = stopped.map((result) => result.label).join(", ");
+	return {
+		status: "done",
+		bytes: 0,
+		detail: left.length ? `${labels}; pid ${left.join(", ")} had not exited yet` : labels
+	};
+}
+async function deleteGradleVersionAction(action, context) {
+	const before = lowestFree(measureDisk());
+	try {
+		const result = await deleteGradleVersion(action.target, { olderThanDays: context.settings.gradleVersionIdleDays });
+		return result.deleted ? {
+			status: "done",
+			bytes: freedSince(before),
+			detail: result.detail
+		} : kept(result.detail);
+	} catch (error) {
+		return {
+			status: "failed",
+			bytes: freedSince(before),
+			detail: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+async function deleteTempLeftoversAction() {
+	const { value: done } = await quietly(() => deleteTempLeftovers());
+	if (done.failures) return {
+		status: "failed",
+		bytes: done.bytes,
+		detail: `${done.failures} could not be deleted`
+	};
+	return done.count ? {
+		status: "done",
+		bytes: done.bytes,
+		detail: `${done.count} deleted`
+	} : kept("none is idle now");
+}
+function unregisterCache(action) {
+	const dir = action.dir ?? action.target;
+	if (existsSync(dir) || !isOnMountedVolume(dir, listMountedVolumes()) || !readManifest().caches.some((c) => c.dir === dir)) return kept("it can no longer be shown to be a stale registration");
+	return unregister(dir) ? {
+		status: "done",
+		bytes: 0,
+		detail: dir
+	} : kept("it was already unregistered");
+}
+async function executeAction(action, context) {
+	switch (action.kind) {
+		case "would-clear-outputs": return clearOutputs(action, context);
+		case "would-trim-cache": return trimCache(action, context);
+		case "would-empty-cache": return emptyCompilationCache(action, context);
+		case "would-remove-worktree": return removeWorktree(action, context);
+		case "would-remove-orphan": return removeOrphan(action);
+		case "would-unregister-cache": return unregisterCache(action);
+		case "would-delete-parked-device": return deleteParkedDevice(action);
+		case "would-delete-devices": return deleteDevices(action, context);
+		case "would-stop-workspace": return action.level === 3 ? stopWorkspace(action, context) : kept("automatic maintenance stops dev servers only at disk pressure level 3");
+		case "would-clear-build-dirs":
+		case "would-delete-dependencies": return clearArtifacts(action, context);
+		case "would-stop-gradle-daemons": return stopGradleDaemonsAction(action);
+		case "would-delete-gradle-version": return deleteGradleVersionAction(action, context);
+		case "would-delete-temp-leftovers": return deleteTempLeftoversAction();
+		default: return kept("automatic maintenance does not stop devices or dev servers yet");
+	}
+}
+function diskRecovered(budget) {
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	return measureDisk().every((disk) => disk.freeMb >= floor);
+}
+//#endregion
+export { collectWorktreeSweep as _, previewMaintenance as a, worktreeRemovalReason as b, deleteTempLeftovers as c, ARTIFACT_DIRS as d, appRoots as f, candidateRootsAsync as g, ownedDeviceUsage as h, plannedMaintenance as i, tempLeftoverLines as l, measureOwnedDevices as m, diskRecovered as n, triggeringRoot as o, finishedWorkspaces as p, executeAction as r, collectTempLeftovers as s, deleteIdleWorkspaceDevices as t, tempLeftoverSection as u, removeWorktrees as v, worktreePullRequestNote as y };