stim 1.25.0 → 1.27.0

package/dist/{act-BbHS3oV8.mjs → act-ROviTF_t.mjs}

@@ -1,29 +1,30 @@
-import { l as WorkspaceProcessCleanupError, n as isTimeoutError, t as getExecutor } from "./exec-VFRpu1iA.mjs";
-import { g as workspaceStateFile$1, m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
-import { F as isOnMountedVolume, G as projectDeviceSlots, I as listMountedVolumes, L as measuredDirectorySizeAsync, N as directorySizeAsync, P as formatBytes, _ as loadConfig$1, p as getProject } from "./config-BZhXY15H.mjs";
-import { o as formatLongDuration, u as plural } from "./command-output-BBvS1H6v.mjs";
-import { c as gitQuiet, l as gitQuietAsync, n as runOperationFileQuiet, r as childEnvironment } from "./operation-exec-CUZifp6Z.mjs";
-import { r as readWorkspaceState$1, u as workspaceLastUsed } from "./workspace-state-CPSp3mav.mjs";
-import { Bt as unpushedCommitsAsync, Ct as hasUncommittedWorkAsync, D as maintenanceKeepSetting, Dt as listWorktreesAsync, Et as listWorktrees, Gt as removeTemporaryEntryAsync, It as resolveFullRefAsync, J as resolveProjectSettings, Lt as resolveSourceCheckoutAsync, Y as resolveProjectSettingsAsync, _t as dirtyPathsAsync, xt as hasPopulatedSubmodulesAsync, zt as sourceCheckoutOf } from "./settings-B5tCoq9N.mjs";
-import { i as findProjectRoot$1 } from "./project-BiC68mIp.mjs";
-import { F as listAvdsAsync, G as ownedAvdSerialResolverAsync, P as listAvds, V as ownedAvdDirectory, yt as readParked } from "./android-Cjcj8MCw.mjs";
-import { a as unregister, n as readManifest } from "./cache-manifest-BPXRONJz.mjs";
-import { A as workspaceBuildInProgress, Cr as discoverCaches, Ct as deleteParkedSims, Dt as deviceSweepIsScoped, E as collectOwnedDeviceActivityAsync, Q as emptyCaches, St as deleteParkedAvds, T as collectOwnedDeviceActivity, br as phase, bt as collectParkedAvds, d as trimmableCaches, f as stopOwnedMetro, hr as memorySweepIsScoped, ht as waitForGradleExit, i as enforceBudget, it as planCacheEmptying, jt as findStaleProjectDevices, lt as collectGradleVersions, o as machineNumber, r as cacheLabel, u as resolveBudget, ur as collectMemoryReport, ut as deleteGradleVersion, vt as DEVICE_LIST_TIMEOUT_MS, wr as pruneCache, wt as deleteProjectDevices, xt as collectParkedSims, yr as stopIdleGradleDaemons } from "./budget-HyShrIpL.mjs";
+import { l as WorkspaceProcessCleanupError, n as isTimeoutError, t as getExecutor } from "./exec-aULwtNly.mjs";
+import { j as workspaceStateFile$1, k as workspaceLogsDir$1, r as readWorkspaceState$1, u as workspaceLastUsed } from "./workspace-state-BjqdjnJR.mjs";
+import { F as isOnMountedVolume, G as projectDeviceSlots, I as listMountedVolumes, L as measuredDirectorySizeAsync, N as directorySizeAsync, P as formatBytes, _ as loadConfig$1, p as getProject } from "./config-Cn94Jc0g.mjs";
+import { o as formatLongDuration, u as plural } from "./command-output-Dj-WT4BP.mjs";
+import { c as gitQuiet, l as gitQuietAsync, n as runOperationFileQuiet, r as childEnvironment } from "./operation-exec-Dp4FuIGR.mjs";
+import { At as listWorktreesAsync, Bt as resolveSourceCheckoutAsync, Ct as hasPopulatedSubmodulesAsync, Ht as sourceCheckoutOf, O as maintenanceKeepSetting, Tt as hasUncommittedWorkAsync, Ut as unpushedCommitsAsync, X as resolveProjectSettings, Z as resolveProjectSettingsAsync, h as deviceIdleShutdownMinutesSetting, kt as listWorktrees, tn as removeTemporaryEntryAsync, yt as dirtyPathsAsync, zt as resolveFullRefAsync } from "./settings-BDVI8Ivc.mjs";
+import { i as findProjectRoot$1 } from "./project-DYj-HVx6.mjs";
+import { F as listAvdsAsync, G as ownedAvdSerialResolverAsync, P as listAvds, V as ownedAvdDirectory, yt as readParked } from "./android-DriNoAVy.mjs";
+import { A as diskPressureLevel, G as planCacheEmptying, N as lowestFree, P as protectWindowMs, X as collectGradleVersions, Z as deleteGradleVersion, Zn as collectMemoryReport, _ as resolveBudget, at as DEVICE_LIST_TIMEOUT_MS, ct as collectParkedSims, d as enforceBudget, dr as pruneCache, dt as deleteProjectDevices, j as levelFloors, lt as deleteParkedAvds, mt as deviceSweepIsScoped, nr as memorySweepIsScoped, nt as waitForGradleExit, or as stopIdleGradleDaemons, p as machineNumber, sr as phase, st as collectParkedAvds, u as cacheLabel, ur as discoverCaches, ut as deleteParkedSims, v as trimmableCaches, vt as findStaleProjectDevices, y as stopOwnedMetro, z as emptyCaches } from "./ccache-BWTze1Ls.mjs";
+import { a as unregister, n as readManifest } from "./cache-manifest-DEjqGGat.mjs";
+import { Dt as readConcurrency, L as workspaceBuildInProgress, M as collectOwnedDeviceActivityAsync, St as GC_OUTPUT, Tt as eachLimited, _ as withIdleWorkspace, a as collectOrphanedWorkspaces, c as isInsideWorkspaces, h as ARTIFACT_DIRS, i as clearWorkspaceOutputs, j as collectOwnedDeviceActivity, l as listWorkspaceDirs, m as workspaceDirRemoved, o as collectWorkspaceOutputs, p as workspaceBuildReasons, s as deleteOrphanedWorkspaces, t as LIGHTEN_AFTER_MS, u as recentNativeUseReason, v as workspaceInUse, wt as takeGcResults, y as workspaceInUseAsync } from "./workspaces-DFbj07jp.mjs";
 import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { B as GC_OUTPUT, H as takeGcResults, a as collectWorkspaceOutputs, c as listWorkspaceDirs, d as workspaceDirRemoved, h as workspaceInUseAsync, i as collectOrphanedWorkspaces, m as workspaceInUse, o as deleteOrphanedWorkspaces, p as withIdleWorkspace, r as clearWorkspaceOutputs, s as isInsideWorkspaces } from "./workspaces-C9w4aeXF.mjs";
-import { N as listBuildLocks, b as leaseIsExpired, g as workspaceActivity, x as listLeaseFiles } from "./activity-BpjwrQXU.mjs";
-import { d as listAllIosSims, f as listAllIosSimsAsync } from "./ios-BQzvJlzw.mjs";
+import { N as listBuildLocks, _ as workspaceDeviceLastUseAt, b as leaseIsExpired, g as workspaceActivity, x as listLeaseFiles } from "./activity-Cd-ysFes.mjs";
+import { d as listAllIosSims, f as listAllIosSimsAsync } from "./ios-E26qSpkb.mjs";
 import { s as metroStoreRoot } from "./errors-DHm_U5gv.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
-import { A as measurePressureAsync, D as measureDisk, E as cacheBlocked, I as lowestFree, L as protectWindowMs, N as diskPressureLevel, O as measureDiskAsync, P as levelFloors, a as matchWorktreeEntry, c as reclaimKeys, i as excludeWatchmanCookies, k as measurePressure, m as removeWorktreeTarget, o as nestedWorktrees, r as excludePodChurn, s as porcelainPath } from "./worktree-CclFIe1Z.mjs";
-import { c as FETCH_FRESH_MS, d as localDefaultBranchAsync, l as fetchDefaultBranchAsync, o as recordPullRequestLookup, p as mergeStateAsync, u as lastFetchedAtAsync } from "./warm-progress-BV3ZPmcY.mjs";
-import { n as describePullRequest, r as endedPullRequest, s as pullRequestLookups } from "./pull-request-CbNlkFok.mjs";
+import { D as stimCliEntries, E as serviceRunningFrom, N as worktreeArchiveLimits, O as stimCliUseOf, S as measurePressureAsync, T as uncommittedActivityOf, a as matchWorktreeEntry, b as measureDiskAsync, c as reclaimKeys, i as excludeWatchmanCookies, m as removeWorktreeTarget, o as nestedWorktrees, r as excludePodChurn, s as porcelainPath, v as cacheBlocked, x as measurePressure, y as measureDisk } from "./worktree-COAJ3-OD.mjs";
+import { n as describePullRequest, r as endedPullRequest, s as pullRequestLookups } from "./pull-request-BzLmzAIQ.mjs";
+import { a as lastFetchedAtAsync, c as mergeStateAsync, f as recordPullRequestLookup, i as fetchDefaultBranchAsync, o as localDefaultBranchAsync, r as FETCH_FRESH_MS } from "./warm-progress-C0RsbngN.mjs";
+import { a as restoreProblem, r as recordLightened, t as finishLightened } from "./lightened-BCsdAGj_.mjs";
+import { i as writeIdleShutdownEvent, n as dueIdleDevices, r as shutDownIdleDevices } from "./idle-shutdown-Cbvo5KEh.mjs";
 import { readClaimSet } from "@stim-cli/core/ownership-claim";
-import { existsSync, lstatSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { existsSync, lstatSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { buildCacheRoot, configDir, metroCacheRoot } from "@stim-cli/core";
-import { LAST_BUILD_KEYS, MAINTENANCE_LOG_NAME, loadConfig, readBuildHistory, readMaintenanceState, readPullRequestCache, settingDefinition, sharedCompilationCache } from "@stim-cli/core/state";
+import { LAST_BUILD_KEYS, MAINTENANCE_LOG_NAME, lastNativeUseFrom, loadConfig, readBuildHistory, readMaintenanceState, readPullRequestCache, settingDefinition, sharedCompilationCache } from "@stim-cli/core/state";
 import { isAbsolute as isAbsolute$1, join as join$1 } from "path";
 import chalk from "chalk";
 import { existsSync as existsSync$1, readdirSync as readdirSync$1, statSync as statSync$1 } from "fs";
@@ -34,6 +35,7 @@ const DIRTY_PATHS_SHOWN = 3;
 const DAY_MS = 864e5;
 const MINUTE_MS = 6e4;
 const GRACE_SETTING = "gc.worktreeGraceMinutes";
+const PROTECT_SETTING = "maintenance.protectRecentHours";
 const NO_OWN_COMMITS_PRESSURE_FLOOR_MS = 5 * MINUTE_MS;
 const PULL_REQUEST_NOT_CHECKED = "not checked since the last maintenance worktree check";
 const WORKTREE_CHECK_SETTING = "maintenance.worktreeCheckMinutes";
@@ -78,6 +80,18 @@ function noOwnCommitsActivityBlocker(activity, idleMs, now) {
 		eligibleAt
 	};
 }
+function dirtyLines(porcelain) {
+	return excludePodChurn(excludeWatchmanCookies(porcelain).lines).lines;
+}
+function finished(facts) {
+	return Boolean(facts.merge?.merged || endedPullRequest(facts.pullRequest));
+}
+function openPullRequest(lookup) {
+	return Boolean(lookup && "pullRequest" in lookup && lookup.pullRequest?.state === "open");
+}
+function newerActivity(a, b) {
+	return a && b ? b.at > a.at ? b : a : a ?? b;
+}
 function hasNoOwnCommits(merge) {
 	return merge?.merged === false && merge.noOwnCommits === true;
 }
@@ -116,11 +130,16 @@ function removalBlocker(facts, olderThan, now, noOwnCommitsIdleMs) {
 	if (facts.nested?.length) return skip("nested-worktree", `contains the worktree ${facts.nested.join(", ")}`);
 	if (facts.inUse.length) return skip("in-use", `in use: ${facts.inUse.join("; ")}`);
 	if (facts.porcelain === null) return skip("status-unreadable", "git status could not be read");
-	const dirty = excludePodChurn(excludeWatchmanCookies(facts.porcelain).lines).lines;
+	const dirty = dirtyLines(facts.porcelain);
 	if (dirty.length) {
 		const paths = dirty.slice(0, DIRTY_PATHS_SHOWN).flatMap((line) => porcelainPath(line) ?? []);
 		const more = dirty.length > DIRTY_PATHS_SHOWN ? ", ..." : "";
-		return skip("dirty", `dirty: ${plural(dirty.length, "uncommitted or untracked file")} (${paths.join(", ")}${more})`);
+		const kept = skip("dirty", `dirty: ${plural(dirty.length, "uncommitted or untracked file")} (${paths.join(", ")}${more})`);
+		if (!facts.archiveDirty) return kept;
+		return removalBlocker({
+			...facts,
+			porcelain: []
+		}, olderThan, now, noOwnCommitsIdleMs) === null && finished(facts) ? null : kept;
 	}
 	if (facts.unpushed === null) return skip("unpushed-unchecked", "unpushed commits could not be checked");
 	const merged = facts.merge?.merged ? facts.merge : null;
@@ -131,17 +150,9 @@ function removalBlocker(facts, olderThan, now, noOwnCommitsIdleMs) {
 	if (merged || ended) return null;
 	const notMerged = facts.merge && !facts.merge.merged ? facts.merge : null;
 	const details = [notMerged?.detail, pullRequestNote(facts.pullRequest)].filter(Boolean);
-	const noOwnCommits = hasNoOwnCommits(notMerged);
-	if (olderThan === null) {
-		if (noOwnCommits && noOwnCommitsIdleMs !== null) return noOwnCommitsActivityBlocker(facts.activity, noOwnCommitsIdleMs, now);
-		return skip(notMerged?.unknown ? "merge-unknown" : "not-merged", details.join("; ") || "not merged");
-	}
+	if (hasNoOwnCommits(notMerged) && !openPullRequest(facts.pullRequest) && noOwnCommitsIdleMs !== null) return noOwnCommitsActivityBlocker(facts.activity, noOwnCommitsIdleMs, now);
+	if (olderThan === null) return skip(notMerged?.unknown ? "merge-unknown" : "not-merged", details.join("; ") || "not merged");
 	const also = details.map((detail) => `; ${detail}`).join("");
-	if (facts.idleDays === null && noOwnCommits && facts.activity) {
-		const days = activityIdleDays(facts.activity, now);
-		if (days < olderThan) return skip("recently-used", `recently active: ${facts.activity.basis} ${days}d ago${also}`);
-		return null;
-	}
 	if (facts.idleDays === null) return skip("last-use-unknown", `recently used: its last use is unknown${also}`);
 	if (facts.idleDays < olderThan) return skip("recently-used", `recently used ${facts.idleDays}d ago${also}`);
 	return null;
@@ -153,11 +164,16 @@ function removalBlocker(facts, olderThan, now, noOwnCommitsIdleMs) {
 */
 function worktreeRemovalReason(candidate, sweep) {
 	const { merge, activity } = candidate;
-	if (merge?.merged) return `merged into ${merge.into}`;
+	const archived = candidate.dirty ? `, ${plural(candidate.dirty, "uncommitted file")} archived first` : "";
+	if (merge?.merged) return `merged into ${merge.into}${archived}`;
 	const ended = endedPullRequest(candidate.pullRequest);
-	if (ended) return describePullRequest(ended);
+	if (ended) return `${describePullRequest(ended)}${archived}`;
 	if (merge && hasNoOwnCommits(merge)) {
-		if (sweep.noOwnCommitsIdleMs !== null && activity) return `${merge.detail}, inactive for ${formatLongDuration(Math.max(0, sweep.now - activity.at))} under disk pressure`;
+		if (sweep.noOwnCommitsIdleMs !== null && activity) {
+			const age = Math.max(0, sweep.now - activity.at);
+			if (sweep.underPressure) return `${merge.detail}, inactive for ${formatLongDuration(age)} under disk pressure`;
+			return age >= DAY_MS ? `${merge.detail}, idle ${activityIdleDays(activity, sweep.now)}d` : `${merge.detail}, inactive for ${formatLongDuration(age)}`;
+		}
 		const days = candidate.idleDays ?? (activity ? activityIdleDays(activity, sweep.now) : null);
 		return days === null ? merge.detail : `${merge.detail}, idle ${days}d`;
 	}
@@ -343,6 +359,10 @@ function activityFromGitDir(gitDir, keys) {
 	const newest = newestMtime(paths);
 	return newest === "unreadable" ? null : newest;
 }
+function protectRecentMs(operation) {
+	const { value, error } = machineNumber(PROTECT_SETTING, loadConfig$1(), operation?.env ?? process.env);
+	return (error ? Number(settingDefinition(PROTECT_SETTING)?.default) : value ?? 0) * 60 * MINUTE_MS;
+}
 function graceMsSetting(operation) {
 	const { value, error } = machineNumber(GRACE_SETTING, loadConfig$1(), operation?.env ?? process.env);
 	if (error) {
@@ -448,7 +468,7 @@ async function checkMergeStates(pending, idle, grace, noOwnCommitsIdleMs, refres
 		operation?.signal.throwIfAborted();
 		const target = refresh ? await fetchDefaultBranchAsync(repo, grace.now, execution) : await localDefaultBranchAsync(repo, execution);
 		const fetch = refresh ? null : await staleFetch(repo, grace.now, freshMs, execution);
-		for (const { candidate, facts } of entries) {
+		await eachLimited(entries, readConcurrency(operation), async ({ candidate, facts }) => {
 			operation?.signal.throwIfAborted();
 			const merge = "error" in target ? {
 				merged: false,
@@ -466,26 +486,29 @@ async function checkMergeStates(pending, idle, grace, noOwnCommitsIdleMs, refres
 				skipped: verdict ? note ? `${verdict.text}; ${note}` : verdict.text : null,
 				eligibleAt: verdict?.eligibleAt ?? null
 			});
-		}
+		});
 	}
 }
 /**
-* Classifies each linked worktree of a registered project or its repository. A merged one is removable; with `idle`, so is one unused for
-* `olderThan` days; with `removesNoOwnCommits`, so is one with no commits of its own beyond the default branch whose
-* last activity is older than the grace period, and never younger than 5 minutes. Device use is read last, in one pass against one simulator list and one AVD resolver, so
+* Classifies each linked worktree of a registered project or its repository. A merged one is removable, a dirty one
+* after archiving its uncommitted work when archives are on; with `idle`, so is one unused for `olderThan` days. One
+* with no commits of its own beyond the default branch is removable once its last activity is older than the grace
+* period and `maintenance.protectRecentHours`, or, `underPressure`, than the grace period alone; never younger than 5
+* minutes. Device use is read last, in one pass against one simulator list and one AVD resolver, so
 * the resolver's time budget covers only device reads. Pull requests are asked once per repository, sequentially
 * with an operation and concurrently otherwise. Merge state is checked only where it decides the verdict, after one fetch per repository.
 * Without `refresh`, it runs no fetch and no `gh`: merge state comes from the existing remote-tracking ref and pull
 * requests from the cache `status --watch` writes, and a kept verdict that fresher state could change says so.
 */
-async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOwnCommits = false, refresh = true, operation }) {
+async function collectWorktreeSweep({ idle, olderThan, now, graceMs, underPressure = false, refresh = true, operation }) {
 	const days = idle ? olderThan ?? DEFAULT_WORKTREE_IDLE_DAYS : null;
 	const grace = {
 		ms: graceMs ?? graceMsSetting(operation),
 		now
 	};
 	const freshMs = refresh ? 0 : reportFreshMs(operation);
-	const noOwnCommitsIdleMs = removesNoOwnCommits ? Math.max(grace.ms, NO_OWN_COMMITS_PRESSURE_FLOOR_MS) : null;
+	const noOwnCommitsIdleMs = Math.max(grace.ms, underPressure ? 0 : protectRecentMs(operation), NO_OWN_COMMITS_PRESSURE_FLOOR_MS);
+	const cli = stimCliEntries(operation?.env);
 	const groups = /* @__PURE__ */ new Map();
 	operation?.signal.throwIfAborted();
 	const read = {
@@ -496,9 +519,13 @@ async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOw
 	const outside = [];
 	const candidates = await candidateRootsAsync(operation);
 	if (candidates.length) phase("worktrees", `checking ${plural(candidates.length, "project")} for merged or idle worktrees`, operation);
-	for (const root of candidates) {
+	const matched = [];
+	await eachLimited([...candidates.entries()], readConcurrency(operation), async ([index, root]) => {
 		operation?.signal.throwIfAborted();
-		const entry = matchWorktreeEntry(await listWorktreesAsync(root, read), root);
+		matched[index] = matchWorktreeEntry(await listWorktreesAsync(root, read), root);
+	});
+	for (const [index, root] of candidates.entries()) {
+		const entry = matched[index];
 		if (!entry) {
 			outside.push({
 				path: root,
@@ -517,31 +544,38 @@ async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOw
 		groups.set(entry.path, [...groups.get(entry.path) ?? [], root]);
 	}
 	const inspected = [];
-	for (const [path, roots] of groups) {
+	await eachLimited([...[...groups].entries()], readConcurrency(operation), async ([index, [path, roots]]) => {
 		operation?.signal.throwIfAborted();
 		const { entries, ...source } = await resolveSourceCheckoutAsync(path, read);
 		const entry = matchWorktreeEntry(entries, path);
 		const keys = [.../* @__PURE__ */ new Set([...roots, ...reclaimKeys(path)])];
 		const idleDays = idleDaysOf(keys, now);
 		const linked = !("refusal" in source) && entry !== null && source.path !== entry.path;
-		const activity = linked && (grace.ms > 0 || days !== null || removesNoOwnCommits) ? await worktreeActivityOfAsync(path, keys, operation) : null;
-		const gitAnswered = linked ? await unlessTimedOut(() => hasUncommittedWorkAsync(path, read), null) : null;
+		const porcelain = await porcelainOf(path, linked ? await unlessTimedOut(() => hasUncommittedWorkAsync(path, read), null) : null, operation);
+		const dirty = linked ? dirtyLines(porcelain).length : 0;
+		const archiveDirty = dirty > 0 && !underPressure && !("refusal" in worktreeArchiveLimits(path, operation?.env));
+		let activity = linked ? await worktreeActivityOfAsync(path, keys, operation) : null;
+		if (activity && archiveDirty) {
+			const edited = await uncommittedActivityOf(path, operation);
+			activity = edited === "unreadable" ? null : newerActivity(activity, edited);
+		}
 		const head = linked ? await resolveFullRefAsync(path, "HEAD", read) : null;
 		const facts = {
 			source: "refusal" in source ? source : linked ? "linked" : "source",
 			bare: Boolean(entry?.bare),
 			locked: Boolean(entry?.locked),
 			nested: entry ? nestedWorktrees(entries, entry.path) : [],
-			porcelain: await porcelainOf(path, gitAnswered, operation),
+			porcelain,
 			unpushed: linked ? await unlessTimedOut(() => unpushedCommitsAsync(path, read), null) : null,
 			submodules: linked ? await unlessTimedOut(() => hasPopulatedSubmodulesAsync(path, read), null) : false,
-			inUse: [],
+			inUse: linked ? stimCliUseOf(path, canonicalPath, cli) : [],
 			idleDays,
 			merge: null,
 			pullRequest: null,
-			activity
+			activity,
+			archiveDirty
 		};
-		inspected.push({
+		inspected[index] = {
 			candidate: {
 				path,
 				keys,
@@ -552,13 +586,14 @@ async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOw
 				skipCode: null,
 				skipped: null,
 				eligibleAt: null,
-				activity
+				activity,
+				...archiveDirty ? { dirty } : {}
 			},
 			facts,
 			repo: "refusal" in source ? null : source.path,
 			branch: head && entry?.branch ? entry.branch : null
-		});
-	}
+		};
+	});
 	const linked = inspected.filter(({ facts }) => facts.source === "linked");
 	for (const { candidate, facts } of linked) for (const key of candidate.keys) facts.inUse.push(...await workspaceInUseAsync(key, { managedLocks: true }, operation?.signal, operation));
 	const devices = await reportDeviceReads(linked.flatMap(({ candidate }) => candidate.keys), operation);
@@ -575,7 +610,7 @@ async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOw
 			skipped: verdict?.text ?? null,
 			eligibleAt: verdict?.eligibleAt ?? null
 		});
-		if (verdict && MERGE_DECIDES.has(verdict.code) && repo !== null) pending.push({
+		if (verdict && (MERGE_DECIDES.has(verdict.code) || verdict.code === "dirty" && facts.archiveDirty) && repo !== null) pending.push({
 			candidate,
 			facts,
 			repo
@@ -592,6 +627,7 @@ async function collectWorktreeSweep({ idle, olderThan, now, graceMs, removesNoOw
 		graceMs: grace.ms,
 		now,
 		noOwnCommitsIdleMs,
+		underPressure,
 		worktrees: listed
 	};
 }
@@ -659,16 +695,8 @@ function cachedPullRequest(cached, branch, head, now, freshMs) {
 	} };
 }
 async function noOwnCommitsRecheck(sweep, path, keys, now, operation) {
-	if (!sweep.idle) {
-		if (sweep.noOwnCommitsIdleMs === null) return "it has no commits of its own and is not idle";
-		return noOwnCommitsActivityBlocker(await worktreeActivityOfAsync(path, keys, operation), sweep.noOwnCommitsIdleMs, now)?.text ?? null;
-	}
-	const idleDays = idleDaysOf(keys, now);
-	if (idleDays !== null) return idleDays < sweep.idle.olderThan ? `used ${idleDays}d ago since gc checked it` : null;
-	const activity = await worktreeActivityOfAsync(path, keys, operation);
-	if (!activity) return "its last activity could not be read";
-	const days = activityIdleDays(activity, now);
-	return days < sweep.idle.olderThan ? `active ${days}d ago since gc checked it: ${activity.basis}` : null;
+	if (sweep.noOwnCommitsIdleMs === null) return "it has no commits of its own and is not idle";
+	return noOwnCommitsActivityBlocker(await worktreeActivityOfAsync(path, keys, operation), sweep.noOwnCommitsIdleMs, now)?.text ?? null;
 }
 async function removeWorktrees(sweep, { now = Date.now(), operation } = {}, output = GC_OUTPUT) {
 	let failures = 0;
@@ -680,7 +708,11 @@ async function removeWorktrees(sweep, { now = Date.now(), operation } = {}, outp
 			const keys = [.../* @__PURE__ */ new Set([...candidate.keys, ...lockedKeys])];
 			const unlocked = keys.filter((key) => !lockedKeys.includes(key));
 			const devices = await reportDeviceReads(keys, operation);
-			const reasons = [...await inUseOf(lockedKeys, { managedLocks: false }, devices, operation?.signal, operation), ...await inUseOf(unlocked, { managedLocks: true }, devices, operation?.signal, operation)].map((r) => `in use: ${r}`);
+			const reasons = [
+				...stimCliUseOf(candidate.path, canonicalPath, stimCliEntries(operation?.env)),
+				...await inUseOf(lockedKeys, { managedLocks: false }, devices, operation?.signal, operation),
+				...await inUseOf(unlocked, { managedLocks: true }, devices, operation?.signal, operation)
+			].map((r) => `in use: ${r}`);
 			const mergedHead = candidate.merge?.merged ? candidate.merge.head : endedPullRequest(candidate.pullRequest) ? candidate.head : null;
 			if (mergedHead) {
 				if (await resolveFullRefAsync(candidate.path, "HEAD", {
@@ -701,10 +733,12 @@ async function removeWorktrees(sweep, { now = Date.now(), operation } = {}, outp
 				if (idleDays === null || !sweep.idle || idleDays < sweep.idle.olderThan) reasons.push(`used ${idleDays === null ? "at an unknown time" : `${idleDays}d ago`} since gc checked it`);
 			}
 			if (sweep.graceMs > 0) {
+				const activity = await worktreeActivityOfAsync(candidate.path, keys, operation);
+				const edited = candidate.dirty && activity ? await uncommittedActivityOf(candidate.path, operation) : null;
 				const recent = graceBlocker({
 					merge: candidate.merge,
 					pullRequest: candidate.pullRequest,
-					activity: await worktreeActivityOfAsync(candidate.path, keys, operation)
+					activity: edited === "unreadable" ? null : newerActivity(activity, edited)
 				}, {
 					ms: sweep.graceMs,
 					now: Date.now()
@@ -716,6 +750,7 @@ async function removeWorktrees(sweep, { now = Date.now(), operation } = {}, outp
 		};
 		let removed = false;
 		let error = null;
+		const archived = { archive: null };
 		try {
 			const ended = endedPullRequest(candidate.pullRequest);
 			const mergedHead = candidate.merge?.merged && candidate.merge.coversUnpushed ? candidate.merge.head : ended?.state === "merged" ? candidate.head ?? void 0 : void 0;
@@ -726,7 +761,17 @@ async function removeWorktrees(sweep, { now = Date.now(), operation } = {}, outp
 				mergedHead,
 				expectedHead,
 				output,
-				operation
+				operation,
+				...candidate.dirty ? { archiveDirty: {
+					pullRequest: ended ? {
+						number: ended.number,
+						url: ended.url,
+						state: ended.state
+					} : null,
+					onArchived: (saved) => {
+						archived.archive = saved;
+					}
+				} } : {}
 			});
 		} catch (thrown) {
 			if (thrown instanceof WorkspaceProcessCleanupError || thrown instanceof Error && "reportCleanup" in thrown) throw thrown;
@@ -735,8 +780,16 @@ async function removeWorktrees(sweep, { now = Date.now(), operation } = {}, outp
 			output.error(chalk.red(`Could not remove ${candidate.path}: ${error}`));
 		}
 		if (removed) {
-			output.log(chalk.green(`Removed the worktree ${candidate.path} (${worktreeRemovalReason(candidate, sweep)})`));
-			output.record("worktree", "done", candidate.path, { detail: worktreeRemovalReason(candidate, sweep) });
+			const saved = archived.archive;
+			const reason = saved ? `${worktreeRemovalReason({
+				...candidate,
+				dirty: 0
+			}, sweep)}; archived ${plural(saved.tracked.length + saved.untracked.length, "uncommitted file")} to ${saved.dir}; restore: ${saved.restore.join(" && ")}` : worktreeRemovalReason({
+				...candidate,
+				dirty: 0
+			}, sweep);
+			output.log(chalk.green(`Removed the worktree ${candidate.path} (${reason})`));
+			output.record("worktree", "done", candidate.path, { detail: reason });
 		} else if (kept.length) {
 			output.log(chalk.yellow(`Kept the worktree ${candidate.path}: ${kept.join("; ")}`));
 			output.record("worktree", "kept", candidate.path, { detail: kept.join("; ") });
@@ -1213,6 +1266,44 @@ function finishedWorkspaces(sweep, now) {
 		}));
 	});
 }
+/** Each workspace's effective devices.idleShutdownMinutes, or 0 when it cannot be resolved. */
+function idleShutdownMinutes(root) {
+	try {
+		return deviceIdleShutdownMinutesSetting(resolveProjectSettings(root).settings);
+	} catch {
+		return 0;
+	}
+}
+/**
+* Plans shutting down each booted owned simulator and emulator idle for its workspace's devices.idleShutdownMinutes,
+* whether or not a supervisor runs there. The devices are shut down, never deleted.
+*/
+function planIdleShutdown({ protectedRoot, now, env = process.env }) {
+	const plan = {
+		actions: [],
+		blocked: [],
+		skips: []
+	};
+	if (deviceSweepIsScoped(env)) return plan;
+	const minutes = new Map(Object.entries(loadConfig$1()?.projects ?? {}).flatMap(([root, project]) => {
+		const value = !projectDeviceSlots(project).some(({ platforms }) => platforms.ios?.owned === true || platforms.android?.owned === true) || canonicalPath(root) === protectedRoot ? 0 : idleShutdownMinutes(root);
+		return value > 0 ? [[root, value]] : [];
+	}));
+	if (minutes.size === 0) return plan;
+	for (const { device, idleForMs } of dueIdleDevices(void 0, Math.min(...minutes.values()) * 6e4, now)) {
+		const own = minutes.get(device.project);
+		if (own === void 0 || idleForMs < own * 6e4 || now - workspaceDeviceLastUseAt(device.project) < own * 6e4) continue;
+		const root = canonicalPath(device.project);
+		plan.actions.push({
+			kind: "would-shutdown-device",
+			target: device.id,
+			workspace: root,
+			bytes: 0,
+			reason: `${device.kind === "ios" ? "simulator" : "emulator"} ${device.name} idle ${formatLongDuration(idleForMs)}, over devices.idleShutdownMinutes ${own}`
+		});
+	}
+	return plan;
+}
 //#endregion
 //#region src/maintenance/sweep.ts
 async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices = true, operation }) {
@@ -1220,13 +1311,13 @@ async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices
 	const skips = [];
 	const blocked = [];
 	const days = settings.olderThanDays;
-	const outputs = await collectWorkspaceOutputs({
+	const outputs = days > 0 ? await collectWorkspaceOutputs({
 		olderThan: days,
 		now,
 		measure: false,
 		signal: operation?.signal,
 		operation
-	});
+	}) : { workspaces: [] };
 	for (const entry of outputs.workspaces) {
 		const root = entry.projectRoot === null ? null : canonicalPath(entry.projectRoot);
 		if (root === null || !entry.willClear || root === protectedRoot) continue;
@@ -1249,7 +1340,7 @@ async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices
 			check: "sweep"
 		});
 	}
-	for (const cache of trimmableCaches(operation?.env, operation?.cwd).filter((candidate) => !isInsideWorkspaces(candidate.dir))) actions.push({
+	for (const cache of days > 0 ? trimmableCaches(operation?.env, operation?.cwd).filter((candidate) => !isInsideWorkspaces(candidate.dir)) : []) actions.push({
 		kind: "would-trim-cache",
 		target: cacheLabel(cache),
 		dir: cache.dir,
@@ -1298,6 +1389,19 @@ async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices
 		actions.push(...reaped.actions);
 		skips.push(...reaped.skips);
 	}
+	if (devices && days > 0 && !deviceSweepIsScoped(operation?.env ?? process.env)) for (const kind of ["ios", "android"]) for (const record of readParked(kind)) {
+		const parkedDays = Math.floor((now - Date.parse(record.parkedAt)) / 864e5);
+		if (!(parkedDays >= days)) continue;
+		const label = `parked ${kind === "ios" ? "simulator" : "emulator"} ${record.name}`;
+		actions.push({
+			kind: "would-delete-parked-device",
+			target: kind === "ios" ? record.udid : record.name,
+			bytes: sizes.find((size) => size.category === "owned-devices" && !size.workspace && size.name === label)?.bytes ?? 0,
+			olderThanDays: days,
+			reason: `${label} unused for ${parkedDays} days, older than ${days} days (age sweep)`,
+			check: "sweep"
+		});
+	}
 	const mounted = listMountedVolumes();
 	for (const cache of readManifest().caches) {
 		if (!isAbsolute(cache.dir) || existsSync(cache.dir) || !isOnMountedVolume(cache.dir, mounted)) continue;
@@ -1316,12 +1420,12 @@ async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices
 		skips
 	};
 }
-async function planWorktrees({ protectedRoot, pinned, now, level, graceMs, sizes, protectRecentMs = 0, refresh, operation }) {
+async function planWorktrees({ protectedRoot, pinned, now, level, graceMs, sizes, protectRecentMs = 0, refresh, idleDays = null, operation }) {
 	const sweep = await collectWorktreeSweep({
-		idle: false,
-		olderThan: null,
+		idle: idleDays !== null,
+		olderThan: idleDays,
 		now,
-		removesNoOwnCommits: level === 3,
+		underPressure: level === 3,
 		operation,
 		...graceMs === void 0 ? {} : { graceMs },
 		...refresh === void 0 ? {} : { refresh }
@@ -1346,7 +1450,7 @@ async function planWorktrees({ protectedRoot, pinned, now, level, graceMs, sizes
 			target: worktree.path,
 			bytes: 0,
 			reason: worktreeRemovalReason(worktree, sweep),
-			check: "worktree",
+			check: level === void 0 && idleDays !== null && !worktree.merge?.merged && !endedPullRequest(worktree.pullRequest) ? "sweep" : "worktree",
 			...level ? { level } : {}
 		});
 	}
@@ -1377,18 +1481,118 @@ async function planWorktrees({ protectedRoot, pinned, now, level, graceMs, sizes
 	};
 }
 //#endregion
+//#region src/workspace/running-from.ts
+const LIST_TIMEOUT_MS = 1e4;
+function parsePs(text) {
+	return text.split("\n").flatMap((row) => {
+		const match = /^\s*(\d+)\s+(.*)$/.exec(row);
+		return match ? [{
+			pid: Number(match[1]),
+			line: match[2] ?? ""
+		}] : [];
+	});
+}
+/** `lsof -Fpn` output: a `p<pid>` line, then the `n<path>` of its working directory. */
+function parseLsof(text) {
+	const cwds = [];
+	let pid = 0;
+	for (const row of text.split("\n")) if (row.startsWith("p")) pid = Number(row.slice(1));
+	else if (row.startsWith("n") && pid) cwds.push({
+		pid,
+		path: row.slice(1)
+	});
+	return cwds;
+}
+function procCwds() {
+	try {
+		return readdirSync("/proc").filter((name) => /^\d+$/.test(name)).flatMap((name) => {
+			try {
+				return [{
+					pid: Number(name),
+					path: readlinkSync(join("/proc", name, "cwd"))
+				}];
+			} catch {
+				return [];
+			}
+		});
+	} catch {
+		return null;
+	}
+}
+function listsSelf(list) {
+	return list.some(({ pid }) => pid === process.pid);
+}
+function runningFrom(ps, cwds) {
+	if (ps === null || cwds === null) return null;
+	const commands = parsePs(ps);
+	return listsSelf(commands) && listsSelf(cwds) ? {
+		commands,
+		cwds
+	} : null;
+}
+const PS_ARGS = [
+	"-axww",
+	"-o",
+	"pid=,args="
+];
+const LSOF_ARGS = [
+	"-a",
+	"-d",
+	"cwd",
+	"-Fpn",
+	"-w"
+];
+function readRunningProcesses(platform = process.platform) {
+	if (platform !== "darwin" && platform !== "linux") return null;
+	const exec = getExecutor();
+	const ps = exec.runFileQuiet("ps", PS_ARGS, { timeoutMs: LIST_TIMEOUT_MS });
+	if (platform === "linux") return runningFrom(ps, procCwds());
+	const lsof = exec.runFileQuiet("lsof", LSOF_ARGS, { timeoutMs: LIST_TIMEOUT_MS });
+	return runningFrom(ps, lsof === null ? null : parseLsof(lsof));
+}
+async function readRunningProcessesAsync(signal, platform = process.platform) {
+	if (platform !== "darwin" && platform !== "linux") return null;
+	const exec = getExecutor();
+	const ps = await exec.runFileQuietAsync("ps", PS_ARGS, {
+		timeoutMs: LIST_TIMEOUT_MS,
+		signal
+	});
+	if (platform === "linux") return runningFrom(ps, procCwds());
+	const lsof = await exec.runFileQuietAsync("lsof", LSOF_ARGS, {
+		timeoutMs: LIST_TIMEOUT_MS,
+		signal
+	});
+	return runningFrom(ps, lsof === null ? null : parseLsof(lsof));
+}
+function stimOnPath() {
+	const found = getExecutor().findExecutable("stim");
+	if (!found) return null;
+	try {
+		return realpathSync(found);
+	} catch {
+		return null;
+	}
+}
+/**
+* Why something installed in or running from `folder` still needs it, or null: an installed stim-server service, the
+* `stim` on PATH, or a live process whose command line or working directory is inside it.
+*/
+function runningFromReason(folder, running) {
+	const root = canonicalPath(folder);
+	const inside = (path) => path === root || path.startsWith(`${root}${sep}`);
+	const service = serviceRunningFrom(root, canonicalPath);
+	if (service) return `the stim-server service ${service.label} runs from it`;
+	const stim = stimOnPath();
+	if (stim && inside(stim)) return `the stim on PATH runs from it (${stim})`;
+	if (!running) return "the running processes cannot be listed to prove nothing runs from it";
+	const command = running.commands.find(({ line }) => line.includes(`${root}${sep}`));
+	if (command) return `process ${command.pid} runs from it`;
+	const cwd = running.cwds.find(({ path }) => inside(canonicalPath(path)));
+	if (cwd) return `process ${cwd.pid} works in it`;
+	return null;
+}
+//#endregion
 //#region src/maintenance/artifacts.ts
-/** Directories that hold only what a build or an install regenerates, relative to an app or package root. */
-const ARTIFACT_DIRS = {
-	build: [
-		"ios/build",
-		"android/app/build",
-		"android/build",
-		"android/.gradle",
-		".build"
-	],
-	dependencies: ["node_modules", "ios/Pods"]
-};
 const PACKAGE_PARENTS = ["apps", "packages"];
 const SCAN_DEPTH = {
 	build: 3,
@@ -1402,6 +1606,14 @@ function isDirectory(path) {
 		return false;
 	}
 }
+function pathExists(path) {
+	try {
+		lstatSync(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
 function artifactWorktrees() {
 	const found = /* @__PURE__ */ new Map();
 	for (const root of candidateRoots()) {
@@ -1487,8 +1699,8 @@ async function newestWriteAsync(dir, maxDepth, signal) {
 	};
 	return await walk(dir, 0) ? newest : null;
 }
-function keptReason(candidate, kind, { now, windowMs, pinned, locked }, reads) {
-	const guarded = artifactGuard(candidate, kind, pinned, locked);
+function keptReason(candidate, kind, { now, windowMs, pinned, locked, running }, reads) {
+	const guarded = artifactGuard(candidate, kind, pinned, locked, running);
 	if (guarded) return guarded;
 	const { worktree, path, keys } = candidate;
 	const tracked = reads ? reads.tracked : gitQuiet(worktree, [
@@ -1498,15 +1710,22 @@ function keptReason(candidate, kind, { now, windowMs, pinned, locked }, reads) {
 	]);
 	if (tracked === null) return "git cannot tell whether it holds tracked files";
 	if (tracked.trim()) return "it holds files git tracks";
+	if (kind === "build") return buildNativeUseReason(keys, now);
 	const activity = reads ? reads.activity : worktreeActivityOf(worktree, keys);
 	const written = reads ? reads.written : newestWrite(path, SCAN_DEPTH[kind]);
 	if (!activity || written === null) return "its last activity cannot be read";
 	if (now - Math.max(activity.at, written) < windowMs) return `used within the last ${Math.round(windowMs / 6e4)} minutes`;
 	return null;
 }
-function artifactGuard(candidate, kind, pinned, locked) {
+function buildNativeUseReason(keys, now) {
+	const states = keys.map((key) => readWorkspaceState$1(key)).filter((state) => state !== null);
+	if (!states.length) return "no Stim workspace records when it last ran ios, android or macos";
+	return recentNativeUseReason(Math.max(...states.map((state) => lastNativeUseFrom(state)).filter(Number.isFinite)), now);
+}
+function artifactGuard(candidate, kind, pinned, locked, running) {
 	const { worktree, path, keys } = candidate;
 	if (keys.some(pinned)) return "pinned by maintenance.keep";
+	if (!pathExists(path)) return "it is already gone";
 	let real;
 	try {
 		real = canonicalPath(path);
@@ -1514,16 +1733,15 @@ function artifactGuard(candidate, kind, pinned, locked) {
 		return "its path cannot be resolved";
 	}
 	if (!isDirectory(path) || real !== join(canonicalPath(worktree), relative(worktree, path))) return "it or a directory above it is a link, or it lies outside its worktree";
-	const inUse = keys.flatMap((key) => workspaceInUse(key, {
-		supervisor: kind === "dependencies",
-		nativeRun: key !== locked
-	}));
+	const inUse = keys.flatMap((key) => kind === "build" ? workspaceBuildReasons(key, { nativeRun: key !== locked }) : workspaceInUse(key, { nativeRun: key !== locked }));
 	if (inUse.length) return `in use: ${inUse.join("; ")}`;
+	if (kind === "dependencies") return runningFromReason(worktree, running === void 0 ? readRunningProcesses() : running);
 	return null;
 }
 async function collectArtifactsAsync(kind, options, signal, operation) {
 	const candidates = [];
 	const skips = [];
+	const running = kind === "dependencies" ? await readRunningProcessesAsync(signal) : null;
 	for (const worktree of await artifactWorktreesAsync(signal, operation)) {
 		if (kind === "dependencies" && !worktree.linked) continue;
 		const root = canonicalPath(worktree.path);
@@ -1554,7 +1772,7 @@ async function collectArtifactsAsync(kind, options, signal, operation) {
 				path,
 				keys: worktree.keys
 			};
-			let reason = protectedHere ? "the command that started this pass runs inside its worktree" : artifactGuard(candidate, kind, options.pinned);
+			let reason = protectedHere ? "the command that started this pass runs inside its worktree" : artifactGuard(candidate, kind, options.pinned, void 0, running);
 			if (!reason) {
 				const tracked = await gitQuietAsync(worktree.path, [
 					"ls-files",
@@ -1567,11 +1785,16 @@ async function collectArtifactsAsync(kind, options, signal, operation) {
 					declareFor: operation,
 					killSignal: "SIGKILL"
 				});
-				const untracked = tracked !== null && !tracked.trim();
-				reason = keptReason(candidate, kind, options, {
+				const windowed = tracked !== null && !tracked.trim() && kind === "dependencies";
+				const activity = windowed ? await worktreeActivityOfAsync(worktree.path, worktree.keys, operation) : null;
+				const written = windowed ? await newestWriteAsync(path, SCAN_DEPTH[kind], signal) : null;
+				reason = keptReason(candidate, kind, {
+					...options,
+					running
+				}, {
 					tracked,
-					activity: untracked ? await worktreeActivityOfAsync(worktree.path, worktree.keys, operation) : null,
-					written: untracked ? await newestWriteAsync(path, SCAN_DEPTH[kind], signal) : null
+					activity,
+					written
 				});
 			}
 			if (reason) skips.push({
@@ -1590,6 +1813,7 @@ async function collectArtifactsAsync(kind, options, signal, operation) {
 function collectArtifacts(kind, options) {
 	const candidates = [];
 	const skips = [];
+	const running = kind === "dependencies" ? readRunningProcesses() : null;
 	for (const worktree of artifactWorktrees()) {
 		if (kind === "dependencies" && !worktree.linked) continue;
 		const root = canonicalPath(worktree.path);
@@ -1606,7 +1830,10 @@ function collectArtifacts(kind, options) {
 				path,
 				keys: worktree.keys
 			};
-			const reason = protectedHere ? "the command that started this pass runs inside its worktree" : keptReason(candidate, kind, options);
+			const reason = protectedHere ? "the command that started this pass runs inside its worktree" : keptReason(candidate, kind, {
+				...options,
+				running
+			});
 			if (reason) skips.push({
 				target: path,
 				reason
@@ -1642,34 +1869,50 @@ async function clearArtifact(action, kind, options) {
 		path: action.target,
 		keys: worktree.keys
 	};
+	const running = kind === "dependencies" ? await readRunningProcessesAsync() : null;
 	const early = keptReason(candidate, kind, {
 		...options,
-		now: Date.now()
+		now: Date.now(),
+		running
 	});
 	if (early) return {
 		status: "kept",
 		bytes: 0,
 		detail: early
 	};
+	const unrestorable = kind === "dependencies" ? await restoreProblem(candidate, options.restoreCache) : null;
+	if (unrestorable && options.requireRestorable) return {
+		status: "kept",
+		bytes: 0,
+		detail: unrestorable
+	};
 	const before = lowestFree(measureDisk());
 	const [key] = candidate.keys;
-	const remove = () => {
+	const remove = async () => {
 		const reason = keptReason(candidate, kind, {
 			...options,
 			now: Date.now(),
+			running: kind === "dependencies" ? await readRunningProcessesAsync() : null,
 			...key ? { locked: key } : {}
 		});
 		if (reason) return reason;
+		const record = kind === "dependencies" && !unrestorable;
+		if (record) recordLightened(candidate.keys, candidate.path);
 		rmSync(candidate.path, {
 			recursive: true,
 			force: true
 		});
+		if (record) finishLightened(candidate.keys, candidate.path);
 		return null;
 	};
 	const kept = key ? await withIdleWorkspace(key, remove, {
 		purpose: "maintenance",
-		supervisor: kind === "dependencies"
-	}).then((run) => run.ran ? run.value : `in use: ${run.reasons.join("; ")}`) : remove();
+		supervisor: kind === "dependencies",
+		...kind === "build" ? {
+			hosted: false,
+			managedLocks: false
+		} : {}
+	}).then((run) => run.ran ? run.value : `in use: ${run.reasons.join("; ")}`) : await remove();
 	if (kept) return {
 		status: "kept",
 		bytes: 0,
@@ -2032,17 +2275,19 @@ async function planLevel2({ settings, sizes, protectedRoot, pinned, now, operati
 	const actions = [];
 	const skips = [];
 	const reason = `disk pressure level 2, idle for ${settings.pressureProtectMinutes} minutes`;
+	const lightenReason = `disk pressure level 2, no ios, android or macos run in the last ${LIGHTEN_AFTER_MS / 6e4} minutes`;
 	const outputs = (await collectWorkspaceOutputs({
 		olderThan: null,
 		now,
 		measure: false,
 		signal: operation?.signal,
-		operation
+		operation,
+		lighten: true
 	})).workspaces.flatMap((entry) => {
 		const root = entry.projectRoot === null ? null : canonicalPath(entry.projectRoot);
 		if (root === null || !entry.willClear || root === protectedRoot || pinned(root)) return [];
 		const used = workspaceLastUsed(root);
-		return Number.isFinite(used) && now - used >= windowMs ? [{
+		return Number.isFinite(used) ? [{
 			root,
 			used
 		}] : [];
@@ -2054,7 +2299,7 @@ async function planLevel2({ settings, sizes, protectedRoot, pinned, now, operati
 			target: root,
 			workspace: root,
 			bytes: size?.bytes ?? 0,
-			reason,
+			reason: lightenReason,
 			level: 2
 		});
 	}
@@ -2090,7 +2335,7 @@ async function planLevel2({ settings, sizes, protectedRoot, pinned, now, operati
 		kind: "would-clear-build-dirs",
 		target: candidate.path,
 		bytes: 0,
-		reason,
+		reason: lightenReason,
 		level: 2
 	});
 	skips.push(...build.skips);
@@ -2256,7 +2501,7 @@ async function planPressureLevels(level, context) {
 function triggeringRoot(operation) {
 	return canonicalPath(findProjectRoot$1(operation?.cwd ?? process.cwd()) ?? join(configDir(), "maintenance", "no-project"));
 }
-async function plannedMaintenance(pressure, recordedSizes, settings, { devices = true, sweep = false, worktrees = false, refresh = true, operation } = {}) {
+async function plannedMaintenance(pressure, recordedSizes, settings, { devices = true, sweep = false, worktrees = false, idle = false, refresh = true, operation } = {}) {
 	const env = operation?.env ?? process.env;
 	const resolved = resolveBudget({ env });
 	if (resolved.error) throw new Error(resolved.error);
@@ -2353,11 +2598,17 @@ async function plannedMaintenance(pressure, recordedSizes, settings, { devices =
 			sizes: currentSizes,
 			protectRecentMs: settings.protectRecentHours * 36e5,
 			refresh,
+			idleDays: sweep && settings.removeIdleWorktrees && settings.olderThanDays > 0 ? settings.olderThanDays : null,
 			operation
 		});
 		merge(planned);
 		result.worktreeSweep = planned.sweep;
 	}
+	if (idle && devices) merge(planIdleShutdown({
+		protectedRoot: root,
+		now: Date.now(),
+		env
+	}));
 	if (pressure) {
 		const pressured = await planPressureLevels(diskPressureLevel(lowestFree(pressure.disk), budget, settings), {
 			settings,
@@ -2405,6 +2656,7 @@ async function previewMaintenance({ devices = true, refresh = true, operation }
 			...await plannedMaintenance(pressure, state?.sizes ?? [], settings, {
 				devices,
 				sweep: true,
+				idle: true,
 				refresh,
 				operation
 			}),
@@ -2543,14 +2795,16 @@ async function clearOutputs(action, context) {
 	if (!root) return kept("the action names no workspace");
 	if (root === context.protectedRoot) return kept("the command that started this pass runs in it");
 	if (maintenancePinned(root)) return kept("pinned by maintenance.keep");
-	const recent = recentUse(root, context.settings, protectWindowMs(action, context.settings));
+	const lighten = action.level === 2;
+	const recent = lighten ? null : recentUse(root, context.settings, protectWindowMs(action, context.settings));
 	if (recent) return kept(recent);
 	const olderThan = action.olderThanDays ?? null;
 	const now = Date.now();
 	const report = collectWorkspaceOutputs({
 		olderThan,
 		now,
-		measure: false
+		measure: false,
+		lighten
 	});
 	const entry = report.workspaces.find((candidate) => candidate.projectRoot && canonicalPath(candidate.projectRoot) === root);
 	if (!entry) return kept("it has no build outputs any more");
@@ -2559,7 +2813,8 @@ async function clearOutputs(action, context) {
 		workspaces: [entry]
 	}, {
 		olderThan,
-		now
+		now,
+		lighten
 	}));
 	return outcomeOf(results, action.bytes);
 }
@@ -2575,7 +2830,12 @@ async function removeWorktree(action, context) {
 		...sweep,
 		worktrees: [worktree]
 	}));
-	return outcomeOf(results, freedSince(before));
+	const outcome = outcomeOf(results, freedSince(before));
+	const removal = results.find((result) => result.status === "done")?.detail;
+	return outcome.status === "done" ? {
+		...outcome,
+		detail: removal ?? action.reason
+	} : outcome;
 }
 async function removeOrphan(action) {
 	const orphan = (await collectOrphanedWorkspaces(Object.keys(loadConfig$1()?.projects ?? {}), listMountedVolumes())).orphaned.find((candidate) => candidate.dir === action.target);
@@ -2583,11 +2843,47 @@ async function removeOrphan(action) {
 	const { results } = await quietly(() => deleteOrphanedWorkspaces([orphan]));
 	return outcomeOf(results, orphan.bytes ?? 0);
 }
+async function shutDownIdleDevice(action) {
+	if (deviceSweepIsScoped()) return kept("STIM_HOME scopes this config, and devices are machine-wide");
+	const root = action.workspace ?? action.target;
+	const minutes = idleShutdownMinutes(root);
+	if (minutes === 0) return kept("devices.idleShutdownMinutes is 0 for this workspace");
+	const idleMs = minutes * 6e4;
+	const due = dueIdleDevices(root, idleMs).find(({ device }) => device.id === action.target);
+	if (!due) return kept(`it is no longer idle for ${minutes} minutes`);
+	const failures = [];
+	const skips = [];
+	const log = (event) => {
+		writeIdleShutdownEvent(root, event);
+		if (event.event === "device_idle_shutdown_failed") (event.skipped ? skips : failures).push(event.msg);
+	};
+	const run = await withIdleWorkspace(root, () => shutDownIdleDevices(root, idleMs, log, Date.now(), { only: due.device }), {
+		purpose: "automatic maintenance idle shutdown",
+		supervisor: false,
+		managedLocks: false
+	});
+	if (!run.ran) return kept(`in use: ${run.reasons.join("; ")}`);
+	if (run.value) return {
+		status: "done",
+		bytes: 0,
+		detail: action.target
+	};
+	if (failures.length) return {
+		status: "failed",
+		bytes: 0,
+		detail: failures.join("; ")
+	};
+	return kept(skips.join("; ") || `it is no longer idle for ${minutes} minutes`);
+}
 async function deleteParkedDevice(action) {
 	if (deviceSweepIsScoped()) return kept("STIM_HOME scopes this config, and devices are machine-wide");
-	const sims = (await collectParkedSims({})).filter((sim) => sim.udid === action.target);
-	const avds = sims.length ? [] : (await collectParkedAvds({})).filter((avd) => avd.name === action.target);
-	if (!sims.length && !avds.length) return kept("it is no longer parked");
+	const age = {
+		olderThanDays: action.olderThanDays ?? null,
+		now: Date.now()
+	};
+	const sims = (await collectParkedSims({}, age)).filter((sim) => sim.udid === action.target);
+	const avds = sims.length ? [] : (await collectParkedAvds({}, age)).filter((avd) => avd.name === action.target);
+	if (!sims.length && !avds.length) return kept(action.olderThanDays === void 0 ? "it is no longer parked" : `it is no longer parked, or was parked within ${action.olderThanDays} days`);
 	const before = lowestFree(measureDisk());
 	const { results } = await quietly(async () => await deleteParkedSims(sims) + await deleteParkedAvds(avds));
 	return outcomeOf(results, freedSince(before));
@@ -2799,6 +3095,7 @@ async function executeAction(action, context) {
 		case "would-unregister-cache": return unregisterCache(action);
 		case "would-delete-parked-device": return deleteParkedDevice(action);
 		case "would-delete-devices": return deleteDevices(action, context);
+		case "would-shutdown-device": return action.check === "disk" ? kept("automatic maintenance does not stop devices or dev servers for disk") : shutDownIdleDevice(action);
 		case "would-stop-workspace": return action.level === 3 ? stopWorkspace(action, context) : kept("automatic maintenance stops dev servers only at disk pressure level 3");
 		case "would-clear-build-dirs":
 		case "would-delete-dependencies": return clearArtifacts(action, context);
@@ -2813,4 +3110,4 @@ function diskRecovered(budget) {
 	return measureDisk().every((disk) => disk.freeMb >= floor);
 }
 //#endregion
-export { collectWorktreeSweep as _, previewMaintenance as a, worktreeRemovalReason as b, deleteTempLeftovers as c, ARTIFACT_DIRS as d, appRoots as f, candidateRootsAsync as g, ownedDeviceUsage as h, plannedMaintenance as i, tempLeftoverLines as l, measureOwnedDevices as m, diskRecovered as n, triggeringRoot as o, finishedWorkspaces as p, executeAction as r, collectTempLeftovers as s, deleteIdleWorkspaceDevices as t, tempLeftoverSection as u, removeWorktrees as v, worktreePullRequestNote as y };
+export { worktreeRemovalReason as C, worktreePullRequestNote as S, ownedDeviceUsage as _, previewMaintenance as a, collectWorktreeSweep as b, deleteTempLeftovers as c, appRoots as d, artifactWorktrees as f, measureOwnedDevices as g, finishedWorkspaces as h, plannedMaintenance as i, tempLeftoverLines as l, collectArtifactsAsync as m, diskRecovered as n, triggeringRoot as o, clearArtifact as p, executeAction as r, collectTempLeftovers as s, deleteIdleWorkspaceDevices as t, tempLeftoverSection as u, maintenancePinned as v, removeWorktrees as x, candidateRootsAsync as y };