stim 1.27.0 → 1.29.0

package/dist/{acquire-artifact-BKN2Yuhg.mjs → acquire-artifact-C2DKfenN.mjs}

@@ -1,5 +1,5 @@
 import { l as WorkspaceProcessCleanupError } from "./exec-aULwtNly.mjs";
-import { I as waitForSharedBuild } from "./activity-Cd-ysFes.mjs";
+import { I as waitForSharedBuild } from "./activity-BR5oHSO5.mjs";
 import { rmSync } from "node:fs";
 //#region src/engine/artifact-lifecycle.ts
 async function runArtifactLifecycle(phases) {

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

@@ -1,30 +1,33 @@
-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 { S as process_identity_exports, d as workspaceProcessLockError, l as WorkspaceProcessCleanupError, n as isTimeoutError, t as getExecutor, u as withWorkspaceProcessLock } from "./exec-aULwtNly.mjs";
+import { E as workspaceDir, j as workspaceStateFile$1, k as workspaceLogsDir$1, r as readWorkspaceState$1, u as workspaceLastUsed, w as workspaceAgentDeviceDir } from "./workspace-state-DGwkPXwq.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-AbUjIBOQ.mjs";
+import { o as formatLongDuration, u as plural } from "./command-output-DjCsmzLZ.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 { At as listWorktrees, Et as hasUncommittedWorkAsync, Ft as matchWorktreeEntry, Kt as sourceCheckoutOf, O as maintenanceKeepSetting, Pt as lockReason, Ut as resolveFullRefAsync, Wt as resolveSourceCheckoutAsync, X as resolveProjectSettings, Xt as worktreeLockAsync, Z as resolveProjectSettingsAsync, bt as dirtyPathsAsync, h as deviceIdleShutdownMinutesSetting, it as settingValueAt, jt as listWorktreesAsync, mt as LOCKED_REASON, qt as unpushedCommitsAsync, sn as removeTemporaryEntryAsync, wt as hasPopulatedSubmodulesAsync } from "./settings-D776ygML.mjs";
+import { P as readRemoteSession, i as findProjectRoot$1 } from "./project-D1n0K4yg.mjs";
+import { A as listAdbDevices, D as getAvdNameForSerial, F as listAvdsAsync, G as ownedAvdSerialResolverAsync, O as getAvdNameForSerialAsync, P as listAvds, V as ownedAvdDirectory, j as listAdbDevicesAsync, yt as readParked } from "./android-BHKgeOuq.mjs";
+import { c as pidExists } from "./metro-BMQHczcf.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-DsDkdP72.mjs";
+import { o as readWebRecord, u as webFacts } from "./state-D5ZxwCGJ.mjs";
+import { a as unregister, n as readManifest } from "./cache-manifest-evF_zJ9U.mjs";
+import { B as workspaceBuildInProgress, Et as GC_OUTPUT, F as collectOwnedDeviceActivityAsync, Ot as takeGcResults, P as collectOwnedDeviceActivity, a as collectOrphanedWorkspaces, b as workspaceInUseAsync, c as isInsideWorkspaces, d as recentNativeUseReason, g as ARTIFACT_DIRS, h as workspaceDirRemoved, i as clearWorkspaceOutputs, jt as readConcurrency, kt as eachLimited, l as keptByLock, m as workspaceBuildReasons, o as collectWorkspaceOutputs, s as deleteOrphanedWorkspaces, t as LIGHTEN_AFTER_MS, u as listWorkspaceDirs, v as withIdleWorkspace, x as resolveSupervisorTarget, y as workspaceInUse } from "./workspaces-CvSYD_78.mjs";
 import { t as canonicalPath } from "./paths-BsJMoPP2.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 { N as listBuildLocks, _ as workspaceDeviceLastUseAt, b as leaseIsExpired, g as workspaceActivity, x as listLeaseFiles } from "./activity-BR5oHSO5.mjs";
+import { d as listAllIosSims, f as listAllIosSimsAsync } from "./ios-CoMCWfub.mjs";
 import { s as metroStoreRoot } from "./errors-DHm_U5gv.mjs";
-import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.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 { t as resolveMaintenanceSettings } from "./settings-D9LtQaUw.mjs";
+import { o as runStop } from "./stop-p9uSKuGE.mjs";
+import { D as stimCliUseOf, E as stimCliEntries, M as worktreeArchiveLimits, T as serviceRunningFrom, _ as cacheBlocked, a as nestedWorktrees, b as measurePressure, i as excludeWatchmanCookies, o as porcelainPath, p as removeWorktreeTarget, r as excludePodChurn, s as reclaimKeys, v as measureDisk, w as uncommittedActivityOf, x as measurePressureAsync, y as measureDiskAsync } from "./worktree-CaQBf6kh.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 { a as lastFetchedAtAsync, c as mergeStateAsync, f as recordPullRequestLookup, i as fetchDefaultBranchAsync, o as localDefaultBranchAsync, r as FETCH_FRESH_MS } from "./warm-progress--KkkBBaq.mjs";
+import { a as restoreProblem, r as recordLightened, t as finishLightened } from "./lightened-vSxkstg6.mjs";
+import { i as writeIdleShutdownEvent, n as dueIdleDevices, r as shutDownIdleDevices } from "./idle-shutdown-BM37gMfU.mjs";
 import { readClaimSet } from "@stim-cli/core/ownership-claim";
-import { existsSync, lstatSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync, 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, lastNativeUseFrom, loadConfig, readBuildHistory, readMaintenanceState, readPullRequestCache, settingDefinition, sharedCompilationCache } from "@stim-cli/core/state";
+import { buildCacheRoot, configDir, metroCacheRoot, rotatedLogPath } from "@stim-cli/core";
+import { LAST_BUILD_KEYS, MAINTENANCE_LOG_NAME, coerceSettingText, deviceViewersDir, lastNativeUseFrom, loadConfig, parseNdjsonText, readBuildHistory, readJsonObject, readMaintenanceState, readPullRequestCache, settingDefinition, settingValueError, 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";
@@ -126,7 +129,7 @@ function removalBlocker(facts, olderThan, now, noOwnCommitsIdleMs) {
 	if (facts.bare) return skip("bare-repository", "bare repository");
 	if (typeof facts.source === "object") return skip("source-checkout-unknown", `source checkout unknown: ${facts.source.refusal}`);
 	if (facts.source === "source") return skip("source-checkout", "source checkout");
-	if (facts.locked) return skip("locked", "locked with git worktree lock");
+	if (facts.locked) return skip("locked", LOCKED_REASON);
 	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");
@@ -1320,6 +1323,11 @@ async function planSweep({ settings, sizes, protectedRoot, pinned, now, devices
 	}) : { workspaces: [] };
 	for (const entry of outputs.workspaces) {
 		const root = entry.projectRoot === null ? null : canonicalPath(entry.projectRoot);
+		if (root !== null && keptByLock(entry) && entry.keptReason) skips.push({
+			target: root,
+			reason: entry.keptReason,
+			workspace: root
+		});
 		if (root === null || !entry.willClear || root === protectedRoot) continue;
 		if (pinned(root)) {
 			skips.push({
@@ -1481,6 +1489,432 @@ async function planWorktrees({ protectedRoot, pinned, now, level, graceMs, sizes
 	};
 }
 //#endregion
+//#region src/maintenance/idle-stop.ts
+const HOUR_MS = 36e5;
+const SETTING = "maintenance.idleStopHours";
+const METRO_REQUESTS = /* @__PURE__ */ new Set([
+	"bundle_response_started",
+	"bundle_response_progress",
+	"bundle_response_finished",
+	"bundle_response_failed",
+	"bundle_build_started",
+	"bundle_build_done",
+	"bundle_build_failed",
+	"manifest_request_started",
+	"manifest_request_finished",
+	"manifest_request_failed",
+	"hmr_update"
+]);
+const STIM_SESSION = "stim-teardown-inventory";
+const AGENT_DEVICE_DRIVERS = /* @__PURE__ */ new Set(["agent-device-claim", "agent-device-lease"]);
+function decideIdleStop(evidence, { idleMs, now }) {
+	if (!(idleMs > 0)) return {
+		stop: false,
+		reason: `${SETTING} is 0`
+	};
+	const last = evidence.activity.filter(({ at }) => Number.isFinite(at)).reduce((best, entry) => !best || entry.at > best.at ? entry : best, null);
+	const idle = last ? now - last.at : NaN;
+	if (last && idle < idleMs) return {
+		stop: false,
+		active: true,
+		reason: `its last ${last.basis} was ${formatLongDuration(Math.max(0, idle))} ago, within ${SETTING}`
+	};
+	if (evidence.keep.length) return {
+		stop: false,
+		reason: evidence.keep.join("; ")
+	};
+	if (!last) return {
+		stop: false,
+		reason: "its last activity is unknown"
+	};
+	return {
+		stop: true,
+		idleMs: idle
+	};
+}
+async function idleStopHours(root, env, operation) {
+	const setting = settingDefinition(SETTING);
+	if (!setting?.env) return { invalid: `${SETTING} is not in the settings registry` };
+	const raw = env[setting.env];
+	const fromEnv = raw !== void 0 && raw !== "";
+	let value;
+	if (fromEnv) value = coerceSettingText(setting, raw);
+	else try {
+		const resolved = operation ? await resolveProjectSettingsAsync(root, {
+			env,
+			signal: operation.signal,
+			declareFor: operation
+		}) : resolveProjectSettings(root);
+		value = settingValueAt(resolved.settings, SETTING);
+	} catch (error) {
+		rethrowCleanup(error, operation?.signal);
+		return { invalid: `${SETTING} cannot be resolved: ${error instanceof Error ? error.message : String(error)}` };
+	}
+	if (value === void 0) return { hours: Number(setting.default) };
+	const error = settingValueError(setting, value);
+	return error || typeof value !== "number" ? { invalid: `${fromEnv ? setting.env : SETTING} is invalid: expected ${error ?? "a number"}` } : { hours: value };
+}
+function deviceKeepReason(device, platform) {
+	const { activity } = device;
+	const what = `its ${device.kind === "ios" ? "simulator" : "emulator"} ${device.name}`;
+	if (activity.state === "driven" && !activity.basis.every((basis) => AGENT_DEVICE_DRIVERS.has(basis))) return `${what} is driven by ${activity.driver?.tool ?? "an unknown tool"}`;
+	if (activity.basis.includes("agent-device-claim") && !activity.recent?.["agent-action"]) return `${what} has a live agent-device claim whose session activity cannot be found`;
+	const probed = activity.state === "driven" ? activity.unknown ?? [] : activity.state === "unknown" ? activity.basis : [];
+	const unknown = platform === "win32" ? probed.filter((basis) => basis !== "driver-process") : probed;
+	if (unknown.length) return `${what} has unknown activity (${unknown.join(", ")})`;
+	return null;
+}
+function recentAt(activity, basis) {
+	return Date.parse(activity.recent?.[basis] ?? "");
+}
+const missing = (error) => error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+const message = (error) => error instanceof Error ? error.message : String(error);
+function agentSessionsActedAt(root) {
+	const dir = join(workspaceAgentDeviceDir(root), "sessions");
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch (error) {
+		return missing(error) ? NaN : `its agent-device sessions cannot be read (${message(error)})`;
+	}
+	let latest = NaN;
+	for (const name of names) {
+		if (name === STIM_SESSION) continue;
+		try {
+			const at = statSync(join(dir, name, "events.ndjson")).mtimeMs;
+			if (!(at <= latest)) latest = at;
+		} catch (error) {
+			if (!missing(error)) return `its agent-device session ${name} cannot be read (${message(error)})`;
+		}
+	}
+	return latest;
+}
+function metroRequestAt(root, since, serving) {
+	const file = join(workspaceLogsDir$1(root), "metro.ndjson");
+	const rotated = rotatedLogPath(file);
+	const records = [];
+	for (const path of [rotated, file]) try {
+		records.push(...parseNdjsonText(readFileSync(path, "utf8")));
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") continue;
+		return `its Metro log cannot be read (${error instanceof Error ? error.message : String(error)})`;
+	}
+	let latest = NaN;
+	let earliest = Infinity;
+	for (const record of records) {
+		if (typeof record.ts !== "number") continue;
+		earliest = Math.min(earliest, record.ts);
+		if (typeof record.event === "string" && METRO_REQUESTS.has(record.event) && !(record.ts <= latest)) latest = record.ts;
+	}
+	if (!Number.isFinite(latest) && earliest > since && existsSync(rotated)) return `its rotated Metro log does not reach back ${SETTING}`;
+	if (serving && earliest === Infinity) return "its dev server runs but its Metro log is missing or empty";
+	return latest;
+}
+function unreadableViewers() {
+	const dir = deviceViewersDir();
+	let names;
+	try {
+		names = readdirSync(dir).filter((name) => name.endsWith(".json"));
+	} catch (error) {
+		return missing(error) ? null : `the stim-server viewer records cannot be read (${message(error)})`;
+	}
+	for (const name of names) {
+		const record = readJsonObject(join(dir, name));
+		if (!record) return `the stim-server viewer record ${name} cannot be read`;
+		if ((0, process_identity_exports.inspectProcessIdentity)(record) === "unknown") return `the stim-server behind the viewer record ${name} cannot be verified`;
+	}
+	return null;
+}
+async function keepReasons(root, devices, { now, platform, locked, operation }) {
+	const checks = {
+		devServer: false,
+		nativeRun: !locked
+	};
+	const keep = operation ? await workspaceInUseAsync(root, checks, operation.signal, operation) : workspaceInUse(root, checks);
+	if (workspaceBuildInProgress(root)) keep.push("a build is in progress");
+	if (readRemoteSession(root)) keep.push("it has a remote device session");
+	const holder = canonicalPath(root);
+	for (const { lease, path } of listLeaseFiles()) if (!lease) keep.push(`the device lease ${path} cannot be read`);
+	else if (!leaseIsExpired(lease, now) && canonicalPath(lease.holder) === holder) keep.push(`it holds the ${lease.platform} device lease on ${lease.deviceName ?? lease.id}`);
+	const browser = webFacts(readWebRecord(root));
+	if (browser && browser.status !== "stopped") keep.push(`its owned Chrome is ${browser.status}`);
+	for (const device of devices) {
+		const reason = deviceKeepReason(device, platform);
+		if (reason) keep.push(reason);
+	}
+	const viewers = devices.length ? unreadableViewers() : null;
+	if (viewers) keep.push(viewers);
+	return keep;
+}
+async function idleStopEvidence(root, devices, { now, idleMs, platform = process.platform, locked = false, serving = false, operation }) {
+	const state = readWorkspaceState$1(root);
+	if (!state && existsSync(workspaceStateFile$1(root))) return {
+		activity: [],
+		keep: ["its state.json cannot be read"]
+	};
+	const sessions = agentSessionsActedAt(root);
+	if (typeof sessions === "string") return {
+		activity: [],
+		keep: [sessions]
+	};
+	const build = state?.lastBuild;
+	const builtAt = Date.parse(String(build?.startedAt ?? "")) + (typeof build?.durationMs === "number" ? build.durationMs : 0);
+	const activity = [
+		{
+			basis: "stim command",
+			at: Date.parse(String(state?.lastUsedAt ?? ""))
+		},
+		{
+			basis: "native run",
+			at: builtAt
+		},
+		{
+			basis: "agent-device command",
+			at: typeof sessions === "number" ? sessions : NaN
+		},
+		...devices.flatMap(({ activity: device }) => [{
+			basis: "agent-device command",
+			at: recentAt(device, "agent-action")
+		}, {
+			basis: "live view",
+			at: recentAt(device, "viewer")
+		}])
+	].filter(({ at }) => Number.isFinite(at));
+	if (activity.some(({ at }) => now - at < idleMs)) return {
+		activity,
+		keep: []
+	};
+	const keep = await keepReasons(root, devices, {
+		now,
+		platform,
+		locked,
+		operation
+	});
+	if (keep.length) return {
+		activity,
+		keep
+	};
+	const metro = metroRequestAt(root, now - idleMs, serving);
+	if (typeof metro === "string") return {
+		activity,
+		keep: [metro]
+	};
+	if (Number.isFinite(metro)) activity.push({
+		basis: "Metro request",
+		at: metro
+	});
+	return {
+		activity,
+		keep
+	};
+}
+function rethrowCleanup(error, signal) {
+	if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+	signal?.throwIfAborted();
+}
+async function unseenEmulatorError(unseen, operation) {
+	try {
+		const signal = operation?.signal;
+		const adb = operation ? await listAdbDevicesAsync({
+			timeoutMs: 5e3,
+			signal,
+			operation
+		}) : listAdbDevices({ timeoutMs: 5e3 });
+		for (const { serial } of [...adb.emulators, ...adb.unhealthy.filter((entry) => entry.kind === "emulator")]) {
+			const name = operation ? await getAvdNameForSerialAsync(serial, {
+				timeoutMs: 5e3,
+				signal,
+				operation
+			}) : getAvdNameForSerial(serial, { timeoutMs: 5e3 });
+			if (name === null) return `its emulators cannot be identified to prove them idle (${serial} gave no AVD name)`;
+			if (unseen.includes(name)) return `its emulator ${name} runs as ${serial}, but its activity could not be read`;
+		}
+		return null;
+	} catch (error) {
+		rethrowCleanup(error, operation?.signal);
+		return `its emulators cannot be listed to prove them idle (${error instanceof Error ? error.message : String(error)})`;
+	}
+}
+function survivingServer(recorded) {
+	const pid = recorded?.serverPid;
+	if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return null;
+	const token = recorded?.serverProcessToken;
+	return (typeof token === "string" ? ["same", "unknown"].includes((0, process_identity_exports.inspectProcessIdentity)({
+		pid,
+		processToken: token
+	})) : pidExists(pid)) ? `its dev server (pid ${pid}) may still run after its supervisor exited; stim stop ends it` : null;
+}
+async function candidate(path, env, devices, operation) {
+	const signal = operation?.signal;
+	const project = loadConfig$1()?.projects?.[path];
+	if (!project) return null;
+	const supervisor = resolveSupervisorTarget({
+		state: readWorkspaceState$1(path)?.supervisor,
+		record: project.supervisor,
+		reservedPort: project.metroPort
+	});
+	const slots = projectDeviceSlots(project);
+	const ownsIos = slots.some(({ platforms }) => platforms.ios?.owned === true);
+	const owns = ownsIos || slots.some(({ platforms }) => platforms.android?.owned === true);
+	if (!owns && (supervisor.status === "none" || supervisor.status === "stale")) return null;
+	const setting = await idleStopHours(path, env, operation);
+	if ("invalid" in setting) return { skip: setting.invalid };
+	if (setting.hours === 0) return null;
+	let booted = [];
+	if (owns) try {
+		booted = (await devices(ownsIos)).filter((device) => device.project === path);
+	} catch (error) {
+		rethrowCleanup(error, signal);
+		return supervisor.status === "none" || supervisor.status === "stale" ? null : { skip: "its owned devices cannot be listed to prove them idle" };
+	}
+	if (supervisor.status === "unverified") return { skip: `its dev server supervisor cannot be verified: ${supervisor.reason ?? "unknown identity"}` };
+	if (supervisor.status === "ours" && readWorkspaceState$1(path)?.supervisor?.mode === "command-child") return { skip: "its dev server runs metro.command, whose bundle and HMR requests Stim cannot see" };
+	if (supervisor.status === "ours" && readWorkspaceState$1(path)?.supervisor?.hmrUpdates !== true) return { skip: "its dev server does not report HMR updates to Stim: an Expo SDK before 54, or a server an older Stim started, which stim stop and stim start restart" };
+	const avdNames = slots.flatMap(({ platforms }) => platforms.android?.owned && platforms.android.avdName ? [platforms.android.avdName] : []);
+	if (supervisor.status !== "ours" && booted.length === 0) return null;
+	const orphan = supervisor.status === "stale" ? survivingServer(readWorkspaceState$1(path)?.supervisor) : null;
+	if (orphan) return { skip: orphan };
+	const seen = new Set(booted.flatMap((device) => device.kind === "android" ? [device.id] : []));
+	const unseen = avdNames.filter((name) => !seen.has(name));
+	const emulators = unseen.length ? await unseenEmulatorError(unseen, operation) : null;
+	if (emulators) return { skip: emulators };
+	return {
+		path,
+		hours: setting.hours,
+		serving: supervisor.status === "ours",
+		devices: booted
+	};
+}
+/**
+* Plans stopping each workspace, other than `protectedRoot`, whose dev server runs or whose owned simulator or
+* emulator is booted, once it has had no real activity for its maintenance.idleStopHours.
+*/
+async function planIdleStop({ protectedRoot, now, devices, env = process.env, platform = process.platform, operation }) {
+	const plan = {
+		actions: [],
+		blocked: [],
+		skips: []
+	};
+	if (deviceSweepIsScoped(env)) return plan;
+	for (const path of Object.keys(loadConfig$1()?.projects ?? {})) {
+		const root = canonicalPath(path);
+		if (root === protectedRoot) continue;
+		operation?.signal.throwIfAborted();
+		const found = await candidate(path, env, devices, operation);
+		if (!found) continue;
+		if ("skip" in found) {
+			plan.skips.push({
+				target: root,
+				reason: found.skip,
+				workspace: root
+			});
+			continue;
+		}
+		const idleMs = found.hours * HOUR_MS;
+		const decision = decideIdleStop(await idleStopEvidence(path, found.devices, {
+			now,
+			idleMs,
+			platform,
+			serving: found.serving,
+			operation
+		}), {
+			idleMs,
+			now
+		});
+		if (!decision.stop) {
+			if (!decision.active) plan.skips.push({
+				target: root,
+				reason: decision.reason,
+				workspace: root
+			});
+			continue;
+		}
+		plan.actions.push({
+			kind: "would-stop-workspace",
+			check: "idle",
+			target: root,
+			workspace: root,
+			bytes: 0,
+			reason: `no real activity for ${formatLongDuration(decision.idleMs)}, over ${SETTING} ${found.hours}`
+		});
+	}
+	return plan;
+}
+const kept$1 = (detail) => ({
+	status: "kept",
+	bytes: 0,
+	detail
+});
+/**
+* Stops a planned idle workspace the way `stim stop` does, under its native-run and metro-start locks, after
+* deciding again that it is still idle. Physical-device leases stay.
+*/
+async function stopIdleWorkspace(action, { protectedRoot, devices, operation, env = operation?.env ?? process.env, by = "automatic maintenance" }) {
+	const root = action.workspace ?? action.target;
+	if (root === protectedRoot) return kept$1("the command that started this pass runs in it");
+	if (deviceSweepIsScoped(env)) return kept$1("STIM_HOME scopes this config, and devices are machine-wide");
+	const path = Object.keys(loadConfig$1()?.projects ?? {}).find((entry) => canonicalPath(entry) === root) ?? root;
+	const stillIdle = async () => {
+		const now = Date.now();
+		const found = await candidate(path, env, devices(), operation);
+		if (!found) return "nothing of it runs any more";
+		if ("skip" in found) return found.skip;
+		const idleMs = found.hours * HOUR_MS;
+		const decision = decideIdleStop(await idleStopEvidence(path, found.devices, {
+			now,
+			idleMs,
+			locked: true,
+			serving: found.serving,
+			operation
+		}), {
+			idleMs,
+			now
+		});
+		return decision.stop ? null : decision.reason;
+	};
+	const signal = operation?.signal;
+	const run = await withIdleWorkspace(path, async () => {
+		try {
+			return await withWorkspaceProcessLock(workspaceDir(path), "metro-start", async () => {
+				const active = await stillIdle();
+				if (active) return kept$1(active);
+				const stopped = await runStop({
+					root: path,
+					operation,
+					report: () => {},
+					requester: { by: `${by} (${action.reason})` },
+					releaseLeases: () => []
+				});
+				return stopped.ok ? {
+					status: "done",
+					bytes: 0,
+					detail: stopped.summary
+				} : {
+					status: "failed",
+					bytes: 0,
+					detail: stopped.summary
+				};
+			}, {
+				external: true,
+				waitMs: 0,
+				ownerPurpose: "idle stop",
+				signal,
+				declareSpawnsFor: operation
+			});
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			signal?.throwIfAborted();
+			if (workspaceProcessLockError(error)) return kept$1("a stim start holds its metro-start lock");
+			throw error;
+		}
+	}, {
+		purpose: "automatic maintenance",
+		devServer: false,
+		operation
+	});
+	return run.ran ? run.value : kept$1(`in use: ${run.reasons.join("; ")}`);
+}
+//#endregion
 //#region src/workspace/running-from.ts
 const LIST_TIMEOUT_MS = 1e4;
 function parsePs(text) {
@@ -1629,6 +2063,7 @@ function artifactWorktree(root, entries, source = sourceCheckoutOf(entries)) {
 	return {
 		path: entry.path,
 		linked: entry.path !== source.path,
+		locked: Boolean(entry.locked),
 		keys
 	};
 }
@@ -1725,6 +2160,7 @@ function buildNativeUseReason(keys, now) {
 function artifactGuard(candidate, kind, pinned, locked, running) {
 	const { worktree, path, keys } = candidate;
 	if (keys.some(pinned)) return "pinned by maintenance.keep";
+	if (candidate.locked) return LOCKED_REASON;
 	if (!pathExists(path)) return "it is already gone";
 	let real;
 	try {
@@ -1770,7 +2206,8 @@ async function collectArtifactsAsync(kind, options, signal, operation) {
 			const candidate = {
 				worktree: worktree.path,
 				path,
-				keys: worktree.keys
+				keys: worktree.keys,
+				locked: worktree.locked
 			};
 			let reason = protectedHere ? "the command that started this pass runs inside its worktree" : artifactGuard(candidate, kind, options.pinned, void 0, running);
 			if (!reason) {
@@ -1828,7 +2265,8 @@ function collectArtifacts(kind, options) {
 			const candidate = {
 				worktree: worktree.path,
 				path,
-				keys: worktree.keys
+				keys: worktree.keys,
+				locked: worktree.locked
 			};
 			const reason = protectedHere ? "the command that started this pass runs inside its worktree" : keptReason(candidate, kind, {
 				...options,
@@ -1867,7 +2305,8 @@ async function clearArtifact(action, kind, options) {
 	const candidate = {
 		worktree: worktree.path,
 		path: action.target,
-		keys: worktree.keys
+		keys: worktree.keys,
+		locked: worktree.locked
 	};
 	const running = kind === "dependencies" ? await readRunningProcessesAsync() : null;
 	const early = keptReason(candidate, kind, {
@@ -1889,6 +2328,8 @@ async function clearArtifact(action, kind, options) {
 	const before = lowestFree(measureDisk());
 	const [key] = candidate.keys;
 	const remove = async () => {
+		const lock = candidate.locked ? "locked" : await worktreeLockAsync(candidate.worktree);
+		if (lock) return lockReason(lock);
 		const reason = keptReason(candidate, kind, {
 			...options,
 			now: Date.now(),
@@ -2285,6 +2726,11 @@ async function planLevel2({ settings, sizes, protectedRoot, pinned, now, operati
 		lighten: true
 	})).workspaces.flatMap((entry) => {
 		const root = entry.projectRoot === null ? null : canonicalPath(entry.projectRoot);
+		if (root !== null && keptByLock(entry) && entry.keptReason) skips.push({
+			target: root,
+			reason: entry.keptReason,
+			workspace: root
+		});
 		if (root === null || !entry.willClear || root === protectedRoot || pinned(root)) return [];
 		const used = workspaceLastUsed(root);
 		return Number.isFinite(used) ? [{
@@ -2501,7 +2947,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, idle = false, refresh = true, operation } = {}) {
+async function plannedMaintenance(pressure, recordedSizes, settings, { devices = true, sweep = false, worktrees = false, idle = false, refresh = true, background = false, operation } = {}) {
 	const env = operation?.env ?? process.env;
 	const resolved = resolveBudget({ env });
 	if (resolved.error) throw new Error(resolved.error);
@@ -2577,7 +3023,7 @@ async function plannedMaintenance(pressure, recordedSizes, settings, { devices =
 		recentlyUsed: (workspace) => recentUse(workspace, settings)
 	});
 	const merge = (extra) => {
-		for (const action of extra.actions) if (!result.actions.some((entry) => entry.kind === action.kind && entry.target === action.target && (entry.level === action.level || action.kind === "would-delete-devices"))) result.actions.push(action);
+		for (const action of extra.actions) if (!result.actions.some((entry) => entry.kind === action.kind && entry.target === action.target && (entry.level === action.level || action.kind === "would-delete-devices") && (action.check !== "idle" || entry.check === "idle"))) result.actions.push(action);
 		result.blocked.push(...extra.blocked);
 		result.skips.push(...extra.skips);
 	};
@@ -2604,11 +3050,27 @@ async function plannedMaintenance(pressure, recordedSizes, settings, { devices =
 		merge(planned);
 		result.worktreeSweep = planned.sweep;
 	}
-	if (idle && devices) merge(planIdleShutdown({
-		protectedRoot: root,
-		now: Date.now(),
-		env
-	}));
+	if (idle && devices) {
+		merge(planIdleShutdown({
+			protectedRoot: root,
+			now: Date.now(),
+			env
+		}));
+		const now = Date.now();
+		try {
+			merge(await planIdleStop({
+				protectedRoot: background ? "" : root,
+				now,
+				env,
+				operation,
+				devices: operation ? cachedDeviceActivityAsync(now, env, operation.signal, operation) : cachedDeviceActivity(now)
+			}));
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			operation?.signal.throwIfAborted();
+			result.blocked.push(`idle stop could not be planned: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
 	if (pressure) {
 		const pressured = await planPressureLevels(diskPressureLevel(lowestFree(pressure.disk), budget, settings), {
 			settings,
@@ -2804,7 +3266,8 @@ async function clearOutputs(action, context) {
 		olderThan,
 		now,
 		measure: false,
-		lighten
+		lighten,
+		only: root
 	});
 	const entry = report.workspaces.find((candidate) => candidate.projectRoot && canonicalPath(candidate.projectRoot) === root);
 	if (!entry) return kept("it has no build outputs any more");
@@ -3096,7 +3559,12 @@ async function executeAction(action, context) {
 		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-stop-workspace":
+			if (action.level === 3) return stopWorkspace(action, context);
+			return action.check === "idle" ? stopIdleWorkspace(action, {
+				protectedRoot: context.background ? "" : context.protectedRoot,
+				devices: () => cachedDeviceActivity(Date.now())
+			}) : kept("automatic maintenance stops dev servers only at disk pressure level 3 or after maintenance.idleStopHours");
 		case "would-clear-build-dirs":
 		case "would-delete-dependencies": return clearArtifacts(action, context);
 		case "would-stop-gradle-daemons": return stopGradleDaemonsAction(action);
@@ -3110,4 +3578,4 @@ function diskRecovered(budget) {
 	return measureDisk().every((disk) => disk.freeMb >= floor);
 }
 //#endregion
-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 };
+export { candidateRootsAsync as C, worktreeRemovalReason as D, worktreePullRequestNote as E, maintenancePinned as S, removeWorktrees as T, finishedWorkspaces as _, previewMaintenance as a, cachedDeviceActivity as b, deleteTempLeftovers as c, appRoots as d, artifactWorktrees as f, stopIdleWorkspace as g, planIdleStop 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, measureOwnedDevices as v, collectWorktreeSweep as w, cachedDeviceActivityAsync as x, ownedDeviceUsage as y };