stim 1.13.0 → 1.15.0

package/dist/{budget-E5o91NR1.mjs → budget-CMiqghig.mjs}

@@ -1,29 +1,35 @@
-import { B as deviceSlotPlatforms, E as withConfigLock$1, F as measuredDirectorySize, I as volumeRootFor, M as formatBytes, N as isOnMountedVolume, O as process_identity_exports, P as listMountedVolumes, U as projectDeviceSlots, _ as loadConfig$1, a as clearDevice, d as getConfigDir, g as isPathPrefix, j as directorySize, o as clearSupervisor, p as getProject } from "./config-0jCcMM0E.mjs";
-import { i as registeredCaches } from "./cache-manifest-DWPF4RKJ.mjs";
-import { C as sharedBuildCache, N as workspaceName$1, c as resolveProjectMetro, h as readWorkspaceState$1, k as workspaceDir, n as killMetroTree, y as workspaceLastUsed } from "./metro-BPeY1YMh.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { A as directorySize, D as withConfigLock$1, F as volumeRootFor, H as projectDeviceSlots, M as isOnMountedVolume, N as listMountedVolumes, P as measuredDirectorySize, _ as loadConfig$1, a as clearDevice, d as getConfigDir, g as isPathPrefix, j as formatBytes, o as clearSupervisor, p as getProject, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { i as registeredCaches } from "./cache-manifest-DnUHBJaU.mjs";
+import { b as workspaceDir, m as sharedBuildCache, r as readWorkspaceState$1, s as workspaceLastUsed, w as workspaceName$1 } from "./workspace-state-CL2V2Ons.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
-import { s as clearWorkspaceSupervisor } from "./state-DwAU2_-D.mjs";
-import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-n7tnJsI8.mjs";
-import { l as phaseLine, u as plural } from "./command-output-BIL7rlX7.mjs";
-import { i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-CL9dZf73.mjs";
-import { o as workspaceActivity } from "./activity-DfVKZTEB.mjs";
-import { F as ownedAvdDirectory, R as ownedAvdSerialResolver, at as dropParked, k as listAvds, lt as readParked, nt as isStimOwnedSim, tt as isStimOwnedAvd } from "./android-qx_31wJo.mjs";
-import { f as teardownOwnedAvd, g as teardownParkedIosSim, h as teardownParkedAvd, m as teardownOwnedIosSim, p as teardownOwnedBrowser, t as resolveSupervisorTarget } from "./ownership-PUP4Dwai.mjs";
-import { d as listIosDeviceTypes, g as parseRuntimeVersion, l as listAllIosSims } from "./ios-CmEzZiOj.mjs";
-import { c as recordGcResult, i as idleShutdownCandidates, n as collectOwnedDeviceActivity, o as shutDownIdleDevices, s as workspaceBuildInProgress, t as collectIdleDevices } from "./idle-DxLi5OkN.mjs";
-import { i as canonicalPath, n as withIdleWorkspace, r as workspaceInUse, t as emptyWorkspaceDir } from "./in-use-wYEaKQM9.mjs";
-import { c as formatSpace, r as capacity, s as environmentState } from "./status-sszP4XKU.mjs";
-import { existsSync, statSync, statfsSync } from "node:fs";
+import { l as readPidFile, s as clearWorkspaceSupervisor } from "./state-CaeaHbDA.mjs";
+import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { l as workspaceActivity, r as createDeviceProcessTables } from "./activity-B2-kb7k0.mjs";
+import { l as phaseLine, o as formatLongDuration, u as plural } from "./command-output-CliHHn7a.mjs";
+import { h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-W5Pi1q38.mjs";
+import { A as listAvds, I as ownedAvdDirectory, ft as readParked, it as isStimOwnedSim, rt as isStimOwnedAvd, st as dropParked, z as ownedAvdSerialResolver } from "./android-Db2eEMaf.mjs";
+import { l as resolveProjectMetro, r as killMetroTree } from "./metro-Di8EN2Tb.mjs";
+import { a as teardownOwnedBrowser, c as teardownParkedIosSim, i as teardownOwnedAvd, n as eraseParkedIosSim, o as teardownOwnedIosSim, s as teardownParkedAvd, t as eraseParkedAvd } from "./teardown-BYuQafiA.mjs";
+import { _ as parseRuntimeVersion, f as listIosDeviceTypes, u as listAllIosSims } from "./ios-3CtCRhwr.mjs";
+import { a as parseWatchmanPid, c as collectOwnedDeviceActivity, f as shutDownIdleDevices, i as parseWatchmanClients, m as recordGcResult, n as parseTriggerCount, p as workspaceBuildInProgress, r as parseWatchRoots, s as collectIdleDevices, t as parseSubscriberNames, u as idleShutdownCandidates } from "./watchman-Bx0wceoF.mjs";
+import { i as canonicalPath, n as withIdleWorkspace, r as workspaceInUse, t as emptyWorkspaceDir } from "./in-use-CndPMilN.mjs";
+import { n as listBuildSlots } from "./build-slots-Df1ApSuH.mjs";
+import { l as withdrawDevServerStopRequest, s as requestDevServerStop, u as resolveSupervisorTarget } from "./stop-cause-CZ_Mr-v9.mjs";
+import { a as capacity, l as environmentState, u as formatSpace } from "./status-l84Gbvp2.mjs";
+import { r as readFootprints, t as STIM_SERVER_COMMAND } from "./machine-usage-D_YYMzfR.mjs";
+import { existsSync, readFileSync, statSync, statfsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { existsSync as existsSync$1, lstatSync as lstatSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
-import { METRO_NAMED_CACHE_LAYOUT } from "@stim-cli/core";
-import { isJsonObject, readJsonFile, settingDefinition, settingValueError } from "@stim-cli/core/state";
-import { dirname as dirname$1, join as join$1, sep as sep$1 } from "node:path";
 import { homedir, tmpdir } from "os";
+import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
+import { METRO_NAMED_CACHE_LAYOUT } from "@stim-cli/core";
+import { buildWorkerRoot, isJsonObject, loadConfig, readJsonFile, settingDefinition, settingValueError } from "@stim-cli/core/state";
 import { homedir as homedir$1, platform, totalmem as totalmem$1 } from "node:os";
 import chalk from "chalk";
 //#region src/supervisor/cache-reset.ts
-async function stopOwnedMetro(root) {
+async function stopOwnedMetro(root, requester) {
 	const project = getProject(root);
 	const port = project?.metroPort;
 	const target = resolveSupervisorTarget({
@@ -44,7 +50,10 @@ async function stopOwnedMetro(root) {
 		pid: target.pid,
 		processToken: target.processToken
 	};
-	if (!killMetroTree(target.pid, target.processToken) || !await (0, process_identity_exports.waitForProcessExit)(expected, 1e4)) return {
+	requestDevServerStop(root, target.processToken, requester);
+	const signalled = killMetroTree(target.pid, target.processToken);
+	if (!signalled) withdrawDevServerStopRequest(root, target.processToken);
+	if (!signalled || !await (0, process_identity_exports.waitForProcessExit)(expected, 1e4)) return {
 		status: "stuck",
 		reason: `supervisor pid ${target.pid} did not exit`
 	};
@@ -57,7 +66,7 @@ async function stopOwnedMetro(root) {
 	return { status: "stopped" };
 }
 async function stopOwnedMetroForReset(root) {
-	const stopped = await stopOwnedMetro(root);
+	const stopped = await stopOwnedMetro(root, { by: "stim start --reset-cache" });
 	switch (stopped.status) {
 		case "unverified": throw supervisorError("STIM_SUPERVISOR_EXITED", `Cannot reset Metro: ${stopped.reason}.`, "Stop it with the tool that started it, then retry. Stim leaves unverified processes alone.");
 		case "external": throw supervisorError("STIM_SUPERVISOR_EXITED", "Cannot reset an externally started dev server.", "Stop it with the tool that started it, then retry `stim start --reset-cache`.");
@@ -68,10 +77,10 @@ async function stopOwnedMetroForReset(root) {
 //#endregion
 //#region src/cache/caches.ts
 function xcodeDerivedDataRoot() {
-	return join(homedir(), "Library", "Developer", "Xcode", "DerivedData");
+	return join$1(homedir(), "Library", "Developer", "Xcode", "DerivedData");
 }
 function compilationCache() {
-	const dir = join(xcodeDerivedDataRoot(), "CompilationCache.noindex");
+	const dir = join$1(xcodeDerivedDataRoot(), "CompilationCache.noindex");
 	if (!existsSync$1(dir)) return null;
 	return {
 		name: "Xcode compilation cache",
@@ -81,8 +90,8 @@ function compilationCache() {
 	};
 }
 function gradleBuildCache() {
-	const gradleHome = process.env.GRADLE_USER_HOME || join(homedir(), ".gradle");
-	const dir = resolve(gradleHome, "caches", "build-cache-1");
+	const gradleHome = process.env.GRADLE_USER_HOME || join$1(homedir(), ".gradle");
+	const dir = resolve$1(gradleHome, "caches", "build-cache-1");
 	if (!existsSync$1(dir)) return null;
 	return {
 		name: "Gradle build cache",
@@ -104,9 +113,9 @@ function metroFileMaps() {
 	const files = [];
 	let bytes = 0;
 	for (const n of names) try {
-		const st = statSync$1(join(root, n));
+		const st = statSync$1(join$1(root, n));
 		if (uid !== void 0 && st.uid !== uid) continue;
-		files.push(join(root, n));
+		files.push(join$1(root, n));
 		bytes += st.size;
 	} catch {}
 	if (!files.length) return null;
@@ -133,7 +142,15 @@ function discoverCaches() {
 		gradle,
 		metroFileMaps()
 	].filter((c) => Boolean(c)).map((c) => Object.assign({}, c, { source: "detected" }));
-	return mergeCacheDescriptors([...registered, ...detected], gradleDir);
+	return distinguishSharedNames(mergeCacheDescriptors([...registered, ...detected], gradleDir));
+}
+function distinguishSharedNames(caches) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const cache of caches) counts.set(cache.name, (counts.get(cache.name) ?? 0) + 1);
+	const labelled = caches.map((cache) => (counts.get(cache.name) ?? 0) < 2 ? cache : Object.assign({}, cache, { name: `${cache.name}: ${basename$1(cache.dir) || cache.dir}` }));
+	const labels = /* @__PURE__ */ new Map();
+	for (const cache of labelled) labels.set(cache.name, (labels.get(cache.name) ?? 0) + 1);
+	return labelled.map((cache, i) => (labels.get(cache.name) ?? 0) < 2 || cache === caches[i] ? cache : Object.assign({}, cache, { name: `${caches[i].name}: ${cache.dir}` }));
 }
 function suppressLegacyMetroAncestors(caches) {
 	const current = caches.filter(isCurrentMetroStore);
@@ -165,7 +182,7 @@ function isMetroStore(cache) {
 function isNamedMetroChild(parent, candidate) {
 	const dir = canonicalCacheDir(parent);
 	const child = canonicalCacheDir(candidate);
-	return dirname(child) === dir || canonicalCacheDir(dirname(candidate)) === dir;
+	return dirname$1(child) === dir || canonicalCacheDir(dirname$1(candidate)) === dir;
 }
 function mergeCacheDescriptors(caches, gradleDir) {
 	const merged = [];
@@ -216,14 +233,14 @@ function cachePathsOverlap(left, right) {
 	return cachePathContains(left, right) || cachePathContains(right, left);
 }
 function cachePathContains(parent, child) {
-	const rel = relative(parent, child);
-	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+	const rel = relative$1(parent, child);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute$1(rel);
 }
 function canonicalCacheDir(dir) {
 	try {
 		return realpathSync$1(dir);
 	} catch {
-		return resolve(dir);
+		return resolve$1(dir);
 	}
 }
 function sizeCaches(caches) {
@@ -285,13 +302,890 @@ function entriesAtDepth(dir, depth) {
 			} catch {
 				continue;
 			}
-			for (const name of names) next.push(join(parent, name));
+			for (const name of names) next.push(join$1(parent, name));
 		}
 		level = next;
 	}
 	return level;
 }
 //#endregion
+//#region src/commands/gc/progress.ts
+function phase(label, text) {
+	console.error(chalk.dim(phaseLine(label, text)));
+}
+//#endregion
+//#region src/commands/gc/memory.ts
+const WATCHMAN_KIND = "watchman";
+const GRADLE_DAEMONS_KIND = "gradle-daemons";
+/** The memory kind `--cache` names, or null for any other name. */
+function memoryCacheKind(cache) {
+	const wanted = cache?.trim().toLowerCase();
+	return wanted === "watchman" || wanted === "gradle-daemons" ? wanted : null;
+}
+/** Which helpers a gc run inspects: both without --cache, one for its own kind, none for any other --cache. */
+function memoryScope(cache) {
+	if (!cache?.trim()) return {
+		watchman: true,
+		gradle: true
+	};
+	const kind = memoryCacheKind(cache);
+	return kind ? {
+		watchman: kind === WATCHMAN_KIND,
+		gradle: kind === GRADLE_DAEMONS_KIND
+	} : null;
+}
+const WATCHMAN_TIMEOUT_MS = 5e3;
+const WATCHMAN_DOCTOR_BYTES = 2 * 1024 ** 3;
+const GRADLE_STATUS_TIMEOUT_MS = 2e4;
+const GRADLE_STOP_TIMEOUT_MS = 6e4;
+const LSOF_TIMEOUT_MS = 1e4;
+const ROOT_PROBES_AT_ONCE = 4;
+const GRADLE_DAEMON_CLASS = /\borg\.gradle\.launcher\.daemon\.bootstrap\.GradleDaemon\s+(\S+)/;
+const KOTLIN_DAEMON_CLASS = /^\S.*?\/bin\/java\s.*\sorg\.jetbrains\.kotlin\.daemon\.KotlinCompileDaemon(\s|$)/;
+/**
+* The Gradle version, Java home and distribution of a `GradleDaemon` process from its command line. The
+* distribution is the directory whose `lib/` holds the daemon's main jar (`gradle-daemon-main-<v>.jar`, or
+* `gradle-launcher-<v>.jar` before Gradle 8.13), so `<distribution>/bin/gradle` is the daemon's own launcher.
+*/
+function parseGradleDaemonCommand(command) {
+	const version = GRADLE_DAEMON_CLASS.exec(command)?.[1];
+	const java = /^(\/.*?)\/bin\/java\s/.exec(command)?.[1];
+	if (!version || !java) return null;
+	const jar = /(?:^|\s)-(?:cp|classpath)\s+(?:[^\s]*:)?(\/.*?\/lib\/gradle-(?:daemon-main|launcher)-[^/\s:]+\.jar)(?=[\s:])/.exec(command)?.[1];
+	return {
+		version,
+		javaHome: java,
+		distribution: jar ? dirname(dirname(jar)) : null
+	};
+}
+function isKotlinDaemonCommand(command) {
+	return KOTLIN_DAEMON_CLASS.test(command) && !GRADLE_DAEMON_CLASS.test(command);
+}
+/**
+* The offload client whose Gradle home under `workerRoot` a daemon uses: named by its classpath, as stim-server
+* matches it, or by the Gradle home it runs in.
+*/
+function offloadClientOf(command, workerRoot, gradleHome) {
+	const root = resolve(workerRoot).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const home = new RegExp(`${root}/([^/\\s]+)/cache/gradle(/|$)`);
+	return home.exec(command)?.[1] ?? (gradleHome ? home.exec(gradleHome)?.[1] ?? null : null);
+}
+/** `gradle --status` rows: the state of each daemon pid it lists, lowercased (idle, busy, stopped, ...). */
+function parseGradleStatus(output) {
+	const states = /* @__PURE__ */ new Map();
+	for (const line of output.split("\n")) {
+		const match = /^\s*(\d+)\s+([A-Z][A-Z_]*)\s+\S/.exec(line);
+		if (match) states.set(Number(match[1]), match[2].toLowerCase());
+	}
+	return states;
+}
+/** `lsof -F pnT` output: each pid's open file names and its ESTABLISHED TCP connections. */
+function parseLsof(output) {
+	const processes = /* @__PURE__ */ new Map();
+	let current = null;
+	let name = null;
+	for (const line of output.split("\n")) if (line.startsWith("p")) {
+		const pid = Number(line.slice(1));
+		current = processes.get(pid) ?? {
+			files: [],
+			connections: []
+		};
+		processes.set(pid, current);
+	} else if (current && line.startsWith("n")) {
+		name = line.slice(1);
+		current.files.push(name);
+	} else if (current && name?.includes("->") && line === "TST=ESTABLISHED") current.connections.push(name);
+	return processes;
+}
+/**
+* The process at the other end of each of `pid`'s connections, found among the other processes lsof listed by the
+* reversed `remote->local` name; null for a peer lsof did not list.
+*/
+function connectionPeers(pid, lsof) {
+	return (lsof.get(pid)?.connections ?? []).map((connection) => {
+		const [local, remote] = connection.split("->");
+		const reversed = `${remote}->${local}`;
+		for (const [other, entry] of lsof) if (other !== pid && entry.connections.includes(reversed)) return other;
+		return null;
+	});
+}
+/** The Gradle user home a daemon runs in: the one whose `daemon/<version>/daemon-<pid>.out.log` it holds open. */
+function gradleHomeFromFiles(pid, version, files) {
+	const suffix = `/daemon/${version}/daemon-${pid}.out.log`;
+	const log = files.find((file) => file.endsWith(suffix));
+	return log ? log.slice(0, -suffix.length) : null;
+}
+const fsProbe = {
+	exists: existsSync,
+	isFile(path) {
+		try {
+			return statSync(path).isFile();
+		} catch {
+			return false;
+		}
+	},
+	read(path) {
+		try {
+			return readFileSync(path, "utf8");
+		} catch {
+			return null;
+		}
+	},
+	mounted: (path) => isOnMountedVolume(path)
+};
+/**
+* Why a watch root is stale: its directory is gone from a mounted volume, or the nearest `.git` above it is a
+* linked worktree's `.git` file whose gitdir no longer exists (git pruned the worktree and left the directory).
+* Null when it is live or when that cannot be proven, such as a path on a volume that is not mounted.
+*/
+function watchmanRootStaleness(path, probe = fsProbe) {
+	if (!probe.exists(path)) return probe.mounted(path) ? "missing" : null;
+	for (let dir = path;; dir = dirname(dir)) {
+		const git = join(dir, ".git");
+		if (probe.exists(git)) {
+			if (!probe.isFile(git)) return null;
+			const target = /^gitdir:\s*(.+?)\s*$/m.exec(probe.read(git) ?? "")?.[1];
+			if (!target) return null;
+			const gitdir = isAbsolute(target) ? target : resolve(dir, target);
+			return probe.exists(gitdir) || !probe.mounted(gitdir) ? null : "pruned-worktree";
+		}
+		if (dirname(dir) === dir) return null;
+	}
+}
+function staleText(stale) {
+	return stale === "missing" ? "its directory is gone" : "its linked worktree was pruned";
+}
+function planWatchmanRoot(root) {
+	const subscriptions = root.subscribers?.length ?? null;
+	const base = {
+		path: root.path,
+		stale: root.stale,
+		subscriptions,
+		triggers: root.triggers
+	};
+	if (root.stale === null) return {
+		...base,
+		removable: false,
+		detail: null
+	};
+	const kept = subscriptions === null ? "could not list its subscriptions" : subscriptions > 0 ? `${subscriptions} subscription(s) still use it` : root.triggers === null ? "could not list its triggers" : root.triggers > 0 ? `it has ${root.triggers} trigger(s)` : null;
+	return {
+		...base,
+		removable: kept === null,
+		detail: kept ? `${staleText(root.stale)}, but ${kept}` : staleText(root.stale)
+	};
+}
+/**
+* Decides the watchman roots gc removes and whether it may shut the daemon down. A stale root goes only while no
+* subscription or trigger uses it. The daemon goes only when `debug-status` lists no client besides gc's own call and
+* every root's subscriptions and triggers could be read, no kept root has a trigger, and no root has a subscription;
+* `describeClient` names each client that keeps it.
+*/
+function planWatchman(facts, describeClient) {
+	const roots = (facts.roots ?? []).map(planWatchmanRoot);
+	const unreadRoots = facts.roots === null || roots.some((root) => root.subscriptions === null || root.triggers === null);
+	const triggered = roots.filter((root) => !root.removable && (root.triggers ?? 0) > 0);
+	let reason = null;
+	let detail = null;
+	if (facts.clients === null || unreadRoots) {
+		reason = "unknown";
+		detail = facts.clients === null ? "watchman debug-status did not list its clients" : "could not list the subscriptions and triggers of every root";
+	} else if (facts.clients.length > 0) {
+		reason = "in-use";
+		detail = `used by ${[...new Set(facts.clients.map(describeClient))].join(", ")}; shutting it down would break their file watching`;
+	} else if (roots.some((root) => !root.removable && (root.subscriptions ?? 0) > 0)) {
+		reason = "in-use";
+		detail = "a root still has a subscription";
+	} else if (triggered.length > 0) {
+		reason = "in-use";
+		detail = `${triggered.map((root) => root.path).join(", ")} ha${triggered.length === 1 ? "s" : "ve"} triggers that stop firing while watchman is down`;
+	}
+	return {
+		process: {
+			kind: "watchman",
+			cacheKind: WATCHMAN_KIND,
+			pid: facts.pid,
+			startedAt: facts.startedAt,
+			bytes: facts.bytes,
+			measure: facts.measure,
+			version: null,
+			gradleHome: null,
+			offloadClient: null,
+			state: reason === "in-use" ? "busy" : reason === "unknown" ? "unknown" : "idle",
+			reclaimable: reason === null,
+			reason,
+			detail
+		},
+		roots
+	};
+}
+/**
+* Decides which Gradle and Kotlin daemons gc may stop. A running Stim build (`buildRunning`) keeps every one. An
+* offload worker's daemon is left to stim-server while it runs. A Gradle daemon goes only when its own `gradle
+* --status` says IDLE. A Kotlin daemon goes only when every Gradle daemon is idle and each of its connections comes from
+* a Gradle daemon gc stops in the same run.
+*/
+function planDaemons({ gradle, kotlin, buildRunning, stimServerRunning }) {
+	const plans = [];
+	const gradleBusy = gradle.some((daemon) => !("state" in daemon.status) || daemon.status.state !== "idle");
+	for (const daemon of gradle) {
+		const state = "state" in daemon.status ? daemon.status.state : null;
+		const idle = state === "idle";
+		let reason = null;
+		let detail = null;
+		if (daemon.offloadClient !== null && stimServerRunning) {
+			reason = "stim-server";
+			detail = `stim-server stops the daemons of offload client ${daemon.offloadClient} when that client loses build or memory runs low`;
+		} else if (buildRunning) {
+			reason = "build-running";
+			detail = buildRunning;
+		} else if (state === "busy") {
+			reason = "busy";
+			detail = "a build is using it";
+		} else if (!idle) {
+			reason = "unknown";
+			detail = "unknown" in daemon.status ? daemon.status.unknown : `gradle --status reports it ${state}`;
+		}
+		plans.push({
+			kind: "gradleDaemon",
+			cacheKind: GRADLE_DAEMONS_KIND,
+			pid: daemon.pid,
+			startedAt: daemon.startedAt,
+			bytes: daemon.bytes,
+			measure: daemon.measure,
+			version: daemon.command.version,
+			gradleHome: daemon.gradleHome,
+			offloadClient: daemon.offloadClient,
+			state: idle ? "idle" : state === "busy" ? "busy" : "unknown",
+			reclaimable: reason === null,
+			reason,
+			detail
+		});
+	}
+	const stopping = new Set(plans.filter((plan) => plan.reclaimable).map((plan) => plan.pid));
+	for (const daemon of kotlin) {
+		const clients = daemon.peers?.filter((peer) => peer === null || !stopping.has(peer)) ?? [];
+		let reason = null;
+		let detail = null;
+		if (buildRunning) {
+			reason = "build-running";
+			detail = buildRunning;
+		} else if (daemon.peers === null) {
+			reason = "unknown";
+			detail = "lsof could not list its connections";
+		} else if (gradleBusy) {
+			reason = "busy";
+			detail = "a Gradle daemon is busy or its state is unknown, and it may be compiling through this one";
+		} else if (clients.length > 0) {
+			reason = "busy";
+			detail = `${clients.length} connection(s) from a process gc does not stop are open`;
+		}
+		plans.push({
+			kind: "kotlinDaemon",
+			cacheKind: GRADLE_DAEMONS_KIND,
+			pid: daemon.pid,
+			startedAt: daemon.startedAt,
+			bytes: daemon.bytes,
+			measure: daemon.measure,
+			version: null,
+			gradleHome: null,
+			offloadClient: null,
+			state: reason === null ? "idle" : reason === "unknown" ? "unknown" : "busy",
+			reclaimable: reason === null,
+			reason,
+			detail
+		});
+	}
+	return plans;
+}
+/**
+* Why no Gradle or Kotlin daemon may be stopped now, or null. An Android build lock, or a build slot that no live iOS
+* build lock of the same process holds, counts as a running build; one whose holder is unresolved counts too.
+*/
+function runningBuild(locks, slots) {
+	const android = locks.find((lock) => lock.platform === "android" && (lock.alive || lock.unresolved));
+	if (android) return `${android.unresolved ? "an unresolved" : "a running"} Android build holds ${android.path} (pid ${android.pid ?? "?"}, ${android.projectRoot || "unrecorded workspace"})`;
+	const ios = new Set(locks.filter((lock) => lock.platform === "ios" && lock.alive).map((lock) => lock.pid));
+	const slot = slots.find((s) => (s.alive || s.unresolved) && !(s.alive && s.pid !== null && ios.has(s.pid)));
+	if (slot) return `${slot.unresolved ? "an unresolved" : "a running"} build holds build slot ${slot.index ?? "?"} (pid ${slot.pid ?? "?"}, ${slot.projectRoot || "unrecorded workspace"})`;
+	return null;
+}
+/** A watchman client's pid resolved to the Stim workspace whose supervisor it is or descends from. */
+function stimWorkspaceOf(pid, parentOf, supervisors) {
+	let current = pid;
+	for (let depth = 0; current !== void 0 && current > 1 && depth < 64; depth++) {
+		const workspace = supervisors.get(current);
+		if (workspace) return workspace;
+		current = parentOf.get(current);
+	}
+	return null;
+}
+function reclaimableBytes(report, kind) {
+	return report.processes.filter((entry) => entry.reclaimable && (kind === void 0 || entry.cacheKind === kind)).reduce((sum, entry) => sum + entry.bytes, 0);
+}
+const boundWatchman = async (args) => {
+	const answer = JSON.parse(await getExecutor().runFileAsync("watchman", ["--no-spawn", ...args], { timeoutMs: WATCHMAN_TIMEOUT_MS }));
+	const error = answer?.error;
+	if (error !== void 0) throw new Error(String(error));
+	return answer;
+};
+async function quietly(fn) {
+	try {
+		return await fn();
+	} catch {
+		return null;
+	}
+}
+/**
+* `watchman debug-status` with gc's own call left out of its clients. The call is spawned directly so its pid is
+* known: debug-status lists the asking CLI as a client too.
+*/
+function watchmanClients() {
+	return new Promise((done) => {
+		let child;
+		try {
+			child = getExecutor().spawn("watchman", ["--no-spawn", "debug-status"], { stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			] });
+		} catch {
+			done(null);
+			return;
+		}
+		const self = child.pid;
+		const chunks = [];
+		const timer = setTimeout(() => child.kill("SIGTERM"), WATCHMAN_TIMEOUT_MS);
+		child.stdout?.on("data", (chunk) => chunks.push(chunk));
+		child.on("error", () => {
+			clearTimeout(timer);
+			done(null);
+		});
+		child.on("close", (status) => {
+			clearTimeout(timer);
+			let clients = null;
+			try {
+				if (status === 0 && self !== void 0) clients = parseWatchmanClients(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+			} catch {}
+			done(clients ? clients.filter((client) => client.pid !== self) : null);
+		});
+	});
+}
+async function collectWatchmanRoots(pid, progress) {
+	const watchman = boundWatchman;
+	const paths = parseWatchRoots(await quietly(() => watchman(["watch-list"])));
+	if (!paths) return null;
+	if (progress) phase("daemons", `watchman pid ${pid}: checking ${plural(paths.length, "root")}`);
+	const roots = [];
+	let next = 0;
+	const probe = async () => {
+		while (next < paths.length) {
+			const index = next++;
+			const path = paths[index];
+			const [subscriptions, triggers] = await Promise.all([quietly(() => watchman(["debug-get-subscriptions", path])), quietly(() => watchman(["trigger-list", path]))]);
+			roots[index] = {
+				path,
+				stale: watchmanRootStaleness(path),
+				subscribers: parseSubscriberNames(subscriptions),
+				triggers: parseTriggerCount(triggers)
+			};
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(ROOT_PROBES_AT_ONCE, paths.length) }, probe));
+	return roots;
+}
+function measureOf(pid, rows, footprints) {
+	const footprint = footprints?.get(pid);
+	if (footprint !== void 0) return {
+		bytes: footprint,
+		measure: "footprint"
+	};
+	return {
+		bytes: (rows.get(pid)?.rssKb ?? 0) * 1024,
+		measure: "rss"
+	};
+}
+function supervisorPids() {
+	const supervisors = /* @__PURE__ */ new Map();
+	for (const root of Object.keys(loadConfig()?.projects ?? {})) {
+		const pid = readPidFile(root);
+		if (pid) supervisors.set(pid, root);
+	}
+	return supervisors;
+}
+async function readLsof(pids) {
+	if (pids.length === 0) return /* @__PURE__ */ new Map();
+	try {
+		return parseLsof(await getExecutor().runFileAsync("lsof", [
+			"-n",
+			"-P",
+			"-F",
+			"pnT",
+			"-p",
+			pids.join(",")
+		], { timeoutMs: LSOF_TIMEOUT_MS }));
+	} catch (error) {
+		const { status, signal: killed, stdout } = error;
+		return status === 1 && !killed && typeof stdout === "string" && stdout ? parseLsof(stdout) : null;
+	}
+}
+async function gradleStatus(command, home) {
+	if (!command.distribution) return { unknown: "could not find its Gradle distribution on its classpath" };
+	const launcher = join(command.distribution, "bin", "gradle");
+	if (!existsSync(launcher)) return { unknown: `its distribution has no ${launcher}` };
+	try {
+		return parseGradleStatus(await getExecutor().runFileAsync(launcher, [
+			"--status",
+			"-q",
+			"-g",
+			home
+		], {
+			cwd: home,
+			env: { JAVA_HOME: command.javaHome },
+			omitEnv: ["GRADLE_OPTS", "JAVA_OPTS"],
+			timeoutMs: GRADLE_STATUS_TIMEOUT_MS
+		}));
+	} catch (error) {
+		return { unknown: `gradle --status failed: ${error.message.split("\n")[0]}` };
+	}
+}
+function groupKey(command, home) {
+	return JSON.stringify([
+		home,
+		command.version,
+		command.distribution,
+		command.javaHome
+	]);
+}
+async function collectGradleFacts(rows, byPid, footprints, stimServerRunning, progress) {
+	const gradleRows = rows.flatMap((row) => {
+		const command = parseGradleDaemonCommand(row.command);
+		return command ? [{
+			row,
+			command
+		}] : [];
+	});
+	const kotlinRows = rows.filter((row) => isKotlinDaemonCommand(row.command));
+	if (gradleRows.length === 0 && kotlinRows.length === 0) return {
+		gradle: [],
+		kotlin: []
+	};
+	if (progress) phase("daemons", `checking ${plural(gradleRows.length, "Gradle daemon")} and ${plural(kotlinRows.length, "Kotlin daemon")}`);
+	const lsof = await readLsof([...gradleRows.map(({ row }) => row.pid), ...kotlinRows.map((row) => row.pid)]);
+	const workerRoot = buildWorkerRoot();
+	const homes = gradleRows.map(({ row, command }) => {
+		const files = lsof?.get(row.pid)?.files;
+		return files ? gradleHomeFromFiles(row.pid, command.version, files) : null;
+	});
+	const offload = gradleRows.map(({ row }, index) => offloadClientOf(row.command, workerRoot, homes[index] ?? null));
+	const statuses = /* @__PURE__ */ new Map();
+	gradleRows.forEach(({ command }, index) => {
+		const home = homes[index];
+		if (offload[index] !== null && stimServerRunning) return;
+		if (home && !statuses.has(groupKey(command, home))) {
+			if (progress) phase("daemons", `gradle --status for Gradle ${command.version} in ${home}`);
+			statuses.set(groupKey(command, home), gradleStatus(command, home));
+		}
+	});
+	const gradle = [];
+	for (const [index, { row, command }] of gradleRows.entries()) {
+		const home = homes[index] ?? null;
+		let status;
+		if (offload[index] !== null && stimServerRunning) status = { unknown: "stim-server manages it" };
+		else if (!home) status = { unknown: lsof ? "could not find its Gradle user home among its open files" : "lsof failed" };
+		else {
+			const states = await statuses.get(groupKey(command, home));
+			if (states instanceof Map) {
+				const state = states.get(row.pid);
+				status = state ? { state } : { unknown: "gradle --status did not list it" };
+			} else status = states;
+		}
+		gradle.push({
+			pid: row.pid,
+			startedAt: row.startedAt,
+			...measureOf(row.pid, byPid, footprints),
+			command,
+			gradleHome: home,
+			offloadClient: offload[index] ?? null,
+			status
+		});
+	}
+	return {
+		gradle,
+		kotlin: kotlinRows.map((row) => Object.assign(measureOf(row.pid, byPid, footprints), {
+			pid: row.pid,
+			startedAt: row.startedAt,
+			peers: lsof?.get(row.pid) ? connectionPeers(row.pid, lsof) : null
+		}))
+	};
+}
+async function collectWatchmanFacts(byPid, footprints, progress) {
+	const pid = parseWatchmanPid(await quietly(() => boundWatchman(["get-pid"])));
+	if (pid === null) return null;
+	const roots = await collectWatchmanRoots(pid, progress);
+	const clients = (await watchmanClients())?.filter((client) => client.pid !== pid) ?? null;
+	return {
+		pid,
+		startedAt: byPid.get(pid)?.startedAt ?? null,
+		...measureOf(pid, byPid, footprints),
+		roots,
+		clients
+	};
+}
+function watchmanClientDescriber(rows) {
+	const parentOf = new Map(rows.map((row) => [row.pid, row.ppid]));
+	const supervisors = supervisorPids();
+	return (client) => {
+		const workspace = stimWorkspaceOf(client.pid, parentOf, supervisors);
+		return workspace ? `the Stim workspace ${workspace}` : `${client.name ?? "a client"} (pid ${client.pid})`;
+	};
+}
+function memorySweepIsScoped() {
+	return Boolean(process.env.STIM_HOME);
+}
+/** The report of a run whose STIM_HOME is set: the helpers are machine-global, so none is inspected or stopped. */
+function scopedMemoryReport() {
+	return {
+		processes: [],
+		watchmanRoots: [],
+		notices: ["memory sweep skipped: STIM_HOME scopes this config, but watchman and the Gradle and Kotlin daemons are machine-global"]
+	};
+}
+async function collectMemoryReport(scope, progress = false) {
+	const report = {
+		processes: [],
+		watchmanRoots: [],
+		notices: []
+	};
+	if (process.platform === "win32") return report;
+	const rows = createDeviceProcessTables().host();
+	if (rows === null) {
+		report.notices.push("memory sweep skipped: ps did not answer");
+		return report;
+	}
+	const byPid = new Map(rows.map((row) => [row.pid, row]));
+	const footprints = await readFootprints();
+	if (scope.watchman) {
+		const facts = await collectWatchmanFacts(byPid, footprints, progress);
+		if (facts) {
+			const plan = planWatchman(facts, watchmanClientDescriber(rows));
+			report.processes.push(plan.process);
+			report.watchmanRoots = plan.roots;
+		} else if (!scope.gradle) report.notices.push("no watchman daemon answered");
+	}
+	if (scope.gradle) {
+		const stimServerRunning = rows.some((row) => STIM_SERVER_COMMAND.test(row.command));
+		const facts = await collectGradleFacts(rows, byPid, footprints, stimServerRunning, progress);
+		report.processes.push(...planDaemons({
+			...facts,
+			buildRunning: facts.gradle.length || facts.kotlin.length ? runningBuild(listBuildLocks(), listBuildSlots()) : null,
+			stimServerRunning
+		}));
+		if (!scope.watchman && report.processes.length === 0) report.notices.push("no Gradle or Kotlin daemon is running");
+	}
+	return report;
+}
+function processLabel(entry) {
+	if (entry.kind === "watchman") return `watchman pid ${entry.pid}`;
+	if (entry.kind === "kotlinDaemon") return `Kotlin compile daemon pid ${entry.pid}`;
+	const where = entry.offloadClient ? `offload client ${entry.offloadClient}` : entry.gradleHome ?? "unknown Gradle home";
+	return `Gradle ${entry.version ?? "?"} daemon pid ${entry.pid} (${where})`;
+}
+function uptime(startedAt, now) {
+	const at = startedAt ? Date.parse(startedAt) : NaN;
+	return Number.isFinite(at) ? `up ${formatLongDuration(Math.max(0, now - at))}` : "uptime unknown";
+}
+function memoryLines(report, scoped, now = Date.now()) {
+	if (!report || report.processes.length === 0 && report.notices.length === 0) return [];
+	const lines = [`Memory (${report.processes.some((entry) => entry.measure === "rss") ? "footprint, resident size where unreadable" : "physical footprint"}) - shared helpers that grow while they run; only --cache watchman or gradle-daemons stops them:`];
+	for (const entry of report.processes) {
+		const state = entry.reclaimable ? "idle" : entry.kind === "watchman" && entry.state === "busy" ? "in use" : entry.state;
+		lines.push(`  ${processLabel(entry)} ${formatBytes(entry.bytes)}, ${uptime(entry.startedAt, now)}, ${state}`);
+		if (entry.kind === "watchman") {
+			const stale = report.watchmanRoots.filter((root) => root.stale !== null).length;
+			lines.push(`              ${report.watchmanRoots.length} root(s), ${stale} stale`);
+			for (const root of report.watchmanRoots.filter((r) => r.stale !== null)) lines.push(`              stale root ${root.path}: ${root.detail}${root.removable ? "" : "; kept"}`);
+		}
+		if (entry.detail) lines.push(`              ${entry.reclaimable ? "" : "kept: "}${entry.detail}`);
+	}
+	for (const notice of report.notices) lines.push(`  ${notice}`);
+	const kinds = scoped ? [scoped] : [WATCHMAN_KIND, GRADLE_DAEMONS_KIND];
+	const parts = [];
+	for (const kind of kinds) {
+		if (!report.processes.some((entry) => entry.cacheKind === kind)) continue;
+		const roots = kind === "watchman" ? report.watchmanRoots.filter((root) => root.removable).length : 0;
+		const note = roots ? ` (and ${roots} stale root(s) removed)` : "";
+		parts.push(`${formatBytes(reclaimableBytes(report, kind))} with stim gc --delete --cache ${kind}${note}`);
+	}
+	if (parts.length) lines.push(`  reclaimable ${formatBytes(reclaimableBytes(report))}: ${parts.join("; ")}`);
+	return lines;
+}
+function sameProcess(entry, rows) {
+	const row = rows?.get(entry.pid);
+	return Boolean(row && entry.startedAt !== null && row.startedAt === entry.startedAt);
+}
+function signal(pid) {
+	try {
+		process.kill(pid, "SIGTERM");
+		return null;
+	} catch (error) {
+		return error.code === "ESRCH" ? null : error.message;
+	}
+}
+function keep(entry, kind, detail) {
+	console.log(chalk.yellow(`Kept ${processLabel(entry)}: ${detail}`));
+	recordGcResult(kind, "kept", processLabel(entry), {
+		id: String(entry.pid),
+		bytes: entry.bytes,
+		detail
+	});
+}
+async function reclaimWatchman(before) {
+	let failures = 0;
+	const fresh = await collectMemoryReport({
+		watchman: true,
+		gradle: false
+	}, true);
+	const daemon = fresh.processes.find((entry) => entry.kind === "watchman");
+	const planned = before.processes.find((entry) => entry.kind === "watchman");
+	if (!daemon || !planned || daemon.pid !== planned.pid) {
+		if (planned) keep(planned, "watchman", "the daemon changed or stopped since the report");
+		return 0;
+	}
+	for (const root of fresh.watchmanRoots.filter((r) => r.stale !== null)) {
+		if (!root.removable) {
+			console.log(chalk.yellow(`Kept the watchman root ${root.path}: ${root.detail}`));
+			recordGcResult("watchmanRoot", "kept", root.path, { detail: root.detail });
+			continue;
+		}
+		try {
+			phase("daemons", `removing stale watchman root ${root.path}`);
+			await boundWatchman(["watch-del", root.path]);
+			console.log(chalk.green(`Removed the stale watchman root ${root.path} (${root.detail})`));
+			recordGcResult("watchmanRoot", "done", root.path, { detail: root.detail });
+		} catch (error) {
+			failures++;
+			console.log(chalk.red(`Could not remove the watchman root ${root.path}: ${error.message}`));
+			recordGcResult("watchmanRoot", "failed", root.path, { detail: error.message });
+		}
+	}
+	const current = (await collectMemoryReport({
+		watchman: true,
+		gradle: false
+	}, true)).processes.find((entry) => entry.kind === "watchman");
+	if (!current || current.pid !== daemon.pid) return failures;
+	if (!current.reclaimable) {
+		keep(current, "watchman", current.detail ?? "it could not be proven unused");
+		return failures;
+	}
+	try {
+		phase("daemons", `shutting down watchman pid ${current.pid}: no client uses it`);
+		await boundWatchman(["shutdown-server"]);
+		console.log(chalk.green(`Shut down watchman pid ${current.pid}, freeing ${formatBytes(current.bytes)}; the next client that needs it starts it again`));
+		recordGcResult("watchman", "done", processLabel(current), {
+			id: String(current.pid),
+			bytes: current.bytes
+		});
+	} catch (error) {
+		failures++;
+		console.log(chalk.red(`Could not shut down watchman pid ${current.pid}: ${error.message}`));
+		recordGcResult("watchman", "failed", processLabel(current), {
+			id: String(current.pid),
+			bytes: current.bytes,
+			detail: error.message
+		});
+	}
+	return failures;
+}
+function stopKotlin(entry, rows) {
+	if (!sameProcess(entry, rows)) {
+		keep(entry, "kotlinDaemon", "the process changed or exited since the check");
+		return 0;
+	}
+	const error = signal(entry.pid);
+	if (error) {
+		console.log(chalk.red(`Could not stop ${processLabel(entry)}: ${error}`));
+		recordGcResult("kotlinDaemon", "failed", processLabel(entry), {
+			id: String(entry.pid),
+			bytes: entry.bytes,
+			detail: error
+		});
+		return 1;
+	}
+	console.log(chalk.green(`Stopped ${processLabel(entry)}, freeing ${formatBytes(entry.bytes)}`));
+	recordGcResult("kotlinDaemon", "done", processLabel(entry), {
+		id: String(entry.pid),
+		bytes: entry.bytes
+	});
+	return 0;
+}
+/**
+* Stops the Gradle daemons a fresh check still finds idle. When every daemon `gradle --status` lists for a home and
+* version is one of them, the daemon's own `gradle --stop` runs for that home; otherwise each idle one gets SIGTERM,
+* because `--stop` also stops the busy daemons of that home and version.
+*/
+async function stopGradle(idle, rows) {
+	let failures = 0;
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of idle) {
+		const command = parseGradleDaemonCommand(rows?.get(entry.pid)?.command ?? "");
+		if (!command || !entry.gradleHome || !sameProcess(entry, rows)) {
+			keep(entry, "gradleDaemon", "the process changed or exited since the check");
+			continue;
+		}
+		const key = groupKey(command, entry.gradleHome);
+		groups.set(key, [...groups.get(key) ?? [], entry]);
+	}
+	for (const [key, entries] of groups) {
+		const [home, , distribution, javaHome] = JSON.parse(key);
+		const command = parseGradleDaemonCommand(rows.get(entries[0].pid).command);
+		const building = runningBuild(listBuildLocks(), listBuildSlots());
+		if (building) {
+			for (const entry of entries) keep(entry, "gradleDaemon", building);
+			continue;
+		}
+		phase("daemons", `gradle --status for Gradle ${command.version} in ${home}`);
+		let states = await gradleStatus(command, home);
+		let current = hostRows();
+		const listed = states instanceof Map ? [...states].filter(([, state]) => state !== "stopped") : [];
+		if (distribution !== null && listed.length > 0 && listed.every(([pid, state]) => state === "idle" && entries.some((entry) => entry.pid === pid))) try {
+			phase("daemons", `gradle --stop for Gradle ${command.version} in ${home}`);
+			await getExecutor().runFileAsync(join(distribution, "bin", "gradle"), [
+				"--stop",
+				"-q",
+				"-g",
+				home
+			], {
+				cwd: home,
+				env: { JAVA_HOME: javaHome },
+				omitEnv: ["GRADLE_OPTS", "JAVA_OPTS"],
+				timeoutMs: GRADLE_STOP_TIMEOUT_MS
+			});
+			for (const entry of entries) {
+				console.log(chalk.green(`Stopped ${processLabel(entry)} with gradle --stop, freeing ${formatBytes(entry.bytes)}`));
+				recordGcResult("gradleDaemon", "done", processLabel(entry), {
+					id: String(entry.pid),
+					bytes: entry.bytes
+				});
+			}
+			continue;
+		} catch (error) {
+			console.log(chalk.dim(`gradle --stop failed for ${home}; signalling each idle daemon: ${error.message.split("\n")[0]}`));
+			states = await gradleStatus(command, home);
+			current = hostRows();
+		}
+		for (const entry of entries) {
+			const state = states instanceof Map ? states.get(entry.pid) : void 0;
+			if (!sameProcess(entry, current)) {
+				keep(entry, "gradleDaemon", "the process changed or exited since the check");
+				continue;
+			}
+			if (state !== "idle") {
+				keep(entry, "gradleDaemon", state ? `gradle --status now reports it ${state}` : "gradle --status no longer lists it idle");
+				continue;
+			}
+			const error = signal(entry.pid);
+			if (error) {
+				failures++;
+				console.log(chalk.red(`Could not stop ${processLabel(entry)}: ${error}`));
+				recordGcResult("gradleDaemon", "failed", processLabel(entry), {
+					id: String(entry.pid),
+					bytes: entry.bytes,
+					detail: error
+				});
+				continue;
+			}
+			console.log(chalk.green(`Stopped ${processLabel(entry)}, freeing ${formatBytes(entry.bytes)}`));
+			recordGcResult("gradleDaemon", "done", processLabel(entry), {
+				id: String(entry.pid),
+				bytes: entry.bytes
+			});
+		}
+	}
+	return failures;
+}
+function stillPlanned(fresh, before, kind) {
+	const planned = new Map(before.processes.filter((entry) => entry.kind === kind).map((entry) => [entry.pid, entry]));
+	return fresh.processes.filter((entry) => entry.kind === kind && planned.get(entry.pid)?.startedAt === entry.startedAt);
+}
+function hostRows() {
+	const rows = createDeviceProcessTables().host();
+	return rows ? new Map(rows.map((row) => [row.pid, row])) : null;
+}
+const EXIT_WAIT_MS = 1e4;
+function alive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+async function waitForExit(pids) {
+	const running = pids.filter(alive);
+	if (running.length === 0) return;
+	phase("daemons", `waiting up to ${EXIT_WAIT_MS / 1e3}s for ${plural(running.length, "Gradle daemon")} to exit: pid ${running.join(", ")}`);
+	const deadline = Date.now() + EXIT_WAIT_MS;
+	while (running.some(alive) && Date.now() < deadline) await new Promise((done) => setTimeout(done, 200));
+}
+/** Stops the Gradle daemons first, then re-checks the Kotlin daemons, whose clients those Gradle daemons were. */
+async function reclaimDaemons(before) {
+	const scope = {
+		watchman: false,
+		gradle: true
+	};
+	const gradle = stillPlanned(await collectMemoryReport(scope, true), before, "gradleDaemon");
+	for (const entry of gradle.filter((e) => !e.reclaimable)) keep(entry, "gradleDaemon", entry.detail ?? "it could not be proven idle");
+	const stopping = gradle.filter((entry) => entry.reclaimable);
+	let failures = await stopGradle(stopping, hostRows());
+	if (!before.processes.some((entry) => entry.kind === "kotlinDaemon")) return failures;
+	await waitForExit(stopping.map((entry) => entry.pid));
+	const kotlin = stillPlanned(await collectMemoryReport(scope, true), before, "kotlinDaemon");
+	for (const entry of before.processes.filter((e) => e.kind === "kotlinDaemon" && e.reclaimable)) {
+		if (kotlin.some((current) => current.pid === entry.pid) || alive(entry.pid)) continue;
+		console.log(chalk.green(`${processLabel(entry)} exited with its Gradle daemon, freeing ${formatBytes(entry.bytes)}`));
+		recordGcResult("kotlinDaemon", "done", processLabel(entry), {
+			id: String(entry.pid),
+			bytes: entry.bytes
+		});
+	}
+	const rows = hostRows();
+	for (const entry of kotlin) if (entry.reclaimable) failures += stopKotlin(entry, rows);
+	else keep(entry, "kotlinDaemon", entry.detail ?? "it could not be proven idle");
+	return failures;
+}
+/** Whether `gc --delete --cache <cache>` would act on a memory kind: stop a process or remove a watchman root. */
+function memoryWorkPending(cache, report) {
+	if (!memoryCacheKind(cache) || !report) return false;
+	return reclaimableBytes(report) > 0 || report.watchmanRoots.some((root) => root.removable);
+}
+/** Acts on the one memory kind `--cache` names: never on an unscoped run or `--cache all`. */
+async function reclaimMemory(cache, report) {
+	const kind = memoryCacheKind(cache);
+	if (!kind || !report || report.processes.length === 0) return 0;
+	return kind === "watchman" ? reclaimWatchman(report) : reclaimDaemons(report);
+}
+/** A doctor note when watchman's footprint is over 2 GiB: only a restart shrinks it, and gc says when one is safe. */
+function watchmanFinding(report) {
+	const daemon = report.processes.find((entry) => entry.kind === "watchman");
+	if (!daemon || daemon.bytes < WATCHMAN_DOCTOR_BYTES) return null;
+	const stale = report.watchmanRoots.filter((root) => root.stale !== null).length;
+	const state = daemon.reclaimable ? "no client uses it now" : `it is kept: ${daemon.detail}`;
+	return {
+		level: "note",
+		title: `watchman uses ${formatBytes(daemon.bytes)}`,
+		detail: `The shared watchman daemon (pid ${daemon.pid}) has a ${formatBytes(daemon.bytes)} ${daemon.measure} with ${report.watchmanRoots.length} watched root(s), ${stale} of them stale; ${state}. Removing roots stops their recrawls, but only a restart returns the memory.`,
+		fix: "Run `stim gc --cache watchman` to see its roots and clients, then `stim gc --delete --cache watchman` once no workspace uses it."
+	};
+}
+async function inspectWatchmanMemory() {
+	if (process.platform === "win32" || memorySweepIsScoped()) return null;
+	return watchmanFinding(await collectMemoryReport({
+		watchman: true,
+		gradle: false
+	}));
+}
+//#endregion
 //#region src/commands/gc/caches.ts
 const DAY_MS$2 = 864e5;
 function cacheSweepIsScoped() {
@@ -300,8 +1194,8 @@ function cacheSweepIsScoped() {
 function isInsideConfigDir(dir) {
 	const root = canonicalPath(getConfigDir());
 	const target = canonicalPath(dir);
-	const rel = relative(root, target);
-	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+	const rel = relative$1(root, target);
+	return rel !== "" && !rel.startsWith("..") && !isAbsolute$1(rel);
 }
 function machineGlobalReason(cache) {
 	if (!cacheSweepIsScoped()) return null;
@@ -311,43 +1205,63 @@ function machineGlobalReason(cache) {
 }
 const EVERY_CACHE = "all";
 const WORKSPACE_OUTPUTS = "workspaces";
+const RECORDINGS = "recordings";
+const PARKED_DEVICES = "parked";
+function includesParkedDevices(name) {
+	return name?.trim().toLowerCase() === PARKED_DEVICES;
+}
+function includesRecordings(name) {
+	const wanted = name?.trim().toLowerCase();
+	return !wanted || wanted === EVERY_CACHE || wanted === RECORDINGS;
+}
+function isWorkspacesScope(name) {
+	return name?.trim().toLowerCase() === WORKSPACE_OUTPUTS;
+}
 function includesWorkspaceOutputs(name) {
 	const wanted = name?.trim().toLowerCase();
 	return !wanted || wanted === EVERY_CACHE || wanted === WORKSPACE_OUTPUTS;
 }
+/** Whether a --cache name selects something besides shared caches: recordings, parked devices or a memory kind. */
+function selectsBeyondCaches(name) {
+	return includesRecordings(name) || includesParkedDevices(name) || memoryCacheKind(name) !== null;
+}
 function selectCaches(caches, name) {
 	if (!name) return caches;
 	const wanted = name.trim().toLowerCase();
 	if (wanted === EVERY_CACHE) return caches;
-	if (wanted === WORKSPACE_OUTPUTS) return [];
+	if (wanted === WORKSPACE_OUTPUTS || wanted === RECORDINGS || wanted === PARKED_DEVICES || memoryCacheKind(wanted)) return [];
 	return caches.filter((c) => c.name.toLowerCase().includes(wanted) || c.dir.toLowerCase().includes(wanted));
 }
+function emptyVerdict(c) {
+	if (c.prune === "report-only") return {
+		willEmpty: false,
+		emptySkipped: "report-only shared cache; Stim never deletes it"
+	};
+	if (c.machineGlobal) return {
+		willEmpty: false,
+		emptySkipped: c.machineGlobal
+	};
+	if (!ownsItsDirectory(c)) return {
+		willEmpty: false,
+		emptySkipped: `${c.dir} is not a directory this cache owns`
+	};
+	return {
+		willEmpty: true,
+		emptySkipped: null
+	};
+}
 function planCacheEmptying(caches, all) {
 	const annotated = caches.map((c) => Object.assign({}, c, { machineGlobal: machineGlobalReason(c) }));
-	if (!all) return annotated;
-	return annotated.map((c) => {
-		if (c.prune === "report-only") return Object.assign({}, c, {
-			willEmpty: false,
-			emptySkipped: "report-only shared cache; Stim never deletes it"
-		});
-		if (c.machineGlobal) return Object.assign({}, c, {
-			willEmpty: false,
-			emptySkipped: c.machineGlobal
-		});
-		if (!ownsItsDirectory(c)) return Object.assign({}, c, {
-			willEmpty: false,
-			emptySkipped: `${c.dir} is not a directory this cache owns`
-		});
-		return Object.assign({}, c, {
-			willEmpty: true,
-			emptySkipped: null
-		});
-	});
+	return all ? annotated.map((c) => Object.assign({}, c, emptyVerdict(c))) : annotated;
+}
+/** What `gc --delete --cache <name>` would do to each cache, for a report that does not run that scope. */
+function previewScopedEmptying(caches) {
+	return planCacheEmptying(caches, false).map((c) => Object.assign({}, c, { scopedEmpty: emptyVerdict(c) }));
 }
 function ownsItsDirectory(cache) {
 	if (Array.isArray(cache.files)) return false;
 	const dir = canonicalPath(cache.dir);
-	if (dirname(dir) === dir) return false;
+	if (dirname$1(dir) === dir) return false;
 	return ![
 		homedir(),
 		tmpdir(),
@@ -377,7 +1291,7 @@ function emptyCache(cache) {
 	let removed = 0;
 	let failed = 0;
 	for (const name of names) try {
-		rmSync$1(join(cache.dir, name), {
+		rmSync$1(join$1(cache.dir, name), {
 			recursive: true,
 			force: true
 		});
@@ -567,7 +1481,7 @@ function findStaleProjectDevices({ config, sims = [], avds = [], olderThanDays,
 	const liveAvds = new Set(avds.filter((a) => typeof a === "string" && a.startsWith("stim-")));
 	const stale = [];
 	for (const [path, proj] of Object.entries(config?.projects || {})) {
-		if (dead.has(path) || !isAbsolute(path)) continue;
+		if (dead.has(path) || !isAbsolute$1(path)) continue;
 		const touched = lastTouched(path);
 		if (!Number.isFinite(touched) || touched >= cutoff) continue;
 		const idleDays = Math.floor((now - touched) / DAY_MS$1);
@@ -655,6 +1569,7 @@ function describeParkedSims(records, sims, deviceTypes, { simsChecked = true } =
 			model: deviceTypes.find((d) => d.identifier === record.deviceTypeIdentifier)?.name ?? null,
 			runtime: sim ? parseRuntimeVersion(sim.runtime) : parseRuntimeVersion(record.runtimeIdentifier),
 			parkedAt: record.parkedAt,
+			app: record.bundleId ?? null,
 			bytes: typeof sim?.dataPathSize === "number" ? sim.dataPathSize : null,
 			listed: simsChecked ? Boolean(sim) : null
 		};
@@ -710,11 +1625,58 @@ function collectParkedAvds(deps, age = {}) {
 			systemImage: record.systemImage,
 			deviceProfile: poolConfigurationDeviceProfile(record.configuration),
 			parkedAt: record.parkedAt,
+			app: record.packageName ?? null,
 			bytes,
 			listed: avds === null ? null : avds.includes(record.name)
 		};
 	});
 }
+function eraseParkedDevices(sims, avds) {
+	let failures = 0;
+	const devices = [...sims.map((sim) => ({
+		platform: "ios",
+		id: sim.udid,
+		name: sim.name,
+		listed: sim.listed,
+		bytes: sim.bytes
+	})), ...avds.map((avd) => ({
+		platform: "android",
+		id: avd.name,
+		name: avd.name,
+		listed: avd.listed,
+		bytes: avd.bytes
+	}))];
+	for (const device of devices) {
+		const what = `parked ${device.platform === "ios" ? "ios sim" : "android emulator"} ${device.name}`;
+		if (device.listed !== true) {
+			const unverified = device.listed === null;
+			const detail = unverified ? "Stim could not list devices to verify it; it was kept. Retry stim gc --cache parked --delete." : "it is not on this machine; stim gc --delete drops its pool record.";
+			if (unverified) failures++;
+			console.log((unverified ? chalk.red : chalk.dim)(`Did not erase ${what}: ${detail}`));
+			recordGcResult("parkedDevice", unverified ? "failed" : "kept", device.name, {
+				id: device.id,
+				detail
+			});
+			continue;
+		}
+		const result = device.platform === "ios" ? eraseParkedIosSim(device.id, { label: device.name }) : eraseParkedAvd(device.id);
+		if (result.status === "torn-down") {
+			console.log(chalk.green(`Erased ${what}; it stays parked`));
+			recordGcResult("parkedDevice", "done", device.name, {
+				id: device.id,
+				bytes: device.bytes
+			});
+		} else if (result.status === "failed") {
+			failures++;
+			console.log(chalk.red(`Failed to erase ${what}: ${result.reason}`));
+			recordGcResult("parkedDevice", "failed", device.name, {
+				id: device.id,
+				detail: result.reason
+			});
+		} else console.log(chalk.dim(`Skipped ${device.name}; it is no longer parked.`));
+	}
+	return failures;
+}
 function deleteParkedAvds(avds) {
 	let failures = 0;
 	for (const avd of avds) {
@@ -891,16 +1853,16 @@ function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords)
 //#endregion
 //#region src/commands/gc/workspaces.ts
 function workspacesRoot() {
-	return join(getConfigDir(), "workspaces");
+	return join$1(getConfigDir(), "workspaces");
 }
 function isInsideWorkspaces(dir) {
-	const rel = relative(canonicalPath(workspacesRoot()), canonicalPath(dir));
-	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+	const rel = relative$1(canonicalPath(workspacesRoot()), canonicalPath(dir));
+	return rel !== "" && !rel.startsWith("..") && !isAbsolute$1(rel);
 }
 function readRecordedRoot(dir, name) {
 	let parsed;
 	try {
-		parsed = readJsonFile(join(dir, "workspace.json"));
+		parsed = readJsonFile(join$1(dir, "workspace.json"));
 	} catch (error) {
 		return {
 			projectRoot: null,
@@ -908,7 +1870,7 @@ function readRecordedRoot(dir, name) {
 		};
 	}
 	const projectRoot = isJsonObject(parsed) ? parsed.projectRoot : void 0;
-	if (typeof projectRoot !== "string" || !isAbsolute(projectRoot)) return {
+	if (typeof projectRoot !== "string" || !isAbsolute$1(projectRoot)) return {
 		projectRoot: null,
 		problem: "its workspace.json records no absolute project root"
 	};
@@ -931,7 +1893,7 @@ function listWorkspaceDirs() {
 	}
 	const entries = [];
 	for (const name of names) {
-		const dir = join(root, name);
+		const dir = join$1(root, name);
 		try {
 			if (!statSync$1(dir).isDirectory()) continue;
 		} catch {
@@ -999,7 +1961,7 @@ function rootPresence(path) {
 		return code === "ENOENT" || code === "ENOTDIR" ? false : null;
 	}
 }
-function collectOrphanedWorkspaces(registryKeys, mountedVolumes) {
+function collectOrphanedWorkspaces(registryKeys, mountedVolumes, { measure = true } = {}) {
 	const classified = classifyWorkspaceDirs(listWorkspaceDirs(), {
 		registryKeys,
 		exists: rootPresence,
@@ -1007,11 +1969,11 @@ function collectOrphanedWorkspaces(registryKeys, mountedVolumes) {
 		inUse: (root) => workspaceInUse(root)
 	});
 	return {
-		orphaned: classified.orphaned.map((entry) => Object.assign({}, entry, { bytes: sizeOf(entry.dir) })),
+		orphaned: measure ? classified.orphaned.map((entry) => Object.assign({}, entry, { bytes: sizeOf(entry.dir) })) : classified.orphaned,
 		skipped: classified.skipped
 	};
 }
-const REBUILD_COST = "The next build of an unchanged app installs from the shared build cache; after a native change the compilation cache speeds the rebuild, but on React Native 0.86 Swift does not use it (explicit modules are off), so that build recompiles Swift.";
+const REBUILD_COST = "The next build of an unchanged app installs from the shared build cache; after a native change the compilation cache speeds the rebuild, but on React Native 0.86 Swift does not use it (explicit modules are off), so that build recompiles Swift. The next stim macos in a cleared workspace is a full Swift build.";
 const WORKSPACE_OUTPUT_DIRS = [
 	"derived-data",
 	"gradle-build",
@@ -1039,7 +2001,13 @@ function sizeOf(dir) {
 	return measuredDirectorySize(dir, { timeoutMs: SIZE_TIMEOUT_MS });
 }
 function outputPaths(dir) {
-	return WORKSPACE_OUTPUT_DIRS.map((name) => join(dir, name)).filter((path) => existsSync$1(path));
+	const paths = WORKSPACE_OUTPUT_DIRS.map((name) => join$1(dir, name)).filter((path) => existsSync$1(path));
+	const macos = join$1(dir, "macos");
+	try {
+		if (!lstatSync$1(macos).isDirectory()) return paths;
+		for (const entry of readdirSync$1(macos, { withFileTypes: true })) if (entry.name === "build" || entry.name.endsWith(".app") || entry.name.startsWith("staging-") && entry.isDirectory()) paths.push(join$1(macos, entry.name));
+	} catch {}
+	return paths;
 }
 function outputBytes(paths) {
 	let total = 0;
@@ -1093,7 +2061,7 @@ async function clearWorkspaceOutputs(report, { olderThan, now = Date.now() }) {
 					now
 				});
 				if (again?.keptReason) return again.keptReason;
-				for (const name of WORKSPACE_OUTPUT_DIRS) rmSync$1(join(entry.dir, name), {
+				for (const path of outputPaths(entry.dir)) rmSync$1(path, {
 					recursive: true,
 					force: true
 				});
@@ -1129,7 +2097,7 @@ async function clearWorkspaceOutputs(report, { olderThan, now = Date.now() }) {
 	};
 }
 function stillOrphaned({ dir, projectRoot }) {
-	if (readRecordedRoot(dir, basename(dir)).projectRoot !== projectRoot || rootPresence(projectRoot) !== false || !isOnMountedVolume(projectRoot)) return false;
+	if (readRecordedRoot(dir, basename$1(dir)).projectRoot !== projectRoot || rootPresence(projectRoot) !== false || !isOnMountedVolume(projectRoot)) return false;
 	return !Object.keys(loadConfig$1()?.projects ?? {}).some((key) => isPathPrefix(projectRoot, key));
 }
 async function deleteOrphanedWorkspaces(orphaned) {
@@ -1245,7 +2213,7 @@ function resolveBudget({ config = loadConfig$1(), env = process.env, totalMemory
 }
 function existingAncestor(path) {
 	let current = path;
-	while (!existsSync(current) && dirname$1(current) !== current) current = dirname$1(current);
+	while (!existsSync(current) && dirname(current) !== current) current = dirname(current);
 	return current;
 }
 function readVolumeSpace(paths) {
@@ -1413,7 +2381,10 @@ async function reclaimIdleDevServers({ root, dryRun, note, now }) {
 		try {
 			run = await withIdleWorkspace(path, async () => {
 				try {
-					return await withWorkspaceProcessLock(workspaceDir(path), "metro-start", async () => stillIdle(path, pid) ? stopOwnedMetro(path) : "busy", {
+					return await withWorkspaceProcessLock(workspaceDir(path), "metro-start", async () => stillIdle(path, pid) ? stopOwnedMetro(path, {
+						by: "budget reclaim",
+						workspace: root
+					}) : "busy", {
 						external: true,
 						waitMs: 0,
 						ownerPurpose: "budget reclaim"
@@ -1542,14 +2513,14 @@ function spaceUsers() {
 	const candidates = [
 		["Stim state", getConfigDir()],
 		["shared build cache", sharedBuildCache()],
-		...platform() === "darwin" ? [["simulators", join$1(home, "Library", "Developer", "CoreSimulator", "Devices")], ["Xcode DerivedData", join$1(home, "Library", "Developer", "Xcode", "DerivedData")]] : [],
-		["Android emulators", join$1(home, ".android", "avd")]
+		...platform() === "darwin" ? [["simulators", join(home, "Library", "Developer", "CoreSimulator", "Devices")], ["Xcode DerivedData", join(home, "Library", "Developer", "Xcode", "DerivedData")]] : [],
+		["Android emulators", join(home, ".android", "avd")]
 	];
 	const measured = /* @__PURE__ */ new Set();
 	const users = [];
 	for (const [label, path] of candidates) {
 		const canonical = canonicalPath(path);
-		if (measured.has(canonical) || [...measured].some((dir) => canonical.startsWith(`${dir}${sep$1}`))) continue;
+		if (measured.has(canonical) || [...measured].some((dir) => canonical.startsWith(`${dir}${sep}`))) continue;
 		measured.add(canonical);
 		if (!existsSync(path)) continue;
 		const bytes = measuredDirectorySize(path, { timeoutMs: USAGE_TIMEOUT_MS });
@@ -1736,4 +2707,4 @@ function budgetLine(report) {
 	return `${report.volumes.length ? `${report.volumes.map((v) => `${v.freeGb} GB free on ${v.volume}`).join(", ")} (reclaims below ${Math.max(budget.minFreeDiskGb, budget.hardFloorDiskGb)} GB, ${budget.hardFloorDiskGb ? `refuses below ${budget.hardFloorDiskGb} GB` : "never refuses"})` : "disk budget off"}; ${report.memory ? `roughly ${report.memory.committedGb} GB of a ${budget.maxCommittedMemoryGb} GB memory budget committed` : "memory budget off"}`;
 }
 //#endregion
-export { includesWorkspaceOutputs as A, deviceSweepIsScoped as C, unverifiedDeviceCommand as D, findStaleProjectDevices as E, sizeCaches as F, stopOwnedMetroForReset as I, selectCaches as M, trimCaches as N, withAndroidAvdSizes as O, discoverCaches as P, describeUnverifiableDevices as S, findStaleDeviceRecords as T, collectParkedSims as _, REBUILD_COST as a, deleteProjectDevices as b, collectOrphanedWorkspaces as c, isInsideWorkspaces as d, listWorkspaceDirs as f, collectParkedAvds as g, collectDeviceLeases as h, machineNumber as i, planCacheEmptying as j, emptyCaches as k, collectWorkspaceOutputs as l, DEVICE_LIST_TIMEOUT_MS$1 as m, budgetLine as n, WORKSPACE_OUTPUT_DIRS as o, sizeText as p, inspectBudget as r, clearWorkspaceOutputs as s, budgetGate as t, deleteOrphanedWorkspaces as u, deleteParkedAvds as v, findOrphanedDevices as w, describeParkedSims as x, deleteParkedSims as y };
+export { discoverCaches as $, withAndroidAvdSizes as A, trimCaches as B, describeUnverifiableDevices as C, findStaleDeviceRecords as D, findOrphanedDevices as E, isWorkspacesScope as F, memoryCacheKind as G, WATCHMAN_KIND as H, planCacheEmptying as I, memorySweepIsScoped as J, memoryLines as K, previewScopedEmptying as L, includesParkedDevices as M, includesRecordings as N, findStaleProjectDevices as O, includesWorkspaceOutputs as P, phase as Q, selectCaches as R, describeParkedSims as S, eraseParkedDevices as T, collectMemoryReport as U, GRADLE_DAEMONS_KIND as V, inspectWatchmanMemory as W, reclaimMemory as X, memoryWorkPending as Y, scopedMemoryReport as Z, collectParkedAvds as _, REBUILD_COST as a, deleteParkedSims as b, collectOrphanedWorkspaces as c, isInsideWorkspaces as d, sizeCaches as et, listWorkspaceDirs as f, collectDeviceLeases as g, DEVICE_LIST_TIMEOUT_MS$1 as h, machineNumber as i, emptyCaches as j, unverifiedDeviceCommand as k, collectWorkspaceOutputs as l, sizeText as m, budgetLine as n, WORKSPACE_OUTPUT_DIRS as o, rootPresence as p, memoryScope as q, inspectBudget as r, clearWorkspaceOutputs as s, budgetGate as t, stopOwnedMetroForReset as tt, deleteOrphanedWorkspaces as u, collectParkedSims as v, deviceSweepIsScoped as w, deleteProjectDevices as x, deleteParkedAvds as y, selectsBeyondCaches as z };