stim 1.17.1 → 1.18.0

package/dist/{budget-CUDz870h.mjs → budget-DIhL2BKx.mjs}

@@ -1,38 +1,32 @@
-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, P as measuredDirectorySize, _ as loadConfig$1, a as clearDevice, d as getConfigDir, 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 { l as phaseLine, o as formatLongDuration, u as plural } from "./command-output-CDAIFD-8.mjs";
-import { l as resolveProjectMetro, r as killMetroTree } from "./metro-g8NqiJp-.mjs";
-import { d as sharedBuildCache, r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-DqcCbpE7.mjs";
-import { a as capacity, l as environmentState, u as formatSpace } from "./status-CzS4bPO9.mjs";
-import { i as recordGcResult, n as withIdleWorkspace, o as canonicalPath } from "./in-use-CvGOUn-x.mjs";
-import { i as createDeviceProcessTables, p as workspaceActivity } from "./activity-IRvJY_ru.mjs";
-import { h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-DpoS36_u.mjs";
-import { n as listBuildSlots } from "./build-slots-41v_d2x9.mjs";
-import { l as readPidFile, s as clearWorkspaceSupervisor } from "./state-BKa8wNN5.mjs";
-import { a as parseWatchmanPid, i as parseWatchmanClients, n as parseTriggerCount, r as parseWatchRoots, t as parseSubscriberNames } from "./watchman-APYjXSQa.mjs";
-import { A as listAvds, I as ownedAvdDirectory, at as isStimOwnedSim, ct as dropParked, it as isStimOwnedAvd, pt as readParked, z as ownedAvdSerialResolver } from "./android-B_YNZy61.mjs";
-import { _ as parseRuntimeVersion, f as listIosDeviceTypes, u as listAllIosSims } from "./ios-DSfnPfse.mjs";
-import { _ as teardownParkedAvd, d as eraseParkedAvd, f as eraseParkedIosSim, g as teardownOwnedIosSim, m as teardownOwnedAvd, t as resolveSupervisorTarget, v as teardownParkedIosSim } from "./ownership-BMLqyBgJ.mjs";
-import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-2mNzOlaB.mjs";
-import { i as idleShutdownCandidates, n as collectOwnedDeviceActivity, o as shutDownIdleDevices, s as workspaceBuildInProgress, t as collectIdleDevices } from "./idle-BXG__1BA.mjs";
-import { a as collectWorkspaceOutputs, r as clearWorkspaceOutputs } from "./workspaces-Bcib97-6.mjs";
-import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
-import { l as withdrawDevServerStopRequest, s as requestDevServerStop } from "./stop-cause-rhmGfwvt.mjs";
-import { existsSync, readFileSync, statSync, statfsSync } from "node:fs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { a as formatElapsed, l as phaseLine, o as formatLongDuration, u as plural } from "./command-output-CBtzyIgF.mjs";
+import { A as directorySize, B as parseDeviceSlotKey, D as withConfigLock$1, F as volumeRootFor, H as projectDeviceSlots, M as isOnMountedVolume, P as measuredDirectorySize, R as deviceSlotKey, _ as loadConfig$1, a as clearDevice, d as getConfigDir, j as formatBytes, o as clearSupervisor, p as getProject, z as deviceSlotPlatforms } from "./config-CgYMahz7.mjs";
+import { l as resolveProjectMetro, r as killMetroTree } from "./metro-Dh8T4Ytd.mjs";
+import { C as workspaceStateFile, a as updateWorkspaceState, c as writeWorkspaceState, d as sharedBuildCache, h as supervisorPidFile, o as withWorkspaceStateLock, r as readWorkspaceState$1, t as clearWorkspaceStateKey, v as workspaceDir, x as workspaceLogsDir$1 } from "./workspace-state-C59dqG-Z.mjs";
+import { a as capacity, l as environmentState, u as formatSpace } from "./status-Dcr0Qexd.mjs";
+import { i as registeredCaches } from "./cache-manifest-BI7ozfmH.mjs";
+import { A as teardownParkedIosSim, C as eraseParkedAvd, E as teardownOwnedAvd, I as canonicalPath, M as listBuildSlots, O as teardownOwnedIosSim, P as recordGcResult, a as collectWorkspaceOutputs, f as withIdleWorkspace, k as teardownParkedAvd, m as resolveSupervisorTarget, r as clearWorkspaceOutputs, w as eraseParkedIosSim } from "./workspaces-xXItD8Dj.mjs";
+import { i as createDeviceProcessTables, o as idleForMs, p as workspaceActivity, r as createActivityReader } from "./activity-BxnkDZDi.mjs";
+import { h as listBuildLocks, i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-Co-EwifR.mjs";
+import { A as listAvds, I as ownedAvdDirectory, at as isStimOwnedSim, ct as dropParked, it as isStimOwnedAvd, pt as readParked, z as ownedAvdSerialResolver } from "./android-DC3ZLuw0.mjs";
+import { d as listAllIosSims, p as listIosDeviceTypes, v as parseRuntimeVersion } from "./ios-B3SbOWdw.mjs";
+import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-BFIz1Shz.mjs";
+import { c as supervisorError } from "./metro-store-BAHFcJm6.mjs";
+import { r as createNdjsonWriter } from "./ndjson-LGZAMsqa.mjs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, statfsSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
-import { existsSync as existsSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
-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, compiledHelper, configDir } from "@stim-cli/core";
-import { MACHINE_OWNER_KINDS, buildWorkerRoot, loadConfig, settingDefinition, settingValueError } from "@stim-cli/core/state";
+import { BUILD_HISTORY_KEY, BUILD_HISTORY_LIMIT, BUILD_PHASES, DEV_SERVER_STOP_REQUEST_KEY, LAST_BUILD_KEYS, MACHINE_OWNER_KINDS, STATS_VERSION, buildWorkerRoot, decodeStats, isJsonObject, loadConfig, parseMissReason, readDevServerStop, readDevServerStopRequest, readRunEstimates, readStats as readStats$1, settingDefinition, settingValueError, statsFile, statsProjectKey as statsProjectKey$1, trimCapacityRefusals, trimCapacityWaits, trimSamples, wholePhases, workspaceBuildDetailFile } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
-import { homedir as homedir$1, platform, totalmem as totalmem$1 } from "node:os";
+import { homedir, platform, totalmem } from "node:os";
 import chalk from "chalk";
+import { existsSync as existsSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, rmSync as rmSync$1, statSync as statSync$1 } from "fs";
+import { LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, compiledHelper, configDir } from "@stim-cli/core";
+import { homedir as homedir$1, tmpdir as tmpdir$1 } from "os";
 //#region src/cache/caches.ts
 function xcodeDerivedDataRoot() {
-	return join$1(homedir(), "Library", "Developer", "Xcode", "DerivedData");
+	return join$1(homedir$1(), "Library", "Developer", "Xcode", "DerivedData");
 }
 function compilationCache() {
 	const dir = join$1(xcodeDerivedDataRoot(), "CompilationCache.noindex");
@@ -45,7 +39,7 @@ function compilationCache() {
 	};
 }
 function gradleBuildCache() {
-	const gradleHome = process.env.GRADLE_USER_HOME || join$1(homedir(), ".gradle");
+	const gradleHome = process.env.GRADLE_USER_HOME || join$1(homedir$1(), ".gradle");
 	const dir = resolve$1(gradleHome, "caches", "build-cache-1");
 	if (!existsSync$1(dir)) return null;
 	return {
@@ -56,7 +50,7 @@ function gradleBuildCache() {
 	};
 }
 function metroFileMaps() {
-	const root = tmpdir();
+	const root = tmpdir$1();
 	if (!existsSync$1(root)) return null;
 	let names;
 	try {
@@ -201,7 +195,7 @@ function canonicalCacheDir(dir) {
 function sizeCaches(caches) {
 	return caches.map((c) => Object.assign({}, c, { bytes: c.bytes ?? directorySize(c.dir) }));
 }
-function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
+function pruneCache(cache, { olderThanDays, now = Date.now(), protect, evictBytes, byMtime = false } = {}) {
 	const cutoff = now - olderThanDays * 24 * 60 * 60 * 1e3;
 	if (cache.prune === "report-only") return {
 		removed: 0,
@@ -214,27 +208,38 @@ function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
 		skipped: "index-backed; empty it whole or not at all"
 	};
 	const entries = cache.files ?? entriesAtDepth(cache.dir, cache.entriesDepth ?? 1);
+	const candidates = [];
+	let protectedEntries = 0;
+	for (const entry of entries) try {
+		const st = statSync$1(entry);
+		const used = byMtime ? st.mtimeMs : Math.max(st.atimeMs, st.mtimeMs);
+		if (used >= cutoff) continue;
+		if (protect?.(entry)) {
+			protectedEntries++;
+			continue;
+		}
+		candidates.push({
+			entry,
+			used,
+			isDirectory: st.isDirectory(),
+			size: st.size
+		});
+	} catch {}
+	if (evictBytes !== void 0) candidates.sort((a, b) => a.used - b.used);
 	let removed = 0;
 	let bytes = 0;
 	let failed = 0;
-	for (const entry of entries) {
-		let used;
-		let size;
-		try {
-			const st = statSync$1(entry);
-			used = Math.max(st.atimeMs, st.mtimeMs);
-			size = st.isDirectory() ? directorySize(entry) : st.size;
-		} catch {
-			continue;
-		}
-		if (used >= cutoff) continue;
+	for (const { entry, isDirectory, size } of candidates) {
+		if (evictBytes !== void 0 && bytes >= evictBytes) break;
 		try {
+			if (!existsSync$1(entry) || statSync$1(entry).mtimeMs >= cutoff) continue;
+			const entryBytes = isDirectory ? directorySize(entry) : size;
 			rmSync$1(entry, {
 				recursive: true,
 				force: true
 			});
 			removed++;
-			bytes += size;
+			bytes += entryBytes;
 		} catch {
 			failed++;
 		}
@@ -243,7 +248,8 @@ function pruneCache(cache, { olderThanDays, now = Date.now() } = {}) {
 		removed,
 		bytes,
 		failed,
-		skipped: null
+		skipped: null,
+		protectedEntries
 	};
 }
 function entriesAtDepth(dir, depth) {
@@ -545,6 +551,194 @@ function attributeMachineUsage({ processes, footprints, environments, roots, sim
 	};
 }
 //#endregion
+//#region src/supervisor/state.ts
+const MODE_BARE = "bare-inproc";
+const MODE_EXPO = "expo-child";
+function readMetroTunnel(root) {
+	const record = readWorkspaceState$1(root)?.metroTunnel;
+	if (!record || typeof record !== "object") return null;
+	const kind = record.kind;
+	const url = record.url;
+	if (typeof url !== "string" || url.length === 0) return null;
+	if (kind === "expo") return {
+		kind: "expo",
+		url
+	};
+	if (kind === "managed") {
+		const provider = record.provider;
+		const pid = record.pid;
+		const port = record.port;
+		const startedAt = record.startedAt;
+		const processToken = record.processToken;
+		const logFile = record.logFile;
+		if (provider !== "ngrok" && provider !== "cloudflared" && provider !== "tailscale" || typeof pid !== "number" || typeof port !== "number") return null;
+		return {
+			kind: "managed",
+			provider,
+			pid,
+			url,
+			port,
+			startedAt: typeof startedAt === "string" ? startedAt : "",
+			processToken: typeof processToken === "string" && processToken.length > 0 ? processToken : null,
+			...typeof logFile === "string" && logFile.length > 0 ? { logFile } : {}
+		};
+	}
+	return null;
+}
+function parseWorkspaceLaunchRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	if (typeof record.appId !== "string" || record.appId.length === 0) return null;
+	if (typeof record.deviceId !== "string" || record.deviceId.length === 0) return null;
+	if (record.metroPort !== null && typeof record.metroPort !== "number") return null;
+	if (typeof record.release !== "boolean") return null;
+	if (typeof record.launchedAt !== "string") return null;
+	return record;
+}
+function readWorkspaceLaunches(root) {
+	const launches = readWorkspaceState$1(root)?.launches;
+	if (!launches || typeof launches !== "object" || Array.isArray(launches)) return {};
+	const records = {};
+	for (const [key, value] of Object.entries(launches)) {
+		const record = parseWorkspaceLaunchRecord(value);
+		if (parseDeviceSlotKey(key) && record) records[key] = record;
+	}
+	return records;
+}
+function writeWorkspaceLaunch(root, platform, record, slot = "default") {
+	updateWorkspaceState(root, (state) => {
+		const launches = state.launches && typeof state.launches === "object" ? state.launches : {};
+		return {
+			...state,
+			launches: {
+				...launches,
+				[deviceSlotKey(platform, slot)]: record
+			}
+		};
+	});
+}
+function clearWorkspaceLaunches(root, slot) {
+	updateWorkspaceState(root, (state) => {
+		if (!state.launches || typeof state.launches !== "object") return state;
+		const launches = { ...state.launches };
+		delete launches[deviceSlotKey("ios", slot)];
+		delete launches[deviceSlotKey("android", slot)];
+		return {
+			...state,
+			launches
+		};
+	});
+}
+function readRemoteSession(root) {
+	const record = readWorkspaceState$1(root)?.remoteDevice;
+	if (!record || typeof record !== "object") return null;
+	const id = record.sessionId;
+	if (typeof id !== "string" || id.length === 0) return null;
+	const platform = record.platform;
+	const startedAt = record.startedAt;
+	const webPreviewUrl = record.webPreviewUrl;
+	const deviceType = record.deviceType;
+	return {
+		platform: platform === "ios" || platform === "android" ? platform : null,
+		sessionId: id,
+		startedAt: typeof startedAt === "string" ? startedAt : null,
+		webPreviewUrl: typeof webPreviewUrl === "string" && webPreviewUrl.length > 0 ? webPreviewUrl : null,
+		deviceType: typeof deviceType === "string" && deviceType.length > 0 ? deviceType : null
+	};
+}
+function readRemoteSessionId(root) {
+	return readRemoteSession(root)?.sessionId ?? null;
+}
+function clearRemoteSession(root, expectedSessionId) {
+	clearWorkspaceStateKey(root, "remoteDevice", (value) => {
+		if (typeof value !== "object" || value === null) return false;
+		return value.sessionId === expectedSessionId;
+	});
+}
+function clearWorkspaceSupervisor(root, expected) {
+	return withWorkspaceStateLock(root, () => {
+		const current = readWorkspaceState$1(root)?.supervisor;
+		if (current && expected !== void 0 && !(0, process_identity_exports.sameProcessRecord)(current, expected)) return false;
+		clearWorkspaceStateKey(root, "supervisor", () => true);
+		clearExpoMetroTunnel(root);
+		if (expected === void 0 || readPidFile(root) === expected?.pid) rmSync(supervisorPidFile(root), { force: true });
+		return true;
+	});
+}
+function clearExpoMetroTunnel(root) {
+	clearWorkspaceStateKey(root, "metroTunnel", (value) => {
+		return typeof value === "object" && value !== null && value.kind === "expo";
+	});
+}
+function clearManagedMetroTunnel(root, expected) {
+	if (!existsSync(workspaceStateFile(root))) return true;
+	return clearWorkspaceStateKey(root, "metroTunnel", (value) => {
+		if (typeof value !== "object" || value === null) return false;
+		const record = value;
+		return record.kind === "managed" && record.provider === expected.provider && record.pid === expected.pid && record.url === expected.url && record.port === expected.port && record.startedAt === expected.startedAt && (record.processToken ?? null) === (expected.processToken ?? null) && (record.logFile ?? null) === (expected.logFile ?? null);
+	});
+}
+function writePidFile(root, pid) {
+	const file = supervisorPidFile(root);
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, `${pid}\n`);
+	return file;
+}
+function readPidFile(root) {
+	try {
+		const pid = parseInt(readFileSync(supervisorPidFile(root), "utf-8").trim(), 10);
+		return Number.isFinite(pid) ? pid : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/watchman.ts
+/** Runs one watchman command with `--no-spawn`, so Stim never starts a daemon, and parses its JSON answer. */
+const runWatchman = async (args, timeoutMs) => JSON.parse(await getExecutor().runFileAsync("watchman", ["--no-spawn", ...args], { timeoutMs }));
+function parseWatchRoots(payload) {
+	const roots = payload?.roots;
+	if (!Array.isArray(roots)) return null;
+	return roots.filter((root) => typeof root === "string");
+}
+function parseSubscriberNames(payload) {
+	if (!payload || typeof payload !== "object" || "error" in payload) return null;
+	const subscribers = payload.subscribers;
+	if (subscribers === void 0) return [];
+	if (!Array.isArray(subscribers)) return null;
+	const names = [];
+	for (const subscriber of subscribers) {
+		const name = subscriber?.info?.name;
+		if (typeof name !== "string") return null;
+		names.push(name);
+	}
+	return names;
+}
+function parseTriggerCount(payload) {
+	const triggers = payload?.triggers;
+	return Array.isArray(triggers) ? triggers.length : null;
+}
+function parseWatchmanPid(payload) {
+	const pid = payload?.pid;
+	return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+/** The connected clients in a `debug-status` answer, or null when the answer does not list them. */
+function parseWatchmanClients(payload) {
+	if (!payload || typeof payload !== "object" || "error" in payload) return null;
+	const clients = payload.clients;
+	if (!Array.isArray(clients)) return null;
+	const parsed = [];
+	for (const client of clients) {
+		const peer = client?.peer;
+		if (typeof peer?.pid !== "number") return null;
+		parsed.push({
+			pid: peer.pid,
+			name: typeof peer.name === "string" ? peer.name : null
+		});
+	}
+	return parsed;
+}
+//#endregion
 //#region src/commands/gc/progress.ts
 function phase(label, text) {
 	console.error(chalk.dim(phaseLine(label, text)));
@@ -1524,8 +1718,8 @@ function ownsItsDirectory(cache) {
 	const dir = canonicalPath(cache.dir);
 	if (dirname$1(dir) === dir) return false;
 	return ![
-		homedir(),
-		tmpdir(),
+		homedir$1(),
+		tmpdir$1(),
 		getConfigDir()
 	].map(canonicalPath).includes(dir);
 }
@@ -2112,6 +2306,1322 @@ function deleteProjectDevices(orphanedDevices, staleDevices, staleDeviceRecords)
 	return deleteFailures;
 }
 //#endregion
+//#region src/engine/stats.ts
+const PLACEMENT_MAX_AGE_MS = 6048e5;
+function emptyStats() {
+	return {
+		version: STATS_VERSION,
+		machine: {},
+		projects: {}
+	};
+}
+function updateStats(record, run, now) {
+	const at = new Date(now).toISOString();
+	const durationMs = wholeMs(run.durationMs);
+	const phases = {
+		coldBuildMs: wholeMs(run.coldBuildMs),
+		podsMs: wholeMs(run.podsMs)
+	};
+	const projects = { ...record.projects };
+	const scope = { ...projects[run.projectKey] };
+	const machine = { ...record.machine };
+	const before = scope[run.platform] ?? null;
+	const credit = creditMs(before, run, durationMs);
+	scope[run.platform] = applyRun(before, run, {
+		at,
+		durationMs,
+		credit,
+		phases
+	});
+	projects[run.projectKey] = scope;
+	machine[run.platform] = applyRun(machine[run.platform] ?? null, run, {
+		at,
+		durationMs,
+		credit,
+		phases
+	});
+	const history = { ...record.history };
+	if (run.phases && !run.failed && !run.waitedForBuild && !run.offloadedTo) {
+		const outcome = isHit(run.cacheHit) ? "hit" : "cold";
+		const project = { ...history[run.projectKey] };
+		const lists = { ...project[run.platform] };
+		const sample = {
+			at,
+			durationMs,
+			phases: wholePhases(run.phases),
+			...run.deviceSetup === void 0 ? {} : { deviceSetup: run.deviceSetup }
+		};
+		lists[outcome] = trimSamples([...lists[outcome] ?? [], sample]);
+		project[run.platform] = lists;
+		history[run.projectKey] = project;
+	}
+	let placements = record.placements;
+	let buildMachines = record.buildMachines;
+	if (run.placement) {
+		const placement = buildPlacement(run, before, at);
+		placements = trimPlacements([...placements ?? [], placement], now);
+		if (placement.machine && placement.decision !== "here") buildMachines = {
+			...buildMachines,
+			[placement.machine]: applyPlacement(buildMachines?.[placement.machine], placement)
+		};
+	}
+	const capacityRefusals = trimCapacityRefusals(record.capacityRefusals ?? [], now);
+	const capacityWaits = trimCapacityWaits(record.capacityWaits ?? [], now);
+	return {
+		version: STATS_VERSION,
+		machine,
+		projects,
+		...Object.keys(history).length ? { history } : {},
+		...placements?.length ? { placements } : {},
+		...capacityRefusals.length ? { capacityRefusals } : {},
+		...capacityWaits.length ? { capacityWaits } : {},
+		...buildMachines && Object.keys(buildMachines).length ? { buildMachines } : {}
+	};
+}
+function buildPlacement(run, before, at) {
+	const placement = run.placement;
+	const buildMs = wholeMs(placement.decision === "offloaded" ? placement.buildMs : run.coldBuildMs);
+	const localEstimateMs = wholeMs(before?.lastColdBuildMs);
+	const slotWaitMs = wholeMs(placement.slotWaitMs);
+	const deviceSlotWaitMs = wholeMs(placement.deviceSlotWaitMs);
+	return {
+		at,
+		project: run.projectKey,
+		platform: run.platform,
+		decision: placement.decision,
+		reason: placement.reason,
+		...placement.machine ? { machine: placement.machine } : {},
+		...buildMs > 0 ? { buildMs } : {},
+		...slotWaitMs > 0 ? { slotWaitMs } : {},
+		...deviceSlotWaitMs > 0 ? { deviceSlotWaitMs } : {},
+		...localEstimateMs > 0 ? { localEstimateMs } : {},
+		...run.failed ? { failed: true } : {}
+	};
+}
+function applyPlacement(totals, placement) {
+	const next = totals ? { ...totals } : {
+		offloaded: 0,
+		offloadedMs: 0,
+		savedMs: 0,
+		fallbacks: 0
+	};
+	if (placement.decision === "fell-back") {
+		next.fallbacks += 1;
+		next.lastFallbackAt = placement.at;
+		return next;
+	}
+	next.offloaded += 1;
+	next.offloadedMs += placement.buildMs ?? 0;
+	if (placement.localEstimateMs && placement.buildMs) next.savedMs += placement.localEstimateMs - placement.buildMs;
+	next.lastOffloadAt = placement.at;
+	return next;
+}
+function trimPlacements(placements, now) {
+	return placements.filter((each) => now - Date.parse(each.at) <= PLACEMENT_MAX_AGE_MS).slice(-100);
+}
+function recordRunStats(run, now) {
+	return withConfigLock$1(() => {
+		const path = statsFile();
+		const loaded = loadForUpdate(path, now);
+		if (loaded.newerVersion !== null) return {
+			recorded: false,
+			note: `Run statistics at ${path} are version ${loaded.newerVersion}, which this Stim does not understand, so this run was not recorded.`
+		};
+		writeStats(path, updateStats(loaded.record, run, now));
+		return {
+			recorded: true,
+			note: loaded.note
+		};
+	});
+}
+function recordCapacityRefusal(event, now) {
+	try {
+		withConfigLock$1(() => {
+			const path = statsFile();
+			const loaded = loadForUpdate(path, now, false);
+			if (!loaded.record || loaded.newerVersion !== null) return;
+			const capacityRefusals = trimCapacityRefusals([...loaded.record.capacityRefusals ?? [], {
+				...event,
+				at: new Date(now).toISOString(),
+				kind: "device"
+			}], now);
+			writeStats(path, {
+				...loaded.record,
+				capacityRefusals
+			});
+		});
+	} catch {}
+}
+function recordCapacityWait(event, now) {
+	try {
+		withConfigLock$1(() => {
+			const path = statsFile();
+			const loaded = loadForUpdate(path, now, false);
+			if (!loaded.record || loaded.newerVersion !== null) return;
+			const capacityWaits = trimCapacityWaits([...loaded.record.capacityWaits ?? [], {
+				platform: event.platform,
+				max: event.max,
+				workspace: event.workspace,
+				ms: wholeMs(event.ms),
+				...event.reclaimed && Number.isInteger(event.reclaimed) && event.reclaimed > 0 ? { reclaimed: event.reclaimed } : {},
+				at: new Date(now).toISOString(),
+				kind: "device-wait"
+			}], now);
+			writeStats(path, {
+				...loaded.record,
+				capacityWaits
+			});
+		});
+	} catch {}
+}
+function createRunRecorder({ platform, write, now, note, phases, deviceSetup }) {
+	let projectKey = null;
+	let cacheKey = null;
+	let coldBuildMs = 0;
+	let podsMs = 0;
+	let placement = null;
+	let deviceSlotWaitMs = 0;
+	let recorded = false;
+	return {
+		setProject(key) {
+			projectKey = key;
+		},
+		setCacheKey(key) {
+			cacheKey = key;
+		},
+		setBuildMs(ms) {
+			coldBuildMs = wholeMs(ms);
+		},
+		setPodsMs(ms) {
+			podsMs = wholeMs(ms);
+		},
+		addDeviceSlotWaitMs(ms) {
+			deviceSlotWaitMs += wholeMs(ms);
+		},
+		deviceSlotWaitMs() {
+			return deviceSlotWaitMs || void 0;
+		},
+		setPlacement(next) {
+			placement = next;
+		},
+		record({ failed, cacheHit = false, waited = null, durationMs, offloadedTo = null }) {
+			if (!projectKey || !cacheKey || recorded) return;
+			recorded = true;
+			const ran = failed ? {} : phases?.() ?? {};
+			try {
+				const outcome = write({
+					platform,
+					projectKey,
+					failed,
+					cacheHit,
+					waitedForBuild: Boolean(waited),
+					durationMs,
+					...offloadedTo ? { offloadedTo } : {},
+					...coldBuildMs > 0 ? { coldBuildMs } : {},
+					...podsMs > 0 ? { podsMs } : {},
+					...Object.keys(ran).length ? { phases: ran } : {},
+					...failed || deviceSetup?.() === void 0 ? {} : { deviceSetup: deviceSetup() },
+					...placement ? { placement: {
+						...placement,
+						...deviceSlotWaitMs > 0 ? { deviceSlotWaitMs } : {}
+					} } : {}
+				}, now());
+				if (outcome?.note) note(outcome.note);
+			} catch (error) {
+				note(`Run statistics could not be recorded: ${error?.message || error}`);
+			}
+		}
+	};
+}
+function loadForUpdate(path, now, recoverCorrupt = true) {
+	let text;
+	try {
+		text = readFileSync(path, "utf-8");
+	} catch {
+		return {
+			record: emptyStats(),
+			note: null,
+			newerVersion: null
+		};
+	}
+	const parsed = decodeStats(text);
+	if (!parsed.record && parsed.newerVersion === null) {
+		if (!recoverCorrupt) return {
+			record: null,
+			note: null,
+			newerVersion: null
+		};
+		const aside = `${path}.corrupt-${now}`;
+		renameSync(path, aside);
+		return {
+			record: emptyStats(),
+			note: `Run statistics at ${path} could not be read, so they were moved to ${aside} and a new file was started.`,
+			newerVersion: null
+		};
+	}
+	if (parsed.newerVersion !== null) return {
+		record: emptyStats(),
+		note: null,
+		newerVersion: parsed.newerVersion
+	};
+	return {
+		record: parsed.record,
+		note: null,
+		newerVersion: null
+	};
+}
+function writeStats(path, record) {
+	const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(record)}\n`);
+	try {
+		renameSync(tmp, path);
+	} catch (error) {
+		rmSync(tmp, { force: true });
+		throw error;
+	}
+}
+function applyRun(bucket, run, { at, durationMs, credit, phases }) {
+	const next = bucket ? { ...bucket } : {
+		runs: 0,
+		failed: 0,
+		hits: 0,
+		misses: 0,
+		coldRuns: 0,
+		coldRunMs: 0,
+		hitRuns: 0,
+		hitRunMs: 0,
+		timeSavedMs: 0,
+		firstRunAt: at,
+		lastRunAt: at
+	};
+	next.runs += 1;
+	next.lastRunAt = at;
+	if (phases.coldBuildMs > 0) next.lastColdBuildMs = phases.coldBuildMs;
+	if (phases.podsMs > 0) next.lastPodsMs = phases.podsMs;
+	if (run.failed) {
+		next.failed += 1;
+		return next;
+	}
+	if (isHit(run.cacheHit)) {
+		next.hits += 1;
+		if (!run.waitedForBuild) {
+			next.hitRuns += 1;
+			next.hitRunMs += durationMs;
+			next.timeSavedMs += credit;
+		}
+		return next;
+	}
+	next.misses += 1;
+	if (run.offloadedTo) {
+		next.offloadedRuns = (next.offloadedRuns ?? 0) + 1;
+		next.offloadedRunMs = (next.offloadedRunMs ?? 0) + durationMs;
+		next.lastOffloadHost = run.offloadedTo;
+		return next;
+	}
+	next.coldRuns += 1;
+	next.coldRunMs += durationMs;
+	return next;
+}
+function creditMs(bucket, run, durationMs) {
+	if (run.failed || !isHit(run.cacheHit) || run.waitedForBuild) return 0;
+	if (!bucket || bucket.coldRuns <= 0) return 0;
+	return Math.max(0, Math.round(bucket.coldRunMs / bucket.coldRuns) - durationMs);
+}
+function isHit(cacheHit) {
+	return cacheHit === "local" || cacheHit === "remote";
+}
+function wholeMs(value) {
+	const ms = Number(value);
+	return Number.isFinite(ms) && ms > 0 ? Math.round(ms) : 0;
+}
+//#endregion
+//#region src/engine/build-detail.ts
+const LINE_MAX = 160;
+const TARGET_GRAPH = /^note: Target dependency graph \((\d+) targets?\)/;
+const XCODE_ACTION = /^([A-Z][A-Za-z]+)\s(.*)\s\(in target '([^']+)' from project '([^']+)'\)$/;
+const XCODE_CONFIGURE = /^(ComputeTargetDependencyGraph|CreateBuildDescription|CreateBuildRequest|Resolve Package Graph|Prepare packages)$/;
+const GRADLE_TASK = /^> Task (:\S+)/;
+/**
+* xcodebuild actions that end a target's work: a clean build touches each product last, and an incremental build
+* that touches nothing still signs framework products last. Targets that end any other way are not counted.
+*/
+const XCODE_TARGET_DONE = /^(Touch|RegisterExecutionPolicyException|CodeSign)$/;
+const GRADLE_CONFIGURE = /^> Configure project /;
+/**
+* SwiftPM prints `[done / total] name` once it plans the build (with U+2009 thin spaces around the slash in Swift 6.4
+* output), `[done/total] Compiling ...` in older toolchains; Swift 6.4 names the target being worked on, and
+* `<product>-product` is the link of a product.
+*/
+const SWIFTPM_PROGRESS = /^\[(\d+)\s*\/\s*(\d+)\](?:\s+(.*))?$/;
+const SWIFTPM_CONFIGURE = /^(Fetching|Fetched|Computing version|Computed|Creating working copy|Working copy of)\b|^\[(Pre-planning|Planning|Using on-disk description)/;
+const XCODE_STEPS = [
+	[/^(CpResource|CopyPNGFile|CopyStringsFile|CompileAssetCatalog\w*|CompileStoryboard|CompileXIB|LinkStoryboards|ProcessInfoPlistFile)$/, "resources"],
+	[/^(Compile\w*|Swift\w*|ScanDependencies|Precompile\w*)$/, "compile"],
+	[/^(Ld|Libtool|CreateUniversalBinary|GenerateDSYMFile)$/, "link"],
+	[/^PhaseScriptExecution$/, "script"],
+	[/^CodeSign$/, "sign"]
+];
+const GRADLE_STEPS = [
+	[/[Dd]ex/, "dex"],
+	[/^(createBundle\w*JsAndAssets|generateCodegen\w*)$/, "script"],
+	[/(Resources?|Assets|Manifest|ResValues|RFile|JavaRes)$/, "resources"],
+	[/^(compile|kapt|ksp|javaPreCompile|buildCMake|configureCMake|externalNativeBuild)/, "compile"],
+	[/^(package|assemble|install|zipalign|validateSigning|merge\w*NativeLibs|strip\w*Symbols)/, "package"]
+];
+function stepOf(name, table) {
+	return table.find(([pattern]) => pattern.test(name))?.[1] ?? null;
+}
+function clip(text) {
+	return text.length > LINE_MAX ? `${text.slice(0, 157)}...` : text;
+}
+function unescape(token) {
+	return token.replace(/\\(.)/g, "$1");
+}
+function baseName(path) {
+	return path.split("/").findLast(Boolean) ?? path;
+}
+/**
+* An xcodebuild action line in short form: the action, the file it works on and its target, as in
+* `CompileC sqlite3.c (sqlite3)`. The file is the last absolute path in the arguments, which xcodebuild prints
+* as the source for compile, copy and plist steps and as the product for link and sign steps; a script phase
+* shows its name instead.
+*/
+function shortXcodeAction(action, args, target) {
+	const tokens = args.match(/(?:\\.|\S)+/g) ?? [];
+	const subject = action === "PhaseScriptExecution" ? unescape(tokens[0] ?? "") : baseName(unescape(tokens.findLast((token) => token.startsWith("/")) ?? ""));
+	return clip(`${action}${subject ? ` ${subject}` : ""} (${target})`);
+}
+function swiftpmStep(text) {
+	return /^Linking\b|-product$/.test(text) ? "link" : "compile";
+}
+/** What one line of xcodebuild, Gradle or SwiftPM output says about the build's progress, or null for any other line. */
+function parseBuildToolLine(msg) {
+	const counted = SWIFTPM_PROGRESS.exec(msg);
+	if (counted) {
+		const text = counted[3]?.trim() ?? "";
+		return {
+			kind: "count",
+			done: Number(counted[1]),
+			total: Number(counted[2]),
+			step: swiftpmStep(text),
+			line: text ? clip(text) : null
+		};
+	}
+	if (SWIFTPM_CONFIGURE.test(msg)) return { kind: "configure" };
+	const graph = TARGET_GRAPH.exec(msg);
+	if (graph) return {
+		kind: "total",
+		unit: "targets",
+		total: Number(graph[1])
+	};
+	if (XCODE_CONFIGURE.test(msg) || GRADLE_CONFIGURE.test(msg)) return { kind: "configure" };
+	const action = XCODE_ACTION.exec(msg);
+	if (action) {
+		const [, name, args, target, project] = action;
+		const step = stepOf(name, XCODE_STEPS);
+		return {
+			kind: "unit",
+			unit: "targets",
+			id: `${project}/${target}`,
+			step,
+			line: step ? shortXcodeAction(name, args, target) : null,
+			finished: XCODE_TARGET_DONE.test(name)
+		};
+	}
+	const task = GRADLE_TASK.exec(msg);
+	if (task) {
+		const path = task[1];
+		return {
+			kind: "unit",
+			unit: "tasks",
+			id: path,
+			step: stepOf(path.slice(path.lastIndexOf(":") + 1), GRADLE_STEPS),
+			line: clip(`> Task ${path}`),
+			finished: false
+		};
+	}
+	return null;
+}
+/**
+* Accumulates a build's tool output into its detail: xcodebuild counts the distinct targets it finished against the
+* total its dependency graph note gives; Gradle counts the task lines it printed and has no total; SwiftPM reports
+* its own `[done / total]` counts, which the parser passes through.
+*/
+function createBuildDetailParser() {
+	let seen = false;
+	let step = null;
+	let unit = null;
+	let total = null;
+	let line = null;
+	let tasks = 0;
+	let counted = null;
+	const targets = /* @__PURE__ */ new Set();
+	return {
+		push(msg) {
+			const parsed = parseBuildToolLine(msg);
+			if (!parsed) return false;
+			seen = true;
+			if (parsed.kind === "total") {
+				unit = "targets";
+				total = parsed.total;
+				return true;
+			}
+			if (parsed.kind === "configure") {
+				step = "configure";
+				return true;
+			}
+			if (parsed.kind === "count") {
+				unit = "steps";
+				counted = {
+					done: parsed.done,
+					total: parsed.total
+				};
+				step = parsed.step;
+				if (parsed.line) line = parsed.line;
+				return true;
+			}
+			unit = parsed.unit;
+			if (parsed.unit === "tasks") tasks += 1;
+			else if (parsed.finished) targets.add(parsed.id);
+			if (parsed.step) step = parsed.step;
+			if (parsed.line) line = parsed.line;
+			return true;
+		},
+		detail(updatedAt) {
+			if (!seen) return null;
+			if (unit === "steps" && counted) return {
+				step,
+				unit,
+				done: Math.min(counted.done, counted.total),
+				total: counted.total,
+				line,
+				updatedAt
+			};
+			const done = unit === "tasks" ? tasks : unit === "targets" ? targets.size : null;
+			return {
+				step,
+				unit,
+				done: done !== null && total !== null ? Math.min(done, total) : done,
+				total: unit === "tasks" ? null : total,
+				line,
+				updatedAt
+			};
+		}
+	};
+}
+//#endregion
+//#region src/engine/build-progress.ts
+const ACTIVE_BUILD_KEY = "activeBuild";
+const NO_BUILD_PROGRESS = {
+	step: () => {},
+	estimate: () => {},
+	miss: () => {},
+	hit: () => {},
+	deviceSetup: () => {},
+	deviceSetupKnown: () => void 0,
+	place: () => {},
+	waitingOn: () => {},
+	waitingFor: () => {},
+	output: () => {},
+	durations: () => ({}),
+	steps: () => null,
+	clear: () => {}
+};
+/** `writer`, with each record it writes also passed to `progress.output`. */
+function tapBuildLog(writer, progress) {
+	if (progress === NO_BUILD_PROGRESS) return writer;
+	return {
+		get file() {
+			return writer.file;
+		},
+		write(record) {
+			progress.output(record);
+			return writer.write(record);
+		},
+		close: () => writer.close(),
+		get written() {
+			return writer.written;
+		},
+		get dropped() {
+			return writer.dropped;
+		},
+		get lastError() {
+			return writer.lastError;
+		}
+	};
+}
+const DETAIL_WRITE_MS = 2e3;
+function toolLine(record) {
+	if (!record || typeof record !== "object") return null;
+	const { src, level, msg } = record;
+	return src === "build" && level === "debug" && typeof msg === "string" ? msg : null;
+}
+function writeBuildDetail(root, claimId, detail) {
+	const file = workspaceBuildDetailFile(root);
+	const tmp = `${file}.tmp-${process.pid}`;
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(tmp, JSON.stringify({
+		claimId,
+		detail
+	}));
+	renameSync(tmp, file);
+}
+const COLD_PHASES = [
+	"prebuild",
+	"pods",
+	"compile"
+];
+const HIT_PHASES = ["install", "launch"];
+function settledOutcome(phase, entered) {
+	if (COLD_PHASES.includes(phase)) return "cold";
+	if (phase === "device") return entered.some((entry) => entry.phase === "cache-lookup") ? "hit" : null;
+	return HIT_PHASES.includes(phase) ? "hit" : null;
+}
+function projectHistory(projectKey) {
+	try {
+		return readStats$1().record?.history?.[projectKey];
+	} catch {
+		return;
+	}
+}
+function startBuildProgress({ root, platform, slot, claim, now = Date.now, note = () => {} }) {
+	const startedAt = new Date(now()).toISOString();
+	const record = {
+		platform,
+		slot,
+		startedAt,
+		phase: "prepare",
+		phaseStartedAt: startedAt,
+		phases: [{
+			phase: "prepare",
+			startedAt
+		}],
+		claim: {
+			root: claim.root,
+			path: claim.path,
+			claimId: claim.claimId,
+			pid: claim.owner.pid
+		}
+	};
+	let warned = false;
+	const guard = (fn) => {
+		try {
+			fn();
+		} catch (error) {
+			if (warned) return;
+			warned = true;
+			note(`Build progress could not be recorded in the workspace state: ${error?.message || error}`);
+		}
+	};
+	const write = (before = (state) => state) => guard(() => updateWorkspaceState(root, (state) => ({
+		...before(state),
+		[ACTIVE_BUILD_KEY]: record
+	})));
+	write(withInterruptedBuild);
+	let projectKey = null;
+	const parser = createBuildDetailParser();
+	let detailWrittenAt = -Infinity;
+	let detailTimer = null;
+	const flushDetail = () => {
+		detailTimer = null;
+		detailWrittenAt = now();
+		const detail = parser.detail(new Date(detailWrittenAt).toISOString());
+		if (detail) guard(() => writeBuildDetail(root, record.claim.claimId, detail));
+	};
+	const settle = (outcome) => {
+		record.outcome = outcome;
+		if (projectKey && platform !== "macos") record.estimate = estimateBuild(projectHistory(projectKey), platform, outcome, record.deviceSetup);
+	};
+	const waits = /* @__PURE__ */ new Map();
+	return {
+		step(phase) {
+			if (phase === record.phase) return;
+			const at = new Date(now()).toISOString();
+			record.phase = phase;
+			record.phaseStartedAt = at;
+			record.phases.push({
+				phase,
+				startedAt: at
+			});
+			if (phase !== "wait") delete record.waitingOn;
+			const outcome = record.outcome || platform === "macos" ? null : settledOutcome(phase, record.phases);
+			if (outcome) settle(outcome);
+			write();
+		},
+		estimate(key) {
+			if (platform === "macos") return;
+			projectKey = key;
+			record.estimate = estimateBuild(projectHistory(key), platform, record.outcome ?? null, record.outcome ? record.deviceSetup : void 0);
+			write();
+		},
+		miss(reason, provisional = false) {
+			record.missReason = reason;
+			settle("cold");
+			if (provisional) record.missProvisional = true;
+			else delete record.missProvisional;
+			write();
+		},
+		hit() {
+			delete record.missReason;
+			delete record.missProvisional;
+			settle("hit");
+			write();
+		},
+		deviceSetup(setup) {
+			if (setup === void 0) return;
+			record.deviceSetup = setup;
+			write();
+		},
+		deviceSetupKnown() {
+			return record.deviceSetup;
+		},
+		place(remote) {
+			const current = record.placement;
+			if (!remote) {
+				if (!current) return;
+				delete record.placement;
+				return write();
+			}
+			if (current?.host === remote.host && current.phase === remote.phase) return;
+			const at = new Date(now()).toISOString();
+			record.placement = {
+				host: remote.host,
+				phase: remote.phase,
+				startedAt: current?.host === remote.host ? current.startedAt : at,
+				phaseStartedAt: at
+			};
+			write();
+		},
+		waitingFor(info, kind) {
+			if (info) waits.set(info.kind, info);
+			else if (kind) waits.delete(kind);
+			else waits.clear();
+			const first = [...waits.values()].toSorted((a, b) => Date.parse(a.since) - Date.parse(b.since))[0];
+			if (first) record.waitingFor = first;
+			else delete record.waitingFor;
+			write();
+		},
+		waitingOn(holder) {
+			if (holder === null) {
+				if (!record.waitingOn) return;
+				delete record.waitingOn;
+			} else {
+				if (record.waitingOn?.path === holder) return;
+				record.waitingOn = { path: holder };
+			}
+			write();
+		},
+		output(line) {
+			const msg = toolLine(line);
+			if (msg === null || !parser.push(msg) || detailTimer) return;
+			const wait = detailWrittenAt + DETAIL_WRITE_MS - now();
+			if (wait <= 0) return flushDetail();
+			detailTimer = setTimeout(flushDetail, wait);
+			detailTimer.unref?.();
+		},
+		durations() {
+			return phaseDurations(record.phases, now());
+		},
+		steps() {
+			const detail = parser.detail("");
+			return detail?.unit === "steps" ? detail.total : null;
+		},
+		clear() {
+			if (detailTimer) clearTimeout(detailTimer);
+			detailTimer = null;
+			guard(() => rmSync(workspaceBuildDetailFile(root), { force: true }));
+			guard(() => {
+				clearWorkspaceStateKey(root, ACTIVE_BUILD_KEY, (value) => parseActiveBuild(value)?.claim.claimId === record.claim.claimId);
+			});
+		}
+	};
+}
+function phaseDurations(phases, now) {
+	const out = {};
+	phases.forEach(({ phase, startedAt }, index) => {
+		const start = Date.parse(startedAt);
+		const next = phases[index + 1];
+		const end = next ? Date.parse(next.startedAt) : now;
+		if (!Number.isFinite(start) || !Number.isFinite(end)) return;
+		out[phase] = (out[phase] ?? 0) + Math.max(0, end - start);
+	});
+	return out;
+}
+function completedPhaseDurations(phases) {
+	if (phases.length < 2) return void 0;
+	const durations = phaseDurations(phases.slice(0, -1), Date.parse(phases.at(-1).startedAt));
+	return Object.keys(durations).length ? durations : void 0;
+}
+const HISTORY_FIELDS = [
+	"devicePlacement",
+	"platform",
+	"status",
+	"configuration",
+	"fingerprint",
+	"cacheKey",
+	"cacheHit",
+	"cacheSkipped",
+	"durationMs",
+	"startedAt",
+	"errorCode",
+	"missReason",
+	"buildMachine",
+	"builtOn",
+	"offloadedTo",
+	"offloadFallback",
+	"diagnostics",
+	"compileSteps"
+];
+function withHistoryEntry(state, platform, entry) {
+	const saved = state[BUILD_HISTORY_KEY];
+	const history = saved && typeof saved === "object" && !Array.isArray(saved) ? saved : {};
+	const list = Array.isArray(history[platform]) ? history[platform] : [];
+	return {
+		...state,
+		[BUILD_HISTORY_KEY]: {
+			...history,
+			[platform]: [entry, ...list].slice(0, BUILD_HISTORY_LIMIT)
+		}
+	};
+}
+function finishedResult(record) {
+	if (record.status === "ok") return "succeeded";
+	return record.errorCode === "STIM_CANCELLED" ? "cancelled" : "failed";
+}
+function recordFinishedBuild(root, record, { update = updateWorkspaceState, now = Date.now } = {}) {
+	const platform = record.platform;
+	update(root, (state) => {
+		const active = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
+		const own = active?.platform === platform ? active : null;
+		const entry = {
+			...Object.fromEntries(HISTORY_FIELDS.filter((key) => key in record).map((key) => [key, record[key]])),
+			result: finishedResult(record),
+			slot: own?.slot ?? "default",
+			phases: own ? phaseDurations(own.phases, now()) : {}
+		};
+		const slot = own?.slot ?? "default";
+		const slots = isJsonObject(state.deviceSlots) ? state.deviceSlots : {};
+		const savedSlot = isJsonObject(slots[slot]) ? slots[slot] : {};
+		const savedDevice = slot === "default" ? state[platform] : savedSlot[platform];
+		if (platform !== "macos" && (record.devicePlacement || isJsonObject(savedDevice))) {
+			const device = isJsonObject(savedDevice) ? { ...savedDevice } : {};
+			if (record.devicePlacement) device.devicePlacement = record.devicePlacement;
+			else delete device.devicePlacement;
+			state = slot === "default" ? {
+				...state,
+				[platform]: device
+			} : {
+				...state,
+				deviceSlots: {
+					...slots,
+					[slot]: {
+						...savedSlot,
+						[platform]: device
+					}
+				}
+			};
+		}
+		if (platform === "macos") return withHistoryEntry(state, platform, entry);
+		return withHistoryEntry({
+			...state,
+			lastBuild: record,
+			[LAST_BUILD_KEYS[platform]]: record
+		}, platform, entry);
+	});
+}
+/** Adds one phase's duration to the recorded run of `platform` that started at `startedAt`. */
+function recordBuildPhase(root, platform, startedAt, phase, ms) {
+	updateWorkspaceState(root, (state) => {
+		const saved = state[BUILD_HISTORY_KEY];
+		const list = isJsonObject(saved) && Array.isArray(saved[platform]) ? saved[platform] : [];
+		const index = list.findIndex((entry) => isJsonObject(entry) && entry.startedAt === startedAt);
+		const entry = list[index];
+		if (!isJsonObject(entry)) return state;
+		const phases = isJsonObject(entry.phases) ? entry.phases : {};
+		const next = [...list];
+		next[index] = {
+			...entry,
+			phases: {
+				...phases,
+				[phase]: Math.round(ms)
+			}
+		};
+		return {
+			...state,
+			[BUILD_HISTORY_KEY]: {
+				...saved,
+				[platform]: next
+			}
+		};
+	});
+}
+function withInterruptedBuild(state) {
+	const left = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
+	if (!left) return state;
+	const last = left.platform === "macos" ? state[BUILD_HISTORY_KEY]?.macos?.[0] : state[LAST_BUILD_KEYS[left.platform]];
+	if (Date.parse(String(last?.startedAt)) >= Date.parse(left.startedAt)) return state;
+	return withHistoryEntry(state, left.platform, {
+		platform: left.platform,
+		status: "failed",
+		result: "interrupted",
+		slot: left.slot,
+		configuration: null,
+		fingerprint: null,
+		cacheKey: null,
+		cacheHit: false,
+		cacheSkipped: false,
+		durationMs: null,
+		startedAt: left.startedAt,
+		phases: {
+			...phaseDurations(left.phases, Date.parse(left.phaseStartedAt)),
+			[left.phase]: 0
+		}
+	});
+}
+function parseActiveBuild(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const claim = record.claim;
+	if (record.platform !== "ios" && record.platform !== "android" && record.platform !== "macos") return null;
+	if (!isPhase(record.phase)) return null;
+	if (typeof record.startedAt !== "string" || typeof record.phaseStartedAt !== "string") return null;
+	if (!claim || typeof claim.root !== "string" || typeof claim.claimId !== "string") return null;
+	const phases = Array.isArray(record.phases) ? record.phases.filter((entry) => isPhase(entry?.phase) && typeof entry?.startedAt === "string") : [];
+	const missReason = parseMissReason(record.missReason);
+	const placement = parsePlacement(record.placement);
+	const waitingOn = parseWaitingOn(record.waitingOn);
+	const waitingFor = parseWaitingFor(record.waitingFor);
+	const estimate = parseEstimate(record.estimate);
+	return {
+		platform: record.platform,
+		slot: typeof record.slot === "string" ? record.slot : "default",
+		startedAt: record.startedAt,
+		phase: record.phase,
+		phaseStartedAt: record.phaseStartedAt,
+		phases,
+		...missReason ? { missReason } : {},
+		...missReason && record.missProvisional === true ? { missProvisional: true } : {},
+		...placement ? { placement } : {},
+		...waitingOn ? { waitingOn } : {},
+		...waitingFor ? { waitingFor } : {},
+		...typeof record.deviceSetup === "boolean" ? { deviceSetup: record.deviceSetup } : {},
+		...record.outcome === "hit" || record.outcome === "cold" ? { outcome: record.outcome } : {},
+		...estimate ? { estimate } : {},
+		claim: {
+			root: claim.root,
+			path: typeof claim.path === "string" ? claim.path : "",
+			claimId: claim.claimId,
+			pid: typeof claim.pid === "number" ? claim.pid : 0
+		}
+	};
+}
+function parsePlacement(value) {
+	if (!value || typeof value !== "object") return null;
+	const { host, phase, startedAt, phaseStartedAt } = value;
+	if ([
+		host,
+		phase,
+		startedAt,
+		phaseStartedAt
+	].some((field) => typeof field !== "string")) return null;
+	return {
+		host,
+		phase,
+		startedAt,
+		phaseStartedAt
+	};
+}
+function parseWaitingFor(value) {
+	if (!value || typeof value !== "object") return null;
+	const { kind, inUse, max, since } = value;
+	if (kind !== "build-slot" && kind !== "device-slot") return null;
+	if (!Number.isInteger(inUse) || inUse < 0 || !Number.isInteger(max) || max <= 0) return null;
+	if (typeof since !== "string" || !Number.isFinite(Date.parse(since))) return null;
+	return {
+		kind,
+		inUse,
+		max,
+		since
+	};
+}
+function parseWaitingOn(value) {
+	const path = value?.path;
+	return typeof path === "string" && path ? { path } : null;
+}
+function parseEstimate(value) {
+	if (!value || typeof value !== "object") return null;
+	const { outcome, expectedMs, basis, phaseMs, planned } = value;
+	if (outcome !== null && outcome !== "hit" && outcome !== "cold") return null;
+	if (expectedMs !== null && typeof expectedMs !== "number") return null;
+	if (typeof basis !== "number" || !Array.isArray(planned) || !phaseMs || typeof phaseMs !== "object") return null;
+	const durations = Object.entries(phaseMs).filter((entry) => isPhase(entry[0]) && typeof entry[1] === "number");
+	return {
+		outcome,
+		expectedMs,
+		basis,
+		phaseMs: Object.fromEntries(durations),
+		planned: planned.filter(isPhase)
+	};
+}
+function isPhase(value) {
+	return BUILD_PHASES.includes(value);
+}
+function activeBuildState(claim, survey = (0, ownership_claim_exports.readClaimSet)(claim.root)) {
+	if (survey.live.some((holder) => holder.claimId === claim.claimId)) return "running";
+	if (survey.dead.some((holder) => holder.claimId === claim.claimId)) return "stale";
+	return survey.unresolved.length ? "unknown" : "stale";
+}
+function median(values) {
+	if (!values.length) return null;
+	const sorted = values.toSorted((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	return sorted.length % 2 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
+}
+function estimateBuild(history, platform, known, deviceSetup) {
+	const lists = platform === "macos" ? void 0 : history?.[platform];
+	const outcome = known ?? latestOutcome(lists);
+	const samples = matchDeviceSetup(outcome && lists?.[outcome] || [], deviceSetup);
+	const phaseMs = {};
+	const planned = [];
+	for (const phase of BUILD_PHASES) {
+		const durations = samples.flatMap((sample) => phase in sample.phases ? [sample.phases[phase]] : []);
+		const ms = median(durations);
+		if (ms === null) continue;
+		phaseMs[phase] = ms;
+		if (durations.length * 2 >= samples.length) planned.push(phase);
+	}
+	return {
+		outcome,
+		expectedMs: median(samples.map((sample) => sample.durationMs)),
+		basis: samples.length,
+		phaseMs,
+		planned
+	};
+}
+const MIN_TAGGED_SAMPLES = 3;
+function matchDeviceSetup(samples, deviceSetup) {
+	if (deviceSetup === void 0) return samples;
+	const tagged = samples.filter((sample) => sample.deviceSetup === deviceSetup);
+	if (deviceSetup || tagged.length >= MIN_TAGGED_SAMPLES) return tagged;
+	return samples.filter((sample) => sample.deviceSetup !== true);
+}
+function latestOutcome(lists) {
+	let latest = null;
+	for (const outcome of ["hit", "cold"]) {
+		const last = lists?.[outcome]?.at(-1);
+		const at = last ? Date.parse(last.at) : NaN;
+		if (Number.isFinite(at) && (!latest || at > latest.at)) latest = {
+			outcome,
+			at
+		};
+	}
+	return latest?.outcome ?? null;
+}
+function buildReport(record, { state, history }) {
+	const estimate = record.estimate ?? estimateBuild(history, record.platform, record.outcome ?? null, record.outcome ? record.deviceSetup : void 0);
+	const plannedPhases = estimate.planned.flatMap((phase) => {
+		const expectedMs = estimate.phaseMs[phase];
+		return expectedMs === void 0 ? [] : [{
+			phase,
+			expectedMs
+		}];
+	});
+	const completedPhaseMs = completedPhaseDurations(record.phases);
+	return {
+		platform: record.platform,
+		slot: record.slot,
+		state,
+		phase: record.phase,
+		startedAt: record.startedAt,
+		phaseStartedAt: record.phaseStartedAt,
+		outcome: estimate.outcome,
+		outcomeKnown: record.outcome !== void 0,
+		...record.outcome && record.phases.some(({ phase }) => phase === "cache-lookup") ? { cacheLookupOutcome: record.outcome === "hit" ? "hit" : "miss" } : {},
+		expectedMs: estimate.expectedMs,
+		expectedPhaseMs: estimate.phaseMs[record.phase] ?? null,
+		...completedPhaseMs ? { completedPhaseMs } : {},
+		basis: estimate.basis,
+		plannedPhases: plannedPhases.length ? plannedPhases : null,
+		...record.missReason ? { missReason: record.missReason } : {},
+		...record.missReason && record.missProvisional ? { missProvisional: true } : {},
+		placement: record.placement ?? "local",
+		...record.waitingOn ? { waitingOn: record.waitingOn } : {},
+		...record.waitingFor ? { waitingFor: record.waitingFor } : {}
+	};
+}
+function remainingText(remainingMs) {
+	return remainingMs < 6e4 ? "under a minute left" : `about ${Math.ceil(remainingMs / 6e4)} min left`;
+}
+function buildStatusLine(report, now) {
+	const slot = report.slot === "default" ? "" : ` [${report.slot}]`;
+	if (report.state === "stale") return `build: stale ${report.platform}${slot} record from ${report.startedAt} (its run is gone; the next run replaces it)`;
+	const elapsedMs = Math.max(0, now - Date.parse(report.startedAt));
+	const remote = typeof report.placement === "object" ? ` on ${report.placement.host} (${report.placement.phase}, ${formatElapsed(Math.max(0, now - Date.parse(report.placement.phaseStartedAt)))})` : "";
+	const waiting = report.waitingOn ? ` on ${report.waitingOn.path}` : "";
+	const head = `build: ${report.platform}${slot} ${report.phase}${waiting}${remote}, ${formatElapsed(elapsedMs)} elapsed`;
+	if (report.state === "unknown") return `${head} (its native-run claim cannot be resolved, so it may not be running)`;
+	if (report.expectedMs === null) return head;
+	const basis = `median of ${plural(report.basis, `${report.outcome} run`)}`;
+	const remainingMs = report.expectedMs - elapsedMs;
+	return remainingMs > 0 ? `${head} -- ${remainingText(remainingMs)} (${basis})` : `${head} (usually ~${formatElapsed(report.expectedMs)}, ${basis})`;
+}
+//#endregion
+//#region src/commands/gc/idle.ts
+function findOwnedDeviceActivity({ config, sims, androidSerial, readActivity, deadProjects = [] }) {
+	const booted = new Map(sims.filter((sim) => sim.state === "Booted").map((sim) => [sim.udid, sim.name]));
+	const dead = new Set(deadProjects);
+	const found = [];
+	for (const [project, record] of Object.entries(config?.projects ?? {})) {
+		if (dead.has(project)) continue;
+		for (const { slot, platforms } of projectDeviceSlots(record)) {
+			const ios = platforms.ios;
+			if (ios?.owned && ios.deviceUdid && booted.has(ios.deviceUdid)) found.push({
+				kind: "ios",
+				id: ios.deviceUdid,
+				name: booted.get(ios.deviceUdid) ?? ios.deviceUdid,
+				project,
+				slot,
+				activity: readActivity({
+					platform: "ios",
+					id: ios.deviceUdid,
+					slot,
+					workspace: project
+				})
+			});
+			const android = platforms.android;
+			const serial = android?.owned && android.avdName ? androidSerial(android.avdName) : null;
+			if (android?.avdName && serial) found.push({
+				kind: "android",
+				id: android.avdName,
+				name: android.avdName,
+				project,
+				slot,
+				activity: readActivity({
+					platform: "android",
+					id: serial,
+					slot,
+					workspace: project
+				})
+			});
+		}
+	}
+	return found;
+}
+function findIdleDevices({ buildInProgress, now, ...inputs }) {
+	return findOwnedDeviceActivity(inputs).filter((device) => device.activity.state === "idle").map(({ kind, id, name, project, slot, activity }) => ({
+		kind,
+		id,
+		name,
+		project,
+		slot,
+		lastActivityAt: activity.lastActivityAt ?? null,
+		idleForMs: idleForMs(activity, now),
+		buildInProgress: buildInProgress(project)
+	}));
+}
+function idleShutdownCandidates(devices, idleMs) {
+	return devices.filter((d) => !d.buildInProgress && d.idleForMs !== null && d.idleForMs >= idleMs);
+}
+function parseIdleDuration(value) {
+	const match = /^([1-9][0-9]*)(m|h|d)$/.exec(value.trim());
+	if (!match) return null;
+	const unit = {
+		m: 6e4,
+		h: 36e5,
+		d: 864e5
+	}[match[2]];
+	return Number(match[1]) * unit;
+}
+function workspaceBuildInProgress(project) {
+	const record = parseActiveBuild(readWorkspaceState$1(project)?.[ACTIVE_BUILD_KEY]);
+	if (!record) return false;
+	try {
+		return activeBuildState(record.claim) !== "stale";
+	} catch {
+		return true;
+	}
+}
+function deviceActivityInputs(config, sims, now) {
+	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
+	return {
+		config,
+		sims,
+		readActivity: createActivityReader({ now }),
+		androidSerial: (avdName) => {
+			try {
+				return resolve(avdName).serial ?? null;
+			} catch {
+				return null;
+			}
+		}
+	};
+}
+function collectOwnedDeviceActivity(config, sims, now = Date.now()) {
+	return findOwnedDeviceActivity(deviceActivityInputs(config, sims, now));
+}
+function collectIdleDevices(config, sims, deadProjects, now = Date.now()) {
+	return findIdleDevices({
+		...deviceActivityInputs(config, sims, now),
+		deadProjects,
+		now,
+		buildInProgress: workspaceBuildInProgress
+	});
+}
+function idleDeviceLines(devices) {
+	if (devices.length === 0) return [];
+	return [`Idle owned devices (${devices.length}) - booted with no driver, claim, or recent activity:`, ...devices.map((d) => {
+		const slot = d.slot === "default" ? "" : ` [${d.slot}]`;
+		const idle = d.idleForMs === null ? "idle for an unknown time" : `idle ${formatLongDuration(d.idleForMs)}`;
+		const build = d.buildInProgress ? ", build in progress" : "";
+		return `  ${d.kind}${slot} ${d.name} (${d.project}) -- ${idle}${build}`;
+	})];
+}
+function shutDownIdleDevices(devices, idleMs, recollect) {
+	const candidates = idleShutdownCandidates(devices, idleMs);
+	const shutDown = [];
+	if (candidates.length === 0) {
+		console.log(chalk.dim(`No owned device has been idle for ${formatLongDuration(idleMs)} or more.`));
+		return {
+			failures: 0,
+			shutDown
+		};
+	}
+	const fresh = idleShutdownCandidates(recollect(), idleMs);
+	let failures = 0;
+	for (const device of candidates) {
+		const what = `${device.kind} ${device.name}`;
+		const current = fresh.find((d) => d.kind === device.kind && d.id === device.id && d.project === device.project && d.slot === device.slot);
+		if (!current) {
+			console.log(chalk.dim(`Kept ${what}: it is no longer idle for ${formatLongDuration(idleMs)}.`));
+			recordGcResult("idleDevice", "kept", device.name, {
+				id: device.id,
+				detail: `it is no longer idle for ${formatLongDuration(idleMs)}`
+			});
+			continue;
+		}
+		const outcome = device.kind === "ios" ? teardownOwnedIosSim(device.id, { label: device.name }) : teardownOwnedAvd(device.id, { owner: {
+			projectPath: device.project,
+			slot: device.slot
+		} });
+		if (outcome.status === "torn-down") {
+			shutDown.push(device);
+			console.log(chalk.green(`Shut down ${what}, idle ${formatLongDuration(current.idleForMs)}`));
+			recordGcResult("idleDevice", "done", device.name, {
+				id: device.id,
+				detail: `idle ${formatLongDuration(current.idleForMs)}`
+			});
+		} else if (outcome.status === "missing") console.log(chalk.dim(`${what} is already gone; nothing to shut down.`));
+		else if (outcome.status === "skipped") {
+			console.log(chalk.yellow(`Skipped ${what}: ${outcome.reason}`));
+			recordGcResult("idleDevice", "kept", device.name, {
+				id: device.id,
+				detail: outcome.reason
+			});
+		} else {
+			failures++;
+			console.log(chalk.red(`Failed to shut down ${what}: ${outcome.reason}`));
+			recordGcResult("idleDevice", "failed", device.name, {
+				id: device.id,
+				detail: outcome.reason
+			});
+		}
+	}
+	return {
+		failures,
+		shutDown
+	};
+}
+//#endregion
+//#region src/supervisor/stop-cause.ts
+function requestDevServerStop(root, processToken, requester) {
+	if (!processToken) return;
+	try {
+		writeWorkspaceState(root, { [DEV_SERVER_STOP_REQUEST_KEY]: {
+			processToken,
+			by: requester.by,
+			pid: process.pid,
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			...requester.workspace ? { workspace: requester.workspace } : {}
+		} });
+	} catch {}
+}
+function withdrawDevServerStopRequest(root, processToken) {
+	if (!processToken) return;
+	try {
+		clearWorkspaceStateKey(root, DEV_SERVER_STOP_REQUEST_KEY, (value) => {
+			return readDevServerStopRequest({ [DEV_SERVER_STOP_REQUEST_KEY]: value })?.processToken === processToken;
+		});
+	} catch {}
+}
+function devServerStopRecord(trigger, request, at) {
+	if (request) return {
+		reason: "requested",
+		at,
+		by: request.by,
+		byPid: request.pid,
+		...request.workspace ? { byWorkspace: request.workspace } : {}
+	};
+	return trigger.kind === "signal" ? {
+		reason: "signal",
+		at,
+		signal: trigger.signal
+	} : {
+		reason: "server-exited",
+		at,
+		mode: trigger.mode,
+		code: trigger.code,
+		signal: trigger.signal
+	};
+}
+function describeDevServerStop(record) {
+	if (record.reason === "idle") return `idle for ${record.idleMinutes} minutes (metro.idleStopMinutes)`;
+	if (record.reason === "requested") return `stop requested by ${record.by} (pid ${record.byPid}${record.byWorkspace ? ` in ${record.byWorkspace}` : ""})`;
+	if (record.reason === "signal") return `received ${record.signal} with no Stim stop request recorded, so it likely came from outside Stim`;
+	const detail = record.signal ? `signal ${record.signal}` : `exit code ${record.code ?? "unknown"}`;
+	const expoSignal = record.mode === "expo-child" && record.code === 0 ? "; Expo CLI also exits 0 on SIGTERM, and no Stim stop request was recorded" : "";
+	return `the ${record.mode} dev server exited unexpectedly (${detail})${expoSignal}`;
+}
+function devServerStopLevel(record) {
+	if (record.reason === "server-exited") return "error";
+	return record.reason === "signal" ? "warn" : "info";
+}
+/** The log line for a recorded supervisor whose process is proven gone, or null while it may still run. */
+function vanishedSupervisorMessage(record) {
+	if (!record || typeof record.pid !== "number") return null;
+	const identity = (0, process_identity_exports.inspectProcessIdentity)(record);
+	if (identity !== "gone" && identity !== "different") return null;
+	const started = typeof record.startedAt === "string" ? ` (started ${record.startedAt})` : "";
+	return `supervisor pid ${record.pid}${started} ${VANISHED}`;
+}
+const VANISHED = "is gone and recorded no cause: usually SIGKILL, a crash or a machine restart";
+function logVanishedSupervisor(root, record) {
+	const msg = vanishedSupervisorMessage(record);
+	if (!msg) return;
+	const writer = createNdjsonWriter(join(workspaceLogsDir$1(root), "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
+	writer.write({
+		src: "metro",
+		level: "warn",
+		event: "supervisor_vanished",
+		msg
+	});
+	writer.close();
+}
+/** The recorded stop, else a vanished supervisor when status proved the recorded one gone. */
+function metroLastStop(state, supervisor) {
+	const recorded = readDevServerStop(state);
+	if (recorded) return recorded;
+	if (supervisor?.status !== "stale" || typeof supervisor.pid !== "number") return null;
+	const startedAt = typeof supervisor.startedAt === "string" ? supervisor.startedAt : null;
+	return {
+		reason: "vanished",
+		pid: supervisor.pid,
+		startedAt
+	};
+}
+function describeMetroLastStop(stop) {
+	return stop.reason === "vanished" ? `supervisor pid ${stop.pid} ${VANISHED}` : describeDevServerStop(stop);
+}
+//#endregion
 //#region src/supervisor/cache-reset.ts
 async function stopOwnedMetro(root, requester) {
 	const project = getProject(root);
@@ -2163,7 +3673,6 @@ async function stopOwnedMetroForReset(root) {
 const MB = 1048576;
 const GB_IN_MB = 1024;
 const COMMITTED_MEMORY_SHARE = .6;
-const STALE_CACHE_DAYS = 14;
 const DEVICE_LIST_TIMEOUT_MS = 1e4;
 const USAGE_TIMEOUT_MS = 1e4;
 const BUDGET_SETTING_REMEDY = "Fix the value with `stim settings set <key> <value>`, or unset the environment variable. Run `stim guide settings` for the budget keys.";
@@ -2207,7 +3716,7 @@ function machineNumber(key, config, env) {
 		error: null
 	};
 }
-function resolveBudget({ config = loadConfig$1(), env = process.env, totalMemoryMb = totalmem$1() / MB } = {}) {
+function resolveBudget({ config = loadConfig$1(), env = process.env, totalMemoryMb = totalmem() / MB } = {}) {
 	const minFree = machineNumber("budget.minFreeDiskGb", config, env);
 	const hardFloor = machineNumber("budget.hardFloorDiskGb", config, env);
 	const memory = machineNumber("budget.maxCommittedMemoryGb", config, env);
@@ -2280,6 +3789,13 @@ function listSims() {
 		return null;
 	}
 }
+function snapshotSims(snapshot) {
+	try {
+		return snapshot.read().filter((sim) => sim.available);
+	} catch {
+		return null;
+	}
+}
 function runningSupervisorPid(path, project) {
 	const target = resolveSupervisorTarget({
 		state: readWorkspaceState$1(path)?.supervisor,
@@ -2288,11 +3804,11 @@ function runningSupervisorPid(path, project) {
 	});
 	return target.status === "ours" ? target.pid ?? null : null;
 }
-function readMemoryUse() {
+function readMemoryUse(simSnapshot) {
 	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
 	return estimateMemoryUse({
 		config: loadConfig$1(),
-		sims: listSims(),
+		sims: simSnapshot ? snapshotSims(simSnapshot) : listSims(),
 		androidSerial: (avdName) => {
 			try {
 				return resolve(avdName).serial ?? null;
@@ -2475,14 +3991,17 @@ async function reclaimWorkspaceOutputs({ root, dryRun, now, diskRecovered }) {
 function cacheLabel(cache) {
 	return `${cache.name} ${cache.dir}`;
 }
+function trimmableCaches() {
+	return planCacheEmptying(discoverCaches(), false).filter((cache) => cache.prune !== "report-only" && cache.prune !== "atomic" && !cache.machineGlobal);
+}
 function reclaimStaleCacheEntries({ dryRun }) {
-	const caches = planCacheEmptying(discoverCaches(), false).filter((cache) => cache.prune !== "report-only" && cache.prune !== "atomic" && !cache.machineGlobal);
+	const caches = trimmableCaches();
 	if (dryRun) return {
 		targets: caches.map(cacheLabel),
 		failures: 0
 	};
 	return {
-		targets: trimCaches(caches, STALE_CACHE_DAYS).map(cacheLabel),
+		targets: trimCaches(caches, 14).map(cacheLabel),
 		failures: 0
 	};
 }
@@ -2496,7 +4015,7 @@ const STEP_ACTIONS = {
 	"idle-devices": "shut down idle owned devices",
 	"idle-dev-servers": "stop idle dev servers",
 	"workspace-outputs": "clear build outputs of idle workspaces",
-	"stale-cache-entries": `trim cache entries unused for ${STALE_CACHE_DAYS} days`
+	"stale-cache-entries": `trim cache entries unused for 14 days`
 };
 async function runStep(step, context) {
 	const log = console.log;
@@ -2520,7 +4039,7 @@ async function runStep(step, context) {
 	}
 }
 function spaceUsers() {
-	const home = homedir$1();
+	const home = homedir();
 	const candidates = [
 		["Stim state", getConfigDir()],
 		["shared build cache", sharedBuildCache()],
@@ -2555,10 +4074,10 @@ function describeShortfall(budget, measure, short) {
 	return [
 		...short.disk.map((v) => `${formatSpace(v.freeMb)} free on ${v.volume}, below the ${formatSpace(floor)} floor`),
 		...short.memory && measure.memory ? [`roughly ${formatSpace(measure.memory.committedMb)} of memory committed, over the ${formatSpace(budget.maxCommittedMemoryMb)} budget`] : [],
-		...short.workspaces && measure.memory ? [`${measure.memory.liveWorkspaces} live workspaces, over the limit of ${budget.maxLiveWorkspaces}`] : []
+		...short.workspaces && measure.memory ? [`${measure.memory.liveWorkspaces} active workspaces, over the limit of ${budget.maxLiveWorkspaces}`] : []
 	];
 }
-async function enforceBudget({ root, note, dryRun = false, budget: resolved }, overrides = {}) {
+async function enforceBudget({ root, note, dryRun = false, budget: resolved, simSnapshot }, overrides = {}) {
 	const deps = {
 		...DEFAULT_DEPS,
 		...overrides
@@ -2579,7 +4098,7 @@ async function enforceBudget({ root, note, dryRun = false, budget: resolved }, o
 	const paths = [root, getConfigDir()];
 	const measureNow = () => ({
 		volumes: budget.minFreeDiskMb > 0 || budget.hardFloorDiskMb > 0 ? deps.volumes(paths) : [],
-		memory: budget.maxCommittedMemoryMb > 0 || budget.maxLiveWorkspaces > 0 ? deps.memory() : null
+		memory: budget.maxCommittedMemoryMb > 0 || budget.maxLiveWorkspaces > 0 ? deps.memory(simSnapshot) : null
 	});
 	let measure = measureNow();
 	let short = budgetShortfalls(budget, measure);
@@ -2600,6 +4119,7 @@ async function enforceBudget({ root, note, dryRun = false, budget: resolved }, o
 			}).disk.length === 0
 		});
 		if (!dryRun) {
+			simSnapshot?.invalidate();
 			measure = measureNow();
 			short = budgetShortfalls(budget, measure);
 		}
@@ -2677,12 +4197,12 @@ function budgetFindings(budget, measure, short, plan) {
 	}
 	if (short.memory || short.workspaces) findings.push({
 		level: "note",
-		title: "Live environments are over the memory budget",
+		title: "Active environments are over the memory budget",
 		detail: `${describeShortfall(budget, measure, {
 			...short,
 			disk: []
 		}).join("; ")}. The next ios, android or start shuts down idle owned devices and stops idle dev servers in other workspaces first.`,
-		fix: "Run `stim status` to see what is live, and `stim stop` in workspaces you own that you no longer need."
+		fix: "Run `stim status` to see what is active, and `stim stop` in workspaces you own that you no longer need."
 	});
 	return findings;
 }
@@ -2734,4 +4254,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 { sizeCaches as $, includesWorkspaceOutputs as A, collectMemoryReport as B, findStaleProjectDevices as C, includesArchives as D, emptyCaches as E, selectsBeyondCaches as F, memorySweepIsScoped as G, memoryCacheKind as H, trimCaches as I, scopedMemoryReport as J, memoryWorkPending as K, parseArchiveSelector as L, planCacheEmptying as M, previewScopedEmptying as N, includesParkedDevices as O, selectCaches as P, discoverCaches as Q, GRADLE_DAEMONS_KIND as R, findStaleDeviceRecords as S, withAndroidAvdSizes as T, memoryLines as U, inspectWatchmanMemory as V, memoryScope as W, attributeMachineUsage as X, phase as Y, readFootprints as Z, describeParkedSims as _, machineNumber as a, eraseParkedDevices as b, resolveBudget as c, collectDeviceLeases as d, collectParkedAvds as f, deleteProjectDevices as g, deleteParkedSims as h, inspectBudget as i, isWorkspacesScope as j, includesRecordings as k, stopOwnedMetroForReset as l, deleteParkedAvds as m, budgetLine as n, peekBudget as o, collectParkedSims as p, reclaimMemory as q, enforceBudget as r, readVolumeSpace as s, budgetGate as t, DEVICE_LIST_TIMEOUT_MS$1 as u, describeUnverifiableDevices as v, unverifiedDeviceCommand as w, findOrphanedDevices as x, deviceSweepIsScoped as y, WATCHMAN_KIND as z };
+export { describeUnverifiableDevices as $, sizeCaches as $t, buildReport as A, phase as At, readStats$1 as B, clearWorkspaceLaunches as Bt, idleDeviceLines as C, memoryCacheKind as Ct, ACTIVE_BUILD_KEY as D, memoryWorkPending as Dt, workspaceBuildInProgress as E, memorySweepIsScoped as Et, recordFinishedBuild as F, MODE_BARE as Ft, DEVICE_LIST_TIMEOUT_MS$1 as G, readRemoteSessionId as Gt, recordCapacityWait as H, readMetroTunnel as Ht, startBuildProgress as I, MODE_EXPO as It, collectParkedSims as J, writeWorkspaceLaunch as Jt, collectDeviceLeases as K, readWorkspaceLaunches as Kt, tapBuildLog as L, clearExpoMetroTunnel as Lt, estimateBuild as M, parseTriggerCount as Mt, parseActiveBuild as N, parseWatchRoots as Nt, NO_BUILD_PROGRESS as O, reclaimMemory as Ot, recordBuildPhase as P, runWatchman as Pt, describeParkedSims as Q, pruneCache as Qt, createRunRecorder as R, clearManagedMetroTunnel as Rt, collectOwnedDeviceActivity as S, inspectWatchmanMemory as St, shutDownIdleDevices as T, memoryScope as Tt, recordRunStats as U, readPidFile as Ut, recordCapacityRefusal as V, clearWorkspaceSupervisor as Vt, statsProjectKey$1 as W, readRemoteSession as Wt, deleteParkedSims as X, readFootprints as Xt, deleteParkedAvds as Y, attributeMachineUsage as Yt, deleteProjectDevices as Z, discoverCaches as Zt, metroLastStop as _, trimCaches as _t, inspectBudget as a, unverifiedDeviceCommand as at, withdrawDevServerStopRequest as b, WATCHMAN_KIND as bt, readVolumeSpace as c, includesArchives as ct, stopOwnedMetroForReset as d, includesWorkspaceOutputs as dt, deviceSweepIsScoped as et, describeDevServerStop as f, isWorkspacesScope as ft, logVanishedSupervisor as g, selectsBeyondCaches as gt, devServerStopRecord as h, selectCaches as ht, enforceBudget as i, findStaleProjectDevices as it, buildStatusLine as j, parseSubscriberNames as jt, activeBuildState as k, scopedMemoryReport as kt, resolveBudget as l, includesParkedDevices as lt, devServerStopLevel as m, previewScopedEmptying as mt, budgetLine as n, findOrphanedDevices as nt, machineNumber as o, withAndroidAvdSizes as ot, describeMetroLastStop as p, planCacheEmptying as pt, collectParkedAvds as q, writePidFile as qt, cacheLabel as r, findStaleDeviceRecords as rt, peekBudget as s, emptyCaches as st, budgetGate as t, eraseParkedDevices as tt, trimmableCaches as u, includesRecordings as ut, requestDevServerStop as v, parseArchiveSelector as vt, parseIdleDuration as w, memoryLines as wt, collectIdleDevices as x, collectMemoryReport as xt, vanishedSupervisorMessage as y, GRADLE_DAEMONS_KIND as yt, readRunEstimates as z, clearRemoteSession as zt };