stim 1.26.0 → 1.28.0

package/dist/{worktree-BKuklFh_.mjs → worktree-2dk5edza.mjs}

@@ -1,209 +1,45 @@
-import { D as ownership_claim_exports, S as process_identity_exports, b as operationState, l as WorkspaceProcessCleanupError, m as declareSpawnsOn, n as isTimeoutError, t as getExecutor, v as stopDeclaringSpawnsOn } from "./exec-VFRpu1iA.mjs";
-import { E as workspaceDir, a as recordWorkspaceUseAsync, l as withWorkspaceStateLockAsync, r as readWorkspaceState$1, w as workspaceAgentDeviceDir } from "./workspace-state-pUg3_RRA.mjs";
-import { E as upsertProject, G as projectDeviceSlots, L as measuredDirectorySizeAsync, O as withConfigLockAsync$1, S as removeProject, _ as loadConfig$1, a as clearDevice, d as getConfigDir, g as isPathPrefix, j as acquireAvdClaim, p as getProject } from "./config-BktkY_zC.mjs";
-import { a as formatElapsed, h as shortUdid, i as formatDuration, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-BF5AR2dL.mjs";
-import { c as gitQuiet, o as git, r as childEnvironment, s as gitAsync, t as runOperationFile } from "./operation-exec-CUZifp6Z.mjs";
-import { At as podsOutOfSync, B as readCommittedSettings, Bt as unpushedCommitsAsync, Ct as hasUncommittedWorkAsync, Dt as listWorktreesAsync, Ft as resolveFullRef, Gt as removeTemporaryEntryAsync, Ht as filesystemDevice, It as resolveFullRefAsync, J as resolveProjectSettings, Mt as removeWorktreeAsync, Ot as locallyKnownUpstream, Rt as restoreFileAsync, St as hasRemoteAsync, Vt as warmWorktreePaths, X as resolveSettings, _t as dirtyPathsAsync, a as SETTING_SHAPE_REMEDY, at as unknownSettingKeys, bt as gitCommonDirOnDisk, ft as branchExistsAsync, ht as depsOutOfSync, jt as readWorktreeExclude, mt as deleteBranchAsync, pt as cloneIgnoredEntries, q as resolveIosProjectDir, tt as settingShapeErrors, wt as isPodInstallChurn, xt as hasPopulatedSubmodulesAsync, yt as gitCommonDirAsync, zt as sourceCheckoutOf } from "./settings-CosW5X-S.mjs";
-import { F as readRemoteSessionId, M as readMetroTunnel, O as clearManagedMetroTunnel, P as readRemoteSession, T as MODE_COMMAND, i as findProjectRoot$1, k as clearRemoteSession, o as isMobileProject } from "./project-BUu6Is4k.mjs";
-import { t as macosAppPresent } from "./state-C4OdpOTF.mjs";
-import { a as workspaceLinkLine, o as workspaceLinks } from "./stim-desktop-6Dqp-gjX.mjs";
-import { ft as POOL_SETTING_REMEDY, vt as parkedMaxSetting } from "./android-DTAcRwBC.mjs";
-import { c as pidExists, d as resolveProjectMetro, p as signalProcessTreeAsync, r as killMetroTreeAsync } from "./metro-CjC10t6E.mjs";
-import { o as readWebRecord } from "./state-C1i2nMOP.mjs";
-import { Dr as discoverCaches, Gt as endRecordedSession, S as withdrawDevServerStopRequest, Un as runProcessOperation, b as requestDevServerStop, c as readVolumeSpace, ct as planCacheEmptying, er as resolveEasCliBin, l as readVolumeSpaceAsync, o as machineNumber, u as resolveBudget } from "./budget-k2mZGvvk.mjs";
+import { D as ownership_claim_exports, S as process_identity_exports, b as operationState, l as WorkspaceProcessCleanupError, m as declareSpawnsOn, n as isTimeoutError, t as getExecutor, v as stopDeclaringSpawnsOn } from "./exec-aULwtNly.mjs";
+import { E as workspaceDir, a as recordWorkspaceUseAsync, l as withWorkspaceStateLockAsync, r as readWorkspaceState$1, w as workspaceAgentDeviceDir } from "./workspace-state-kIZrdlSg.mjs";
+import { E as upsertProject, G as projectDeviceSlots, L as measuredDirectorySizeAsync, O as withConfigLockAsync$1, S as removeProject, _ as loadConfig$1, a as clearDevice, d as getConfigDir, g as isPathPrefix$1, j as acquireAvdClaim, p as getProject } from "./config-Cn94Jc0g.mjs";
+import { a as formatElapsed, h as shortUdid, i as formatDuration, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-C8R1KIvi.mjs";
+import { c as gitQuiet, l as gitQuietAsync, o as git, r as childEnvironment, s as gitAsync, t as runOperationFile } from "./operation-exec-Dp4FuIGR.mjs";
+import { Ct as gitCommonDirOnDisk, Dt as isPodInstallChurn, Et as hasUncommittedWorkAsync, Ft as matchWorktreeEntry, Gt as restoreFileAsync, Ht as resolveFullRef, It as nativeCanonicalPath, Jt as warmWorktreePaths, Kt as sourceCheckoutOf, Lt as podsOutOfSync, Mt as locallyKnownUpstream, Q as resolveSettings, Rt as readWorktreeExclude, St as gitCommonDirAsync, Tt as hasRemoteAsync, Ut as resolveFullRefAsync, V as readCommittedSettings, X as resolveProjectSettings, Y as resolveIosProjectDir, _ as inertSettingWarning, _t as deleteBranchAsync, a as SETTING_SHAPE_REMEDY, bt as dirtyPathsAsync, gt as cloneIgnoredEntries, ht as branchExistsAsync, jt as listWorktreesAsync, nn as moveIgnoredTreesToTrash, qt as unpushedCommitsAsync, rn as restoreTrashedTrees, rt as settingShapeErrors, st as unknownSettingKeys, tn as disposeTrash, vt as depsOutOfSync, wt as hasPopulatedSubmodulesAsync, zt as removeWorktreeAsync } from "./settings-CY5JZlNN.mjs";
+import { F as readRemoteSessionId, M as readMetroTunnel, O as clearManagedMetroTunnel, P as readRemoteSession, T as MODE_COMMAND, i as findProjectRoot$1, k as clearRemoteSession, o as isMobileProject } from "./project-Sui52ywT.mjs";
+import { t as macosAppPresent } from "./state-BXC1Lfxw.mjs";
+import { a as workspaceLinkLine, o as workspaceLinks } from "./stim-desktop-CbWo21kb.mjs";
+import { ft as POOL_SETTING_REMEDY, vt as parkedMaxSetting } from "./android-CsPs-7Mg.mjs";
+import { c as pidExists, d as resolveProjectMetro, p as signalProcessTreeAsync, r as killMetroTreeAsync } from "./metro-BnhXV2Mj.mjs";
+import { A as diskPressureLevel, D as requestDevServerStop, En as runProcessOperation, G as planCacheEmptying, Ln as resolveEasCliBin, N as lowestFree, Ot as endRecordedSession, _ as resolveBudget, g as readVolumeSpaceAsync, h as readVolumeSpace, k as withdrawDevServerStopRequest, p as machineNumber, ur as discoverCaches } from "./ccache-Bm_A1xX9.mjs";
+import { o as readWebRecord } from "./state-B2QJbDwz.mjs";
+import { C as stopTunnel, E as withManagedRemoteWorktreeRemovalLock, O as withManagedTunnelRemovalLock, _ as emptyWorkspaceDir, ht as teardownOwnedIosSim, mt as teardownOwnedBrowser, o as collectWorkspaceOutputs, pt as teardownOwnedAvd, v as withIdleWorkspace, x as resolveSupervisorTarget } from "./workspaces-CmOcceDN.mjs";
 import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
-import { p as cacheUser } from "./native-run-BfIDFKLH.mjs";
-import { A as teardownOwnedIosSim, C as withManagedTunnelRemovalLock, O as teardownOwnedAvd, a as collectWorkspaceOutputs, f as emptyWorkspaceDir, g as resolveSupervisorTarget, k as teardownOwnedBrowser, p as withIdleWorkspace, v as stopTunnel, x as withManagedRemoteWorktreeRemovalLock } from "./workspaces-g2lhdBXF.mjs";
-import { D as releaseWorkspaceLeases, t as agentDeviceDaemon } from "./activity-Lnb_EoRY.mjs";
-import { L as readHostMemoryPressure, R as readHostMemoryPressureAsync } from "./ios-WxpDJ5T1.mjs";
-import { t as clearNamedPorts } from "./named-ports-BG0j1X4g.mjs";
+import { D as runCaptured, O as runPodInstall, S as DEPS_ERROR, T as readPodState, Y as podInstallCommand, ct as cacheUser, j as HEARTBEAT_INTERVAL_MS, w as podsAreStale } from "./toolchain-mLA_km-b.mjs";
+import { D as releaseWorkspaceLeases, t as agentDeviceDaemon } from "./activity-DRMg4_mD.mjs";
+import { R as readHostMemoryPressure, z as readHostMemoryPressureAsync } from "./ios-B1DYuOjh.mjs";
+import { t as clearNamedPorts } from "./named-ports-Phoi2POD.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
-import { D as runCaptured, O as runPodInstall, S as DEPS_ERROR, T as readPodState, Y as podInstallCommand, j as HEARTBEAT_INTERVAL_MS, w as podsAreStale } from "./toolchain-J4J8MrAr.mjs";
-import { i as stopHostedAndroid } from "./hosted-android-Bk54ej6n.mjs";
-import { r as stopHostedIos } from "./hosted-ios-D55QhYaD.mjs";
-import { n as stopMacosApp } from "./stop-ySNQHXMG.mjs";
-import { n as verifyCollectorOwnership } from "./ownership-BjYvMNX_.mjs";
-import { n as removePhoneReverses } from "./phone-reverses-lmj6kcPm.mjs";
-import { a as discoverXcodeProject } from "./react-native-build-oNwqF5Wb.mjs";
-import { n as hasInstalledDependencies, r as installedNpmTreeIsValid, t as dependencyState } from "./dependency-state-DFB41vfr.mjs";
-import { a as forgetStatusMeasures, p as mergeStateAsync, t as startWarmProgress } from "./warm-progress-DvhTX_eu.mjs";
-import { o as pullRequestLookupAsync, r as endedPullRequest } from "./pull-request-CbNlkFok.mjs";
-import { r as workspaceRecordingEnabled } from "./recordings-BldzVKq0.mjs";
+import { i as stopHostedAndroid } from "./hosted-android-DlaKLbW0.mjs";
+import { a as stopHostedIos, n as removePhoneReverses } from "./phone-reverses-BzTa8g1F.mjs";
+import { r as stopMacosApp } from "./stop-DQvE-P76.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-DJCq48IJ.mjs";
+import { o as pullRequestLookupAsync, r as endedPullRequest } from "./pull-request-BzLmzAIQ.mjs";
+import { c as mergeStateAsync, d as forgetStatusMeasures, t as startWarmProgress } from "./warm-progress-B0Vpuvpl.mjs";
+import { r as workspaceRecordingEnabled } from "./recordings-iy0mkm7b.mjs";
+import { i as installedNpmTreeProblems, n as hasInstalledDependencies, t as dependencyState } from "./dependency-state-CojA2o0t.mjs";
+import { a as discoverXcodeProject } from "./react-native-build-jUHnIfZ9.mjs";
 import { claimRemoveCommand, clearFreeClaimSet, readClaimSet, releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { cpus, freemem, homedir, loadavg, totalmem } from "node:os";
 import { basename, dirname, join, relative } from "node:path";
-import { buildCacheRoot, configDir, metroCacheRoot, unitLines, unitWords, withDirLockTransaction, workspaceName } from "@stim-cli/core";
-import { LAST_BUILD_KEYS, archiveDir, archiveEnabled, archiveLock, archiveRoot, archivedUsage, buildWorkerRoot, countErrorEntries, endedAgentSessionOf, isJsonObject, listRecordedDevicesAsync, loadConfig, queryLogs, readArchivesAsync, readBuildHistory, readJsonObject, readLastBuilds, readMacosRecord, readPullRequestCache, readWorkspaceState, recordingEnabled, sharedCcache, sharedCompilationCache, sortByTs, trashRoot } from "@stim-cli/core/state";
+import { buildCacheRoot, configDir, metroCacheRoot, quotedPath, unitLines, unitWords, withDirLockTransaction, workspaceName } from "@stim-cli/core";
+import { LAST_BUILD_KEYS, archiveDir, archiveEnabled, archiveLock, archiveRoot, archivedUsage, buildWorkerRoot, countErrorEntries, endedAgentSessionOf, isJsonObject, isPathPrefix, listRecordedDevicesAsync, loadConfig, queryLogs, readArchivesAsync, readBuildHistory, readJsonObject, readLastBuilds, readMacosRecord, readPullRequestCache, readWorkspaceState, recordingEnabled, sharedCcache, sharedCompilationCache, sortByTs, trace, worktreeArchiveRoot } from "@stim-cli/core/state";
 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 { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { captureProcessIdentity } from "@stim-cli/core/process-identity";
 import chalk from "chalk";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, readlinkSync as readlinkSync$1, realpathSync as realpathSync$1, renameSync as renameSync$1, rmSync as rmSync$1, symlinkSync as symlinkSync$1, unlinkSync as unlinkSync$1, writeFileSync as writeFileSync$1 } from "fs";
-import { chmod, lstat, mkdir, mkdtemp, readdir, rename, rm, rmdir, stat, utimes, writeFile } from "node:fs/promises";
+import { chmod, lstat, mkdir, readdir, rename, rm, rmdir, stat, utimes, writeFile } from "node:fs/promises";
 import { createHash as createHash$1 } from "crypto";
-//#region src/maintenance/pressure.ts
-/**
-* The free-disk floor of each level in MiB. Level 2 has no floor of its own: it runs when level 1 left free disk
-* under the budget floor, and stops once free disk is back above it. Its urgent threshold only sets the reported level.
-*/
-function levelFloors(budget, settings) {
-	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
-	return {
-		1: floor,
-		2: floor,
-		3: Math.max(settings.criticalFreeDiskGb * 1024, budget.hardFloorDiskMb),
-		urgent: settings.urgentFreeDiskGb * 1024
-	};
-}
-function diskPressureLevel(freeMb, budget, settings) {
-	const floors = levelFloors(budget, settings);
-	if (freeMb < floors[3]) return 3;
-	if (freeMb < floors.urgent) return 2;
-	return freeMb < floors[1] ? 1 : 0;
-}
-function lowestFree(disk) {
-	return disk.length ? Math.min(...disk.map((volume) => volume.freeMb)) : Infinity;
-}
-/** Whether an action planned at a pressure level may still run with this much free disk. */
-function levelStillShort(action, freeMb, budget, settings) {
-	return action.level === void 0 || freeMb < levelFloors(budget, settings)[action.level];
-}
-/** The protection window in milliseconds: protectRecentHours, or maintenance.pressureProtectMinutes for actions of level 2 and 3. */
-function protectWindowMs(action, settings) {
-	return action.level === void 0 ? settings.protectRecentHours * 36e5 : settings.pressureProtectMinutes * 6e4;
-}
-//#endregion
-//#region src/maintenance/measure.ts
-function measureDisk() {
-	return readVolumeSpace([
-		configDir(),
-		...Object.keys(loadConfig()?.projects ?? {}),
-		buildWorkerRoot(loadConfig())
-	]);
-}
-function measureDiskAsync(operation) {
-	return readVolumeSpaceAsync([
-		configDir(),
-		...Object.keys(loadConfig()?.projects ?? {}),
-		buildWorkerRoot(loadConfig())
-	], operation.signal);
-}
-/** The disk pressure level of the fullest volume Stim writes to, measured now. */
-function currentDiskLevel(disk = measureDisk()) {
-	return diskPressureLevel(lowestFree(disk), resolveBudget().budget, resolveMaintenanceSettings());
-}
-function measurePressure(settings, previous, now) {
-	return pressureFromObservations(settings, previous, now, readHostMemoryPressure(), measureDisk());
-}
-async function measurePressureAsync(settings, previous, now, operation) {
-	return pressureFromObservations(settings, previous, now, await readHostMemoryPressureAsync(void 0, void 0, operation.signal, operation), await readVolumeSpaceAsync([
-		configDir(),
-		...Object.keys(loadConfig()?.projects ?? {}),
-		buildWorkerRoot(loadConfig())
-	], operation.signal));
-}
-function pressureFromObservations(settings, previous, now, level, disk) {
-	const availableBytes = process.platform === "darwin" ? null : freemem();
-	const warningSince = level === "warning" ? previous?.warningSince ?? now : null;
-	return {
-		disk,
-		memory: {
-			level,
-			availableBytes,
-			pressured: settings.memoryPressureLevel !== "off" && (level === "critical" || settings.memoryPressureLevel === "warning" && warningSince !== null && now - warningSince >= settings.memoryWarningMinutes * 6e4 || availableBytes !== null && availableBytes < (settings.minAvailableMemoryGb === void 0 ? totalmem() * .1 : settings.minAvailableMemoryGb * 1024 ** 3))
-		},
-		warningSince
-	};
-}
-function sizeScanDeferred(settings) {
-	return loadavg()[0] / Math.max(1, cpus().length) > settings.maxLoadPerCore;
-}
-function cacheBlocked(entry, discovered = discoverCaches(), env = process.env) {
-	return planCacheEmptying([{
-		...entry,
-		note: "",
-		prune: "entries",
-		...discovered.some((cache) => canonicalPath(cache.dir) === canonicalPath(entry.dir) && cache.source === "registered") ? { source: "registered" } : {}
-	}], false, env)[0]?.machineGlobal ?? (entry.category === "compilation-cache" ? cacheUser(entry.dir) : void 0);
-}
-async function measureSizes(now, failure) {
-	const sizes = [];
-	const outputs = await collectWorkspaceOutputs({
-		olderThan: null,
-		now,
-		sizeTimeoutMs: 12e4
-	});
-	for (const entry of outputs.workspaces) {
-		if (entry.bytes === null) {
-			failure(entry.dir, entry.projectRoot ?? void 0);
-			continue;
-		}
-		sizes.push({
-			name: "workspace build outputs",
-			category: "workspace-outputs",
-			dir: entry.dir,
-			bytes: entry.bytes,
-			measuredAt: now,
-			...entry.projectRoot ? { workspace: canonicalPath(entry.projectRoot) } : {},
-			idleDays: entry.idleDays,
-			...!entry.willClear ? { blocked: entry.keptReason ?? "workspace ownership is unresolved" } : {}
-		});
-	}
-	const known = [
-		{
-			name: "shared build cache",
-			dir: buildCacheRoot(),
-			category: "build-cache"
-		},
-		{
-			name: "Metro transform caches",
-			dir: metroCacheRoot(),
-			category: "metro-cache"
-		},
-		{
-			name: "ccache",
-			dir: sharedCcache(),
-			category: "ccache"
-		},
-		{
-			name: "Swift compilation cache",
-			dir: sharedCompilationCache(),
-			category: "compilation-cache"
-		}
-	];
-	const discovered = discoverCaches();
-	for (const cache of discovered) {
-		if (cache.source !== "registered" && !canonicalPath(cache.dir).startsWith(`${canonicalPath(configDir())}/`)) continue;
-		if (cache.prune === "report-only") continue;
-		const dir = canonicalPath(cache.dir);
-		if (known.some((item) => dir === canonicalPath(item.dir) || dir.startsWith(`${canonicalPath(item.dir)}/`))) continue;
-		const category = cache.name.startsWith("Metro transform cache") ? "metro-cache" : /^(Expo build cache|native build cache|Build cache)$/.test(cache.name) ? "build-cache" : "other";
-		known.push({
-			name: cache.name,
-			dir: cache.dir,
-			category
-		});
-	}
-	for (const entry of known) {
-		if (!existsSync(entry.dir)) continue;
-		const bytes = await measuredDirectorySizeAsync(entry.dir, { timeoutMs: 12e4 });
-		if (bytes === null) {
-			failure(entry.dir);
-			continue;
-		}
-		const blocked = cacheBlocked(entry, discovered);
-		sizes.push({
-			...entry,
-			bytes,
-			measuredAt: now,
-			...blocked ? { blocked } : {}
-		});
-	}
-	return sizes;
-}
-//#endregion
 //#region src/workspace/pods-relocate.ts
 const CHECKSUMS_HEADER = "SPEC CHECKSUMS:\n";
 const GENERATED_DIRS = [
@@ -828,6 +664,95 @@ async function removeKind(record, kind) {
 function logRemovalOrder(path) {
 	return /\.ndjson\.\d+$/.test(path) ? 0 : /^build-.*\.ndjson$/.test(basename(path)) ? 1 : 2;
 }
+/**
+* How long and how large worktree archives of `root` are kept, from `archive.maxAgeDays` and `archive.maxTotalGb`, or
+* why its uncommitted changes cannot be archived: archives are disabled for it or for a project registered inside it,
+* a limit is 0, or a setting is invalid.
+*/
+function worktreeArchiveLimits(root, env = process.env) {
+	if (!enabled(root, env)) return { refusal: "archive.enabled is false for it" };
+	const nested = Object.keys(loadConfig()?.projects ?? {}).find((key) => key !== root && isPathPrefix(root, key) && !enabled(key, env));
+	if (nested) return { refusal: `archive.enabled is false for ${nested}, inside it` };
+	let limits;
+	try {
+		limits = archiveSettings(env);
+	} catch (error) {
+		return { refusal: (error instanceof Error ? error.message : String(error)).split("\n")[0] ?? "" };
+	}
+	if (!limits.maxAgeDays) return { refusal: "archive.maxAgeDays is 0, so no archive would be kept" };
+	if (!limits.maxTotalGb) return { refusal: "archive.maxTotalGb is 0, so no archive would be kept" };
+	return {
+		maxAgeDays: limits.maxAgeDays,
+		maxBytes: limits.maxTotalGb * 1024 ** 3
+	};
+}
+async function listWorktreeArchives(signal) {
+	const root = worktreeArchiveRoot();
+	let repositories;
+	try {
+		repositories = await readdir(root);
+	} catch {
+		return {
+			repositories: [],
+			entries: []
+		};
+	}
+	const entries = [];
+	for (const repository of repositories) {
+		signal?.throwIfAborted();
+		const dir = join(root, repository);
+		if (!(await lstat(dir)).isDirectory()) continue;
+		for (const name of await readdir(dir)) {
+			if (name.endsWith(".claims")) continue;
+			const path = join(dir, name);
+			const entry = await lstat(path);
+			if (!entry.isDirectory()) continue;
+			const created = Date.parse(String(readJsonObject(join(path, "manifest.json"))?.createdAt ?? ""));
+			const bytes = (await files(path, signal)).reduce((sum, file) => sum + file.bytes, 0);
+			entries.push({
+				path,
+				at: Number.isFinite(created) ? created : entry.mtimeMs,
+				bytes
+			});
+		}
+	}
+	return {
+		repositories,
+		entries
+	};
+}
+/** Bytes every worktree archive holds, the one being written included. */
+async function worktreeArchiveBytes(signal) {
+	return (await listWorktreeArchives(signal)).entries.reduce((sum, entry) => sum + entry.bytes, 0);
+}
+async function pruneWorktreeArchives(now, limits, signal) {
+	const listed = await listWorktreeArchives(signal);
+	const { repositories } = listed;
+	const entries = listed.entries.filter((entry) => {
+		const claims = readClaimSet(`${entry.path}.claims`);
+		return !claims.live.length && !claims.unresolved.length;
+	});
+	entries.sort((a, b) => a.at - b.at);
+	let total = entries.reduce((sum, entry) => sum + entry.bytes, 0);
+	const cap = (limits.maxTotalGb ?? 0) * 1024 ** 3;
+	const maxAgeMs = (limits.maxAgeDays ?? 0) * DAY;
+	for (const entry of entries) {
+		signal?.throwIfAborted();
+		if (now - entry.at < maxAgeMs && total <= cap) continue;
+		if (clearFreeClaimSet({
+			root: `${entry.path}.claims`,
+			label: "worktree archive"
+		}).status !== "cleared") continue;
+		await rm(entry.path, {
+			recursive: true,
+			force: true
+		});
+		total -= entry.bytes;
+	}
+	for (const repository of repositories) try {
+		await rmdir(join(worktreeArchiveRoot(), repository));
+	} catch {}
+}
 async function enforceArchiveRetention(now = Date.now(), operation) {
 	const signal = operation?.signal;
 	const env = operation?.env ?? process.env;
@@ -901,6 +826,7 @@ async function enforceArchiveRetention(now = Date.now(), operation) {
 			record.expires.record = new Date(Date.parse(record.removedAt) + limits.maxAgeDays * DAY).toISOString();
 			if (JSON.stringify(record.expires) !== before) await writeRecord(archiveDir(record.id), record);
 		}
+		await pruneWorktreeArchives(now, limits, signal);
 	}, {
 		waitMs: 3e4,
 		signal
@@ -1456,7 +1382,7 @@ async function reclaimIdleProject(path, workspaceExisted, { archive, deleteOwned
 //#region src/workspace/service-guard.ts
 const SERVICE_IN_USE = { code: "STIM_WORKTREE_SERVICE" };
 function inside(folder, canonical) {
-	return (value) => typeof value === "string" && value.startsWith("/") && isPathPrefix(folder, canonical(value));
+	return (value) => typeof value === "string" && value.startsWith("/") && isPathPrefix$1(folder, canonical(value));
 }
 function serviceUseOf(plist, file, folder, canonical) {
 	if (typeof plist !== "object" || plist === null) return null;
@@ -1535,37 +1461,561 @@ function serviceRunningFrom(folder, canonical, agentsDir = join(homedir(), "Libr
 			argument: null
 		};
 	}
-	for (const name of names) {
-		const file = join(agentsDir, name);
-		const label = name.replace(/\.plist$/, "");
-		try {
-			if (!readFileSync(file).includes("StimService")) continue;
-		} catch {
-			return {
-				label,
-				plist: file,
-				argument: null
-			};
+	for (const name of names) {
+		const file = join(agentsDir, name);
+		const label = name.replace(/\.plist$/, "");
+		try {
+			if (!readFileSync(file).includes("StimService")) continue;
+		} catch {
+			return {
+				label,
+				plist: file,
+				argument: null
+			};
+		}
+		try {
+			const json = getExecutor().runFile("plutil", [
+				"-convert",
+				"json",
+				"-o",
+				"-",
+				file
+			], { timeoutMs: 5e3 });
+			const use = serviceUseOf(JSON.parse(json), file, folder, canonical);
+			if (use) return use;
+		} catch {
+			return {
+				label,
+				plist: file,
+				argument: null
+			};
+		}
+	}
+	return null;
+}
+/** The Stim CLI entry points removal must not delete: the running one and the `stim` on PATH. */
+function stimCliEntries(env) {
+	const entries = [];
+	if (process.argv[1]) entries.push({
+		label: "the running stim",
+		path: process.argv[1]
+	});
+	const onPath = getExecutor().findExecutable("stim", env ? { env } : void 0);
+	if (onPath) entries.push({
+		label: "the stim on PATH",
+		path: onPath
+	});
+	return entries;
+}
+/** Why removing `folder` would delete a Stim CLI in `entries`, resolved through symlinks; empty when it would not. */
+function stimCliUseOf(folder, canonical, entries) {
+	return entries.flatMap(({ label, path }) => {
+		const resolved = canonical(path);
+		return isPathPrefix$1(folder, resolved) ? [`it holds ${label} (${resolved})`] : [];
+	});
+}
+//#endregion
+//#region src/workspace/worktree-archive.ts
+const WATCHMAN_COOKIE = /(?:^|\/)\.watchman-cookie-[^/]*$/;
+const ARCHIVE_TIMEOUT_MS = 6e5;
+function execution(operation) {
+	return {
+		...operation ? childEnvironment(operation.env) : {},
+		signal: operation?.signal,
+		declareFor: operation,
+		killSignal: "SIGKILL"
+	};
+}
+function nulList(text) {
+	return text.split("\0").filter(Boolean);
+}
+async function changesOf(path, operation) {
+	const read = {
+		...execution(operation),
+		untrimmed: true,
+		timeoutMs: 6e4
+	};
+	const tracked = nulList(await gitAsync(path, [
+		"diff",
+		"--name-only",
+		"--no-renames",
+		"-z",
+		"HEAD",
+		"--"
+	], read));
+	const untracked = nulList(await gitAsync(path, [
+		"ls-files",
+		"-z",
+		"--others",
+		"--exclude-standard",
+		"--"
+	], read)).filter((file) => !WATCHMAN_COOKIE.test(file));
+	return {
+		tracked: tracked.toSorted(),
+		untracked: untracked.toSorted()
+	};
+}
+/**
+* Paths whose staged content differs from the working tree. `git diff HEAD` saves only the working tree, so a staged
+* version that the working tree no longer holds would be lost.
+*/
+async function stagedOnly(path, operation) {
+	const read = {
+		...execution(operation),
+		untrimmed: true,
+		timeoutMs: 6e4
+	};
+	const staged = new Set(nulList(await gitAsync(path, [
+		"diff",
+		"--cached",
+		"--name-only",
+		"--no-renames",
+		"-z",
+		"--"
+	], read)));
+	return nulList(await gitAsync(path, [
+		"diff",
+		"--name-only",
+		"--no-renames",
+		"-z",
+		"--"
+	], read)).filter((file) => staged.has(file));
+}
+async function headSizes(path, files, operation) {
+	if (!files.length) return 0;
+	if (files.some((file) => file.includes("\n"))) throw new Error("a changed path contains a newline");
+	return (await gitAsync(path, ["cat-file", "--batch-check=%(objectsize)"], {
+		...execution(operation),
+		timeoutMs: 6e4,
+		input: `${files.map((file) => `HEAD:${file}`).join("\n")}\n`
+	})).split("\n").reduce((sum, line) => sum + (/^\d+$/.test(line.trim()) ? Number(line.trim()) : 0), 0);
+}
+async function changedAt(file, deleted) {
+	for (let current = file;; current = dirname(current)) try {
+		const { mtimeMs, ctimeMs } = await lstat(current);
+		return Math.max(mtimeMs, ctimeMs);
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+		if (deleted === "skip" || dirname(current) === current) return null;
+	}
+}
+/** With `parent`, a deleted file counts its nearest existing parent directory's change, since unlinking changes it. */
+async function newestChange(path, changes, deleted = "skip") {
+	let newest = null;
+	for (const file of [...changes.tracked, ...changes.untracked]) {
+		const changed = await changedAt(join(path, file), deleted);
+		if (changed !== null && (newest === null || changed > newest)) newest = changed;
+	}
+	return newest;
+}
+/**
+* Plans a bundle of HEAD's commits that the default branch lacks, all of HEAD's history without `origin/HEAD`, so the
+* restore can recreate HEAD after its branch is deleted and git collects the commits; null when the default branch
+* already contains HEAD. `bytes` is their size on disk.
+*/
+async function headBundlePlan(path, head, operation) {
+	const run = {
+		...execution(operation),
+		timeoutMs: ARCHIVE_TIMEOUT_MS
+	};
+	const base = (await gitQuietAsync(path, [
+		"symbolic-ref",
+		"--quiet",
+		"refs/remotes/origin/HEAD"
+	], run))?.trim();
+	if (base && await gitQuietAsync(path, [
+		"merge-base",
+		"--is-ancestor",
+		head,
+		base
+	], run) !== null) return null;
+	const exclude = base ? [`^${base}`] : [];
+	const bytes = Number(await gitAsync(path, [
+		"rev-list",
+		"--disk-usage",
+		"--objects",
+		"HEAD",
+		...exclude
+	], run));
+	if (!Number.isFinite(bytes)) throw new Error("git did not report the size of the commits to bundle");
+	return {
+		exclude,
+		bytes
+	};
+}
+async function bundleHead(path, plan, dir, operation) {
+	const run = {
+		...execution(operation),
+		timeoutMs: ARCHIVE_TIMEOUT_MS
+	};
+	const bundle = join(dir, "head.bundle");
+	await gitAsync(path, [
+		"bundle",
+		"create",
+		bundle,
+		"HEAD",
+		...plan.exclude
+	], run);
+	await chmod(bundle, 384);
+	await gitAsync(path, [
+		"bundle",
+		"verify",
+		bundle
+	], run);
+	return bundle;
+}
+/**
+* When a worktree's uncommitted or untracked, non-ignored files last changed, a deleted file by its nearest existing
+* parent directory: null when it has none, and `unreadable` when git or the files cannot be read. git records no time
+* for these edits, so the idle checks read the files themselves.
+*/
+async function uncommittedActivityOf(path, operation) {
+	try {
+		const at = await newestChange(path, await changesOf(path, operation), "parent");
+		return at === null ? null : {
+			at,
+			basis: "an uncommitted file change"
+		};
+	} catch (error) {
+		operation?.signal.throwIfAborted();
+		if (error instanceof Error && "reportCleanup" in error) throw error;
+		return "unreadable";
+	}
+}
+function sameList(a, b) {
+	return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function safeName(value) {
+	return value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[.-]+/, "") || "worktree";
+}
+function stamp(at) {
+	return new Date(at).toISOString().replace(/[-:]/g, "").replace(".", "-");
+}
+/**
+* Why the archive no longer describes the worktree, or null when it still does: the same changed and untracked files,
+* none modified since the archive started, and the patch still reverses cleanly against the working tree.
+*/
+async function worktreeArchiveMismatch(path, archive, operation) {
+	if (archive.tracked.length) try {
+		await gitAsync(path, [
+			"apply",
+			"--check",
+			"-R",
+			join(archive.dir, "tracked.patch")
+		], {
+			...execution(operation),
+			timeoutMs: ARCHIVE_TIMEOUT_MS
+		});
+	} catch (error) {
+		if (error instanceof Error && "reportCleanup" in error) throw error;
+		operation?.signal.throwIfAborted();
+		return `the archived patch does not reverse against the worktree: ${(error instanceof Error ? error.message : String(error)).split("\n")[0]}`;
+	}
+	const staged = await stagedOnly(path, operation);
+	if (staged.length) return `the staged content of ${staged.join(", ")} differs from its working tree`;
+	const now = await changesOf(path, operation);
+	if (!sameList(now.tracked, archive.tracked) || !sameList(now.untracked, archive.untracked)) return "its uncommitted or untracked files changed while they were archived";
+	const newest = await newestChange(path, now);
+	if (newest !== null && newest >= archive.at) return "an uncommitted file changed while it was archived";
+	for (const file of [
+		...archive.bundled ? ["head.bundle"] : [],
+		...archive.tracked.length ? ["tracked.patch"] : [],
+		...archive.untracked.length ? ["untracked.tar"] : []
+	]) if (!await lstat(join(archive.dir, file)).catch(() => null)) return `its archive lost ${file}`;
+	return null;
+}
+/**
+* Saves a worktree's uncommitted work under `$STIM_HOME/archive/worktrees/<repository>/<branch-or-dir>-<timestamp>/`:
+* `tracked.patch` (`git diff --binary HEAD`, staged and unstaged changes together), `untracked.tar` (untracked files
+* git does not ignore) and `manifest.json` naming the branch, HEAD, pull request, files and restore commands. Ignored
+* files are not saved. Throws, leaving no archive, when archives are disabled or limited to 0, the files exceed
+* `archive.maxTotalGb` or the disk floor, an untracked nested repository is present, a staged version differs from
+* the working tree, or the written archive does not verify.
+*/
+async function archiveWorktreeChanges({ path, repository, branch, head, pullRequest, operation }) {
+	const limits = worktreeArchiveLimits(path, operation?.env);
+	if ("refusal" in limits) throw new Error(limits.refusal);
+	const at = Date.now();
+	const changes = await changesOf(path, operation);
+	const nested = changes.untracked.find((file) => file.endsWith("/"));
+	if (nested) throw new Error(`${nested} is an untracked nested repository`);
+	const staged = await stagedOnly(path, operation);
+	if (staged.length) throw new Error(`the staged content of ${staged.join(", ")} differs from its working tree`);
+	if (!changes.tracked.length && !changes.untracked.length) throw new Error("git reported no change it could save");
+	const retention = async () => {
+		try {
+			await enforceArchiveRetention(void 0, operation);
+		} catch (error) {
+			if (error instanceof Error && "reportCleanup" in error) throw error;
+			operation?.signal.throwIfAborted();
+		}
+	};
+	await retention();
+	const existing = await worktreeArchiveBytes(operation?.signal);
+	let bytes = 0;
+	for (const file of changes.untracked) bytes += (await lstat(join(path, file))).size;
+	let tracked = await headSizes(path, changes.tracked, operation);
+	for (const file of changes.tracked) tracked += (await lstat(join(path, file)).catch(() => null))?.size ?? 0;
+	const plan = await headBundlePlan(path, head, operation);
+	if (existing + bytes + (plan?.bytes ?? 0) > limits.maxBytes) throw new Error(`its untracked files and unmerged commits (${bytes + (plan?.bytes ?? 0)} bytes) do not fit in archive.maxTotalGb beside the other archives`);
+	const [volume] = await readVolumeSpaceAsync([worktreeArchiveRoot()], operation?.signal);
+	const floorMb = resolveBudget({ env: operation?.env }).budget.hardFloorDiskMb;
+	const neededMb = (bytes + 2 * tracked + 2 * (plan?.bytes ?? 0)) / 1024 ** 2;
+	if (!volume || volume.freeMb - neededMb < floorMb) throw new Error(volume ? `writing it would leave less free disk than budget.hardFloorDiskGb on ${volume.volume}` : "free disk for it could not be read");
+	const dir = join(worktreeArchiveRoot(), safeName(basename(repository)), `${safeName(branch?.replace(/^refs\/heads\//, "") ?? basename(path))}-${stamp(at)}-${randomUUID().slice(0, 8)}`);
+	await mkdir(dirname(dir), {
+		recursive: true,
+		mode: 448
+	});
+	const attempt = tryAcquireClaim({
+		root: `${dir}.claims`,
+		mode: "exclusive",
+		label: "worktree archive"
+	});
+	const claim = attempt.acquired;
+	if (!claim) {
+		releaseClaim(attempt.pending);
+		throw new Error("its archive claim is held");
+	}
+	let created = false;
+	const restore = [`git -C ${quotedPath(repository)} worktree add --detach ${quotedPath(path)} ${head}`];
+	try {
+		await mkdir(dir, { mode: 448 });
+		created = true;
+		const bundle = plan ? await bundleHead(path, plan, dir, operation) : null;
+		if (bundle) restore.unshift(`git -C ${quotedPath(repository)} bundle unbundle ${quotedPath(bundle)}`);
+		if (changes.tracked.length) {
+			const patch = join(dir, "tracked.patch");
+			await gitAsync(path, [
+				"diff",
+				"--binary",
+				"--no-color",
+				"--no-ext-diff",
+				"--no-textconv",
+				"--no-relative",
+				"--src-prefix=a/",
+				"--dst-prefix=b/",
+				`--output=${patch}`,
+				"HEAD",
+				"--"
+			], {
+				...execution(operation),
+				timeoutMs: ARCHIVE_TIMEOUT_MS
+			});
+			await chmod(patch, 384);
+			restore.push(`git -C ${quotedPath(path)} apply ${quotedPath(patch)}`);
+		}
+		if (changes.untracked.length) {
+			const tarball = join(dir, "untracked.tar");
+			const exec = {
+				...execution(operation),
+				cwd: path,
+				timeoutMs: ARCHIVE_TIMEOUT_MS
+			};
+			await getExecutor().runFileAsync("tar", [
+				"-cf",
+				tarball,
+				"--null",
+				"-T",
+				"-"
+			], {
+				...exec,
+				input: `${changes.untracked.join("\0")}\0`
+			});
+			await chmod(tarball, 384);
+			if (!sameList((await getExecutor().runFileAsync("tar", ["-tf", tarball], {
+				...exec,
+				untrimmed: true
+			})).split(/\r?\n/).filter(Boolean).toSorted(), changes.untracked)) throw new Error("the untracked tarball does not list every file");
+			restore.push(`tar -xf ${quotedPath(tarball)} -C ${quotedPath(path)}`);
+		}
+		const archive = {
+			dir,
+			at,
+			...changes,
+			restore,
+			bundled: bundle !== null,
+			claim
+		};
+		const mismatch = await worktreeArchiveMismatch(path, archive, operation);
+		if (mismatch) throw new Error(mismatch);
+		const manifest = {
+			version: 1,
+			createdAt: new Date(at).toISOString(),
+			worktree: path,
+			repository,
+			branch,
+			head,
+			pullRequest,
+			headBundle: bundle ? "head.bundle" : null,
+			trackedPatch: changes.tracked.length ? "tracked.patch" : null,
+			untrackedTarball: changes.untracked.length ? "untracked.tar" : null,
+			tracked: changes.tracked,
+			untracked: changes.untracked,
+			restore
+		};
+		const tmp = join(dir, ".manifest.json.tmp");
+		await writeFile(tmp, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 384 });
+		await rename(tmp, join(dir, "manifest.json"));
+		const total = await worktreeArchiveBytes(operation?.signal);
+		if (total > limits.maxBytes) throw new Error(`the archive (${total - existing} bytes) does not fit in archive.maxTotalGb beside the other archives`);
+		const [after] = await readVolumeSpaceAsync([dir], operation?.signal);
+		if (!after || after.freeMb < floorMb) throw new Error(`it left less free disk than budget.hardFloorDiskGb on ${after?.volume ?? "its volume"}`);
+		await retention();
+		if (!await lstat(join(dir, "manifest.json")).catch(() => null)) throw new Error("archive retention removed it");
+		return archive;
+	} catch (error) {
+		try {
+			if (created) await rm(dir, {
+				recursive: true,
+				force: true
+			});
+		} finally {
+			releaseClaim(claim);
+		}
+		throw error;
+	}
+}
+/** Deletes an archive whose worktree was kept intact, so a retried removal does not pile up copies. */
+async function discardWorktreeArchive(archive) {
+	await rm(archive.dir, {
+		recursive: true,
+		force: true
+	});
+	releaseWorktreeArchive(archive);
+}
+/** Lets retention manage the archive once the removal that needed it has ended. */
+function releaseWorktreeArchive(archive) {
+	releaseClaim(archive.claim);
+}
+//#endregion
+//#region src/maintenance/measure.ts
+function measureDisk() {
+	return readVolumeSpace([
+		configDir(),
+		...Object.keys(loadConfig()?.projects ?? {}),
+		buildWorkerRoot(loadConfig())
+	]);
+}
+function measureDiskAsync(operation) {
+	return readVolumeSpaceAsync([
+		configDir(),
+		...Object.keys(loadConfig()?.projects ?? {}),
+		buildWorkerRoot(loadConfig())
+	], operation.signal);
+}
+/** The disk pressure level of the fullest volume Stim writes to, measured now. */
+function currentDiskLevel(disk = measureDisk()) {
+	return diskPressureLevel(lowestFree(disk), resolveBudget().budget, resolveMaintenanceSettings());
+}
+function measurePressure(settings, previous, now) {
+	return pressureFromObservations(settings, previous, now, readHostMemoryPressure(), measureDisk());
+}
+async function measurePressureAsync(settings, previous, now, operation) {
+	return pressureFromObservations(settings, previous, now, await readHostMemoryPressureAsync(void 0, void 0, operation.signal, operation), await readVolumeSpaceAsync([
+		configDir(),
+		...Object.keys(loadConfig()?.projects ?? {}),
+		buildWorkerRoot(loadConfig())
+	], operation.signal));
+}
+function pressureFromObservations(settings, previous, now, level, disk) {
+	const availableBytes = process.platform === "darwin" ? null : freemem();
+	const warningSince = level === "warning" ? previous?.warningSince ?? now : null;
+	return {
+		disk,
+		memory: {
+			level,
+			availableBytes,
+			pressured: settings.memoryPressureLevel !== "off" && (level === "critical" || settings.memoryPressureLevel === "warning" && warningSince !== null && now - warningSince >= settings.memoryWarningMinutes * 6e4 || availableBytes !== null && availableBytes < (settings.minAvailableMemoryGb === void 0 ? totalmem() * .1 : settings.minAvailableMemoryGb * 1024 ** 3))
+		},
+		warningSince
+	};
+}
+function sizeScanDeferred(settings) {
+	return loadavg()[0] / Math.max(1, cpus().length) > settings.maxLoadPerCore;
+}
+function cacheBlocked(entry, discovered = discoverCaches(), env = process.env) {
+	return planCacheEmptying([{
+		...entry,
+		note: "",
+		prune: "entries",
+		...discovered.some((cache) => canonicalPath(cache.dir) === canonicalPath(entry.dir) && cache.source === "registered") ? { source: "registered" } : {}
+	}], false, env)[0]?.machineGlobal ?? (entry.category === "compilation-cache" ? cacheUser(entry.dir) : void 0);
+}
+async function measureSizes(now, failure) {
+	const sizes = [];
+	const outputs = await collectWorkspaceOutputs({
+		olderThan: null,
+		now,
+		sizeTimeoutMs: 12e4
+	});
+	for (const entry of outputs.workspaces) {
+		if (entry.bytes === null) {
+			failure(entry.dir, entry.projectRoot ?? void 0);
+			continue;
+		}
+		sizes.push({
+			name: "workspace build outputs",
+			category: "workspace-outputs",
+			dir: entry.dir,
+			bytes: entry.bytes,
+			measuredAt: now,
+			...entry.projectRoot ? { workspace: canonicalPath(entry.projectRoot) } : {},
+			idleDays: entry.idleDays,
+			...!entry.willClear ? { blocked: entry.keptReason ?? "workspace ownership is unresolved" } : {}
+		});
+	}
+	const known = [
+		{
+			name: "shared build cache",
+			dir: buildCacheRoot(),
+			category: "build-cache"
+		},
+		{
+			name: "Metro transform caches",
+			dir: metroCacheRoot(),
+			category: "metro-cache"
+		},
+		{
+			name: "ccache",
+			dir: sharedCcache(),
+			category: "ccache"
+		},
+		{
+			name: "Swift compilation cache",
+			dir: sharedCompilationCache(),
+			category: "compilation-cache"
 		}
-		try {
-			const json = getExecutor().runFile("plutil", [
-				"-convert",
-				"json",
-				"-o",
-				"-",
-				file
-			], { timeoutMs: 5e3 });
-			const use = serviceUseOf(JSON.parse(json), file, folder, canonical);
-			if (use) return use;
-		} catch {
-			return {
-				label,
-				plist: file,
-				argument: null
-			};
+	];
+	const discovered = discoverCaches();
+	for (const cache of discovered) {
+		if (cache.source !== "registered" && !canonicalPath(cache.dir).startsWith(`${canonicalPath(configDir())}/`)) continue;
+		if (cache.prune === "report-only") continue;
+		const dir = canonicalPath(cache.dir);
+		if (known.some((item) => dir === canonicalPath(item.dir) || dir.startsWith(`${canonicalPath(item.dir)}/`))) continue;
+		const category = cache.name.startsWith("Metro transform cache") ? "metro-cache" : /^(Expo build cache|native build cache|Build cache)$/.test(cache.name) ? "build-cache" : "other";
+		known.push({
+			name: cache.name,
+			dir: cache.dir,
+			category
+		});
+	}
+	for (const entry of known) {
+		if (!existsSync(entry.dir)) continue;
+		const bytes = await measuredDirectorySizeAsync(entry.dir, { timeoutMs: 12e4 });
+		if (bytes === null) {
+			failure(entry.dir);
+			continue;
 		}
+		const blocked = cacheBlocked(entry, discovered);
+		sizes.push({
+			...entry,
+			bytes,
+			measuredAt: now,
+			...blocked ? { blocked } : {}
+		});
 	}
-	return null;
+	return sizes;
 }
 //#endregion
 //#region src/engine/warm-claim.ts
@@ -1825,9 +2275,11 @@ function checkoutFactLine(branch, plan, head) {
 /**
 * Whether to install, decided against the lockfile as it stands now rather than against what HEAD did.
 * A lockfile that did not move is not evidence that its dependencies are installed: an install that was
-* interrupted leaves a present node_modules behind and moves HEAD no further.
+* interrupted leaves a present node_modules behind and moves HEAD no further. A `patches/` change counts
+* as a dependency change because patch-package applies it only on a fresh install. A tree `npm ls` already
+* rejected right after the last completed install, with the same problems, is not one another install would fix.
 */
-function depsPlan({ lockfile, lockfileChanged, installed, treeValid, lastInstall, lockHash }) {
+function depsPlan({ lockfile, lockfileChanged, patchesChanged, installed, treeProblems, lastInstall, lockHash, patchesHash }) {
 	if (!lockfile) return {
 		run: false,
 		reason: "no lockfile in this repository"
@@ -1836,7 +2288,7 @@ function depsPlan({ lockfile, lockfileChanged, installed, treeValid, lastInstall
 		run: true,
 		reason: "no installed dependencies"
 	};
-	if (treeValid === false) return {
+	if (treeProblems && lastInstall?.treeProblems !== treeProblems) return {
 		run: true,
 		reason: `the installed tree does not match ${lockfile}`
 	};
@@ -1853,6 +2305,10 @@ function depsPlan({ lockfile, lockfileChanged, installed, treeValid, lastInstall
 			run: true,
 			reason: `${lockfile} does not match the last completed install`
 		};
+		if (lastInstall.patches !== patchesHash) return {
+			run: true,
+			reason: "patches/ does not match the last completed install"
+		};
 		return {
 			run: false,
 			reason: `${lockfile} matches the last completed install`
@@ -1862,6 +2318,10 @@ function depsPlan({ lockfile, lockfileChanged, installed, treeValid, lastInstall
 		run: true,
 		reason: `${lockfile} changed`
 	};
+	if (patchesChanged) return {
+		run: true,
+		reason: "patches/ changed"
+	};
 	return {
 		run: false,
 		reason: `${lockfile} unchanged`
@@ -1873,18 +2333,51 @@ function depsPlan({ lockfile, lockfileChanged, installed, treeValid, lastInstall
 * nothing about this one, and no record at all is the state of every repository before its first refresh.
 */
 function incompleteInstallRefusal(root, appDir) {
-	const dependencies = dependencyState(existsSync(appDir) ? appDir : root);
-	if (!dependencies) return null;
-	const last = readInstallEvidence(dependencies.root);
-	if (!last || last.completed || last.lock !== dependencies.lock) return null;
-	const hash = lockfileHash(dependencies.root, dependencies.lock);
-	if (hash === null || last.hash !== hash) return null;
-	return {
-		code: "STIM_DEPS_INCOMPLETE",
-		message: `Refusing to copy from ${dependencies.root}: the last install of ${dependencies.lock} there did not finish, so its dependencies are partial.`,
-		lines: [],
-		remedy: `Run \`stim worktree warm --refresh\` to install them in the source checkout -- it reinstalls rather than skipping, because no completed install of this ${dependencies.lock} is recorded -- then warm again.`
-	};
+	for (const dependencies of dependencyStates(root, appDir)) {
+		const last = readInstallEvidence(dependencies.root);
+		if (!last || last.completed || last.lock !== dependencies.lock) continue;
+		const hash = lockfileHash(dependencies.root, dependencies.lock);
+		if (hash === null || last.hash !== hash) continue;
+		return {
+			code: "STIM_DEPS_INCOMPLETE",
+			message: `Refusing to copy from ${dependencies.root}: the last install of ${dependencies.lock} there did not finish, so its dependencies are partial.`,
+			lines: [],
+			remedy: `Run \`stim worktree warm --refresh\` to install them in the source checkout -- it reinstalls rather than skipping, because no completed install of this ${dependencies.lock} is recorded -- then warm again.`
+		};
+	}
+	return null;
+}
+function dependencyStates(root, appDir) {
+	const app = dependencyState(existsSync(appDir) ? appDir : root);
+	const top = dependencyState(root, root);
+	return [app, top && top.root !== app?.root && (hasInstalledDependencies(top.root, top.installed) || readInstallEvidence(top.root)) ? top : null].filter((state) => state !== null);
+}
+/**
+* An npm project whose own `.npmrc` sets `ignore-scripts` gets no lifecycle scripts from `npm ci`, its own
+* postinstall included. `npm run` still runs a named script under that setting, so the project's postinstall
+* (usually patch-package) runs explicitly; dependencies' install scripts stay blocked.
+*/
+function skippedPostinstall(dependencies) {
+	if (dependencies.lock !== "package-lock.json") return false;
+	let postinstall;
+	try {
+		postinstall = JSON.parse(readFileSync(join(dependencies.root, "package.json"), "utf-8"))?.scripts?.postinstall;
+	} catch {
+		return false;
+	}
+	if (typeof postinstall !== "string" || !postinstall.trim()) return false;
+	try {
+		return getExecutor().runFile("npm", [
+			"config",
+			"get",
+			"ignore-scripts"
+		], {
+			cwd: dependencies.root,
+			timeoutMs: 3e4
+		}) === "true";
+	} catch {
+		return false;
+	}
 }
 function podsPlan({ hasIos, hasPodfile, podfileLockChanged, stale, dir = "ios/" }) {
 	if (!hasIos) return {
@@ -1936,6 +2429,22 @@ function lockfileHash(depsRoot, lockfile) {
 		return null;
 	}
 }
+function hashPatches(depsRoot) {
+	const dir = join(depsRoot, "patches");
+	let names;
+	try {
+		names = readdirSync(dir, {
+			recursive: true,
+			withFileTypes: true
+		}).filter((entry) => entry.isFile() && entry.name.endsWith(".patch")).map((entry) => relative(dir, join(entry.parentPath, entry.name))).toSorted();
+	} catch {
+		return "";
+	}
+	if (!names.length) return "";
+	const hash = createHash("sha256");
+	for (const name of names) hash.update(name).update("\0").update(readFileSync(join(dir, name))).update("\0");
+	return hash.digest("hex");
+}
 function readInstallEvidence(depsRoot) {
 	try {
 		const parsed = JSON.parse(readFileSync(installRecordFile(depsRoot), "utf-8"));
@@ -1944,21 +2453,19 @@ function readInstallEvidence(depsRoot) {
 		return {
 			lock: parsed.lock,
 			hash: parsed.hash,
-			completed: parsed.completed === true
+			patches: typeof parsed.patches === "string" ? parsed.patches : "",
+			completed: parsed.completed === true,
+			treeProblems: typeof parsed.treeProblems === "string" ? parsed.treeProblems : null
 		};
 	} catch {
 		return null;
 	}
 }
-function writeInstallEvidence(depsRoot, lockfile, hash, completed) {
+function writeInstallEvidence(depsRoot, evidence) {
 	const file = installRecordFile(depsRoot);
 	const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
 	mkdirSync(join(getConfigDir(), "warm-installs"), { recursive: true });
-	writeFileSync(tmp, JSON.stringify({
-		lock: lockfile,
-		hash: hash ?? "",
-		completed
-	}));
+	writeFileSync(tmp, JSON.stringify(evidence));
 	try {
 		renameSync(tmp, file);
 	} catch (error) {
@@ -1966,8 +2473,17 @@ function writeInstallEvidence(depsRoot, lockfile, hash, completed) {
 		throw error;
 	}
 }
+function pendingInstallEvidence(dependencies) {
+	return {
+		lock: dependencies.lock,
+		hash: lockfileHash(dependencies.root, dependencies.lock) ?? "",
+		patches: dependencies.lock === "package-lock.json" ? hashPatches(dependencies.root) : "",
+		completed: false,
+		treeProblems: null
+	};
+}
 function restoreInstallEvidence(depsRoot, prior) {
-	if (prior) writeInstallEvidence(depsRoot, prior.lock, prior.hash, prior.completed);
+	if (prior) writeInstallEvidence(depsRoot, prior);
 	else rmSync(installRecordFile(depsRoot), { force: true });
 }
 function inProgressOperation(gitDir) {
@@ -2181,10 +2697,13 @@ async function refreshMainCheckout({ root, appDir, settings, iosProject, emit, s
 	const plan = checkoutPlan(locallyKnownUpstream(root));
 	if (plan.kind === "diverged") return divergedRefusal(root, branch, plan);
 	if (inspectOnly && plan.kind === "fast-forward") return { mutation: `fast-forward ${plan.behind} commit${plan.behind === 1 ? "" : "s"}` };
-	const depsBefore = dependencyState(existsSync(appDir) ? appDir : root);
-	const priorInstall = depsBefore ? readInstallEvidence(depsBefore.root) : null;
-	const marked = plan.kind === "fast-forward" ? depsBefore : null;
-	if (marked) writeInstallEvidence(marked.root, marked.lock, lockfileHash(marked.root, marked.lock), false);
+	const depsBefore = dependencyStates(root, appDir);
+	const priorInstalls = new Map(depsBefore.map((entry) => [entry.root, readInstallEvidence(entry.root)]));
+	const marked = plan.kind === "fast-forward" ? depsBefore : [];
+	for (const entry of marked) writeInstallEvidence(entry.root, pendingInstallEvidence(entry));
+	const restoreMarked = (depsRoot) => {
+		if (marked.some((entry) => entry.root === depsRoot)) restoreInstallEvidence(depsRoot, priorInstalls.get(depsRoot) ?? null);
+	};
 	let head = before;
 	if (plan.kind === "fast-forward") {
 		const merged = fastForward(root, plan.upstream);
@@ -2199,43 +2718,71 @@ async function refreshMainCheckout({ root, appDir, settings, iosProject, emit, s
 	emit(checkoutFactLine(branch, plan, head));
 	const note = defaultBranchNote(branch, resolveDefaultBranch(root, settings));
 	if (note.kind !== "match") for (const line of note.lines) emit(phaseLine("", line));
-	const dependencies = dependencyState(existsSync(appDir) ? appDir : root);
-	const installed = dependencies ? hasInstalledDependencies(dependencies.root, dependencies.installed) : false;
-	const consumed = dependencies ? lockfileHash(dependencies.root, dependencies.lock) : null;
-	const deps = depsPlan({
-		lockfile: dependencies?.lock ?? null,
-		lockfileChanged: dependencies ? pathChangedBetween(root, before, head, gitPath(relative(root, dependencies.root), dependencies.lock)) : false,
-		installed,
-		treeValid: dependencies?.lock === "package-lock.json" && installed ? installedNpmTreeIsValid(dependencies.root) : null,
-		lastInstall: priorInstall,
-		lockHash: consumed
-	});
-	const depsSubject = `source ${dependencies?.root ?? root}: ${deps.reason}`;
-	if (deps.run && dependencies) {
-		if (inspectOnly) return { mutation: deps.reason };
-		writeInstallEvidence(dependencies.root, dependencies.lock, consumed, false);
-		const install = await runInstallCommand({
-			command: dependencies.command,
-			cwd: dependencies.root,
-			spawnFn: spawn,
-			now,
-			heartbeatMs,
-			onHeartbeat: emit
+	const dependencyRoots = dependencyStates(root, appDir);
+	for (const entry of marked) if (!dependencyRoots.some((other) => other.root === entry.root)) restoreMarked(entry.root);
+	if (!dependencyRoots.length) emit(stepLine("deps", `source ${root}: no lockfile in this repository`, "skipped"));
+	const owed = [];
+	for (const dependencies of dependencyRoots) {
+		const installed = hasInstalledDependencies(dependencies.root, dependencies.installed);
+		const depsDir = relative(root, dependencies.root);
+		const consumed = pendingInstallEvidence(dependencies);
+		const deps = depsPlan({
+			lockfile: dependencies.lock,
+			lockfileChanged: pathChangedBetween(root, before, head, gitPath(depsDir, dependencies.lock)),
+			patchesChanged: dependencies.lock === "package-lock.json" && pathChangedBetween(root, before, head, gitPath(depsDir, "patches/*.patch")),
+			installed,
+			treeProblems: dependencies.lock === "package-lock.json" && installed ? installedNpmTreeProblems(dependencies.root) : null,
+			lastInstall: priorInstalls.has(dependencies.root) ? priorInstalls.get(dependencies.root) ?? null : readInstallEvidence(dependencies.root),
+			lockHash: consumed.hash || null,
+			patchesHash: consumed.patches
 		});
-		emit(stepLine("deps", depsSubject, `${dependencies.command} (${formatDuration(install.durationMs)})`));
-		const running = await awaitSpawnedWork(`\`${dependencies.command}\``);
-		if (!install.ok) return {
-			code: DEPS_ERROR,
-			message: String(install.reason),
-			lines: install.lastLines,
-			remedy: `Run \`cd ${dependencies.root} && ${dependencies.command}\` and fix what it reports, then run warm again.`
-		};
-		if (running) return running;
-		writeInstallEvidence(dependencies.root, dependencies.lock, consumed, true);
-	} else {
-		if (marked) restoreInstallEvidence(marked.root, priorInstall);
+		const depsSubject = `source ${dependencies.root}: ${deps.reason}`;
+		if (deps.run) {
+			if (inspectOnly) return { mutation: deps.reason };
+			owed.push({
+				dependencies,
+				subject: depsSubject
+			});
+			continue;
+		}
+		restoreMarked(dependencies.root);
 		emit(stepLine("deps", depsSubject, "skipped"));
 	}
+	for (const { dependencies, subject: depsSubject } of owed) {
+		const consumed = pendingInstallEvidence(dependencies);
+		writeInstallEvidence(dependencies.root, consumed);
+		const runStep = async (command, subject, remedy) => {
+			const install = await runInstallCommand({
+				command,
+				cwd: dependencies.root,
+				spawnFn: spawn,
+				now,
+				heartbeatMs,
+				onHeartbeat: emit
+			});
+			emit(stepLine("deps", subject, `${command} (${formatDuration(install.durationMs)})`));
+			const running = await awaitSpawnedWork(`\`${command}\``);
+			if (!install.ok) return {
+				code: DEPS_ERROR,
+				message: String(install.reason),
+				lines: install.lastLines,
+				remedy: `Run \`cd ${dependencies.root} && ${remedy}\` and fix what it reports, then run warm again.`
+			};
+			return running;
+		};
+		const postinstall = skippedPostinstall(dependencies) ? "npm run postinstall" : null;
+		const installFailure = await runStep(dependencies.command, depsSubject, postinstall ? `${dependencies.command} && ${postinstall}` : dependencies.command);
+		if (installFailure) return installFailure;
+		if (postinstall) {
+			const postinstallFailure = await runStep(postinstall, `source ${dependencies.root}: ignore-scripts skipped postinstall`, postinstall);
+			if (postinstallFailure) return postinstallFailure;
+		}
+		writeInstallEvidence(dependencies.root, {
+			...consumed,
+			completed: true,
+			treeProblems: dependencies.lock === "package-lock.json" ? installedNpmTreeProblems(dependencies.root) : null
+		});
+	}
 	const app = relative(root, appDir) || ".";
 	const where = `source ${appDir}: `;
 	const ios = iosProject;
@@ -2272,210 +2819,6 @@ async function refreshMainCheckout({ root, appDir, settings, iosProject, emit, s
 	return podsRunning;
 }
 //#endregion
-//#region src/workspace/worktree-trash.ts
-const TRASH_MANIFEST = "trash.json";
-const TRASH_ENTRY_PREFIX = "remove-";
-const TRASH_ENTRIES = "entries";
-const TRASH_CLAIMS = "claims";
-const LIST_TIMEOUT_MS = 3e4;
-const DELETE_NICENESS = "10";
-function rethrowCancellation(error, signal) {
-	if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
-	signal?.throwIfAborted();
-}
-async function isPlainDirectory(path) {
-	const stat = await lstat(path).catch(() => null);
-	return Boolean(stat?.isDirectory());
-}
-async function ignoredDirectories(worktree, options) {
-	const out = await gitAsync(worktree, [
-		"ls-files",
-		"--others",
-		"--ignored",
-		"--exclude-standard",
-		"--directory",
-		"--no-empty-directory",
-		"-z"
-	], {
-		...options.env ? childEnvironment(options.env) : {},
-		signal: options.signal,
-		declareFor: options.declareFor,
-		timeoutMs: LIST_TIMEOUT_MS,
-		untrimmed: true
-	});
-	const found = [];
-	for (const entry of out.split("\0")) {
-		if (!entry.endsWith("/")) continue;
-		const rel = entry.slice(0, -1);
-		const parts = rel.split("/");
-		let plain = true;
-		for (let depth = 1; depth <= parts.length && plain; depth++) plain = await isPlainDirectory(join(worktree, ...parts.slice(0, depth)));
-		if (plain) found.push(rel);
-	}
-	return found;
-}
-/**
-* Moves the worktree's ignored directories, which `git worktree remove` would delete, into a new entry under
-* `$STIM_HOME/trash` held by an exclusive ownership claim. Null, with nothing moved, when the trash is on another
-* filesystem, the platform is Windows, git cannot list the entries, or the claim cannot be taken. A directory that
-* does not rename stays in the worktree for git to delete.
-*/
-async function moveIgnoredTreesToTrash(worktree, options = {}) {
-	if ((options.platform ?? process.platform) === "win32") return null;
-	let listed;
-	try {
-		listed = await ignoredDirectories(worktree, options);
-	} catch (error) {
-		rethrowCancellation(error, options.signal);
-		return null;
-	}
-	if (!listed.length) return null;
-	const root = trashRoot();
-	let dir = null;
-	let claim = null;
-	const entries = listed.map((from, index) => ({
-		from,
-		to: String(index)
-	}));
-	try {
-		await mkdir(root, { recursive: true });
-		if (filesystemDevice(root) !== filesystemDevice(worktree)) return null;
-		dir = await mkdtemp(join(root, TRASH_ENTRY_PREFIX));
-		claim = (0, ownership_claim_exports.tryAcquireClaim)({
-			root: join(dir, "claims"),
-			mode: "exclusive",
-			label: "worktree trash"
-		}).acquired ?? null;
-		if (!claim) throw new Error("the trash entry claim was not acquired");
-		const manifest = {
-			worktree,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		await writeFile(join(dir, TRASH_MANIFEST), `${JSON.stringify(manifest)}\n`);
-		await mkdir(join(dir, TRASH_ENTRIES));
-	} catch (error) {
-		if (claim) (0, ownership_claim_exports.releaseClaim)(claim);
-		if (dir) await rm(dir, {
-			recursive: true,
-			force: true
-		}).catch(() => {});
-		rethrowCancellation(error, options.signal);
-		return null;
-	}
-	const moved = [];
-	for (const entry of entries) try {
-		await rename(join(worktree, entry.from), join(dir, TRASH_ENTRIES, entry.to));
-		moved.push(entry);
-	} catch {}
-	const trash = {
-		dir,
-		worktree,
-		moved,
-		claim
-	};
-	if (moved.length) return trash;
-	await discardTrash(trash);
-	return null;
-}
-async function discardTrash(trash) {
-	await rmdir(join(trash.dir, TRASH_ENTRIES)).catch(() => {});
-	await rm(join(trash.dir, TRASH_MANIFEST), { force: true }).catch(() => {});
-	(0, ownership_claim_exports.releaseClaim)(trash.claim);
-	await rmdir(trash.dir).catch(() => {});
-}
-/** Moves every tree back into the worktree. Returns the relative paths that stay in the trash for gc. */
-async function restoreTrashedTrees(trash) {
-	const kept = [];
-	for (const entry of trash.moved.toReversed()) {
-		const target = join(trash.worktree, entry.from);
-		try {
-			if (await lstat(target).catch(() => null) || !await isPlainDirectory(dirname(target))) {
-				kept.push(entry.from);
-				continue;
-			}
-			await rename(join(trash.dir, TRASH_ENTRIES, entry.to), target);
-		} catch {
-			kept.push(entry.from);
-		}
-	}
-	if (kept.length) (0, ownership_claim_exports.releaseClaim)(trash.claim);
-	else await discardTrash(trash);
-	return kept;
-}
-/** Deletes one trash entry: `rm -rf` for the bulk, then a walk that also clears read-only directories. */
-async function deleteTrashEntry(dir, operation) {
-	if (process.platform !== "win32") try {
-		await runOperationFile(operation, getExecutor(), "rm", [
-			"-rf",
-			"--",
-			join(dir, TRASH_ENTRIES)
-		], {
-			timeoutMs: "unbounded",
-			signal: operation?.signal,
-			cwd: dirname(dir)
-		});
-	} catch (error) {
-		rethrowCancellation(error, operation?.signal);
-	}
-	await removeTemporaryEntryAsync(dir, operation?.signal);
-}
-function deleteInBackground(trash) {
-	try {
-		(0, ownership_claim_exports.markClaimChildPending)(trash.claim);
-		const child = getExecutor().spawn("nice", [
-			"-n",
-			DELETE_NICENESS,
-			"rm",
-			"-rf",
-			"--",
-			join(trash.dir, TRASH_ENTRIES),
-			trash.dir
-		], {
-			cwd: dirname(trash.dir),
-			detached: true,
-			stdio: "ignore"
-		});
-		child.on?.("error", () => {});
-		child.unref?.();
-		const captured = child.pid === void 0 ? null : captureProcessIdentity(child.pid);
-		if (captured?.ok === false && captured.reason.startsWith("NOT_FOUND")) {
-			(0, ownership_claim_exports.clearClaimChild)(trash.claim);
-			(0, ownership_claim_exports.releaseClaim)(trash.claim);
-			return existsSync(trash.dir) ? "left" : "deleted";
-		}
-		if (!captured?.ok || child.pid === void 0) throw new Error("the trash deletion process was not recorded");
-		(0, ownership_claim_exports.setClaimChild)(trash.claim, {
-			pid: child.pid,
-			processToken: captured.token
-		});
-		return "background";
-	} catch {
-		try {
-			(0, ownership_claim_exports.clearClaimChild)(trash.claim);
-		} catch {}
-		(0, ownership_claim_exports.releaseClaim)(trash.claim);
-		return "left";
-	}
-}
-/**
-* Deletes the trash entry once git removed the worktree. A CLI command starts a detached, low-priority `rm` recorded
-* as the claim's child, so gc reports the entry as in use until `rm` exits. Inside a bounded report, such as the
-* programmatic API, every child is stopped when the report settles, so the entry is deleted before returning.
-* `left` means the entry waits for gc with its claim released.
-*/
-async function disposeTrash(trash, operation) {
-	if (!getExecutor().reportSignal?.()) return deleteInBackground(trash);
-	try {
-		await deleteTrashEntry(trash.dir, operation);
-		return "deleted";
-	} catch (error) {
-		rethrowCancellation(error, operation?.signal);
-		return "left";
-	} finally {
-		(0, ownership_claim_exports.releaseClaim)(trash.claim);
-	}
-}
-//#endregion
 //#region src/commands/worktree.ts
 function dependencyInstallCommand(target, dir = ".") {
 	const installRoot = resolve$1(target, dir);
@@ -2532,7 +2875,7 @@ function reportRefreshFailure(failure, out) {
 	out(chalk.red(`failed: ${failure.code}`));
 }
 function mainCheckoutAppDir(root, target, cwd) {
-	const app = findProjectRoot$1(cwd);
+	const app = warmedWorkspace(root, target, cwd) ?? findProjectRoot$1(cwd);
 	if (!app) return root;
 	const rel = relative$1(target, app);
 	if (!rel || rel.startsWith("..") || isAbsolute$1(rel)) return root;
@@ -2540,20 +2883,26 @@ function mainCheckoutAppDir(root, target, cwd) {
 }
 /**
 * The app workspace a warm prepares: the nearest app below the worktree root, or else the one app registered in
-* the source checkout, at the same place in this worktree, or else the worktree root when it is the app. A monorepo
-* root can declare react-native without being the app.
+* the source checkout, at the same place in this worktree, or else the one registered in this worktree, or else
+* the worktree root when it is the app. A monorepo root can declare react-native without being the app.
 */
 function warmedWorkspace(root, target, cwd) {
 	const nearest = findProjectRoot$1(cwd);
-	const app = nearest && isPathPrefix(target, nearest) && isMobileProject(nearest) ? nearest : null;
+	const app = nearest && isPathPrefix$1(target, nearest) && isMobileProject(nearest) ? nearest : null;
 	if (app && app !== target) return app;
-	const apps = /* @__PURE__ */ new Set();
-	for (const path of Object.keys(loadConfig$1()?.projects ?? {})) {
-		const rel = relative$1(root, path);
-		if (rel.startsWith("..") || isAbsolute$1(rel)) continue;
-		const mapped = resolve$1(target, rel);
-		if (isMobileProject(mapped)) apps.add(mapped);
-	}
+	const registered = Object.keys(loadConfig$1()?.projects ?? {});
+	const appsUnder = (checkout) => {
+		const apps = /* @__PURE__ */ new Set();
+		for (const path of registered) {
+			const rel = relative$1(checkout, path);
+			if (rel.startsWith("..") || isAbsolute$1(rel)) continue;
+			const mapped = resolve$1(target, rel);
+			if (isMobileProject(mapped)) apps.add(mapped);
+		}
+		return apps;
+	};
+	const source = appsUnder(root);
+	const apps = source.size ? source : appsUnder(target);
 	return apps.size === 1 ? [...apps][0] : app;
 }
 async function registerWarmedWorkspace(workspace, out) {
@@ -2608,7 +2957,7 @@ async function warmWorktreeTarget(opts) {
 		for (const key of scope) opts.beforeWarm?.(nativeCanonicalPath(key));
 		if (app) await recordWorkspaceUseAsync(app, /* @__PURE__ */ new Date(), operation.env, opts.cwd, operation.signal);
 		if (workspace && workspace !== app) await recordWorkspaceUseAsync(workspace, /* @__PURE__ */ new Date(), operation.env, opts.cwd, operation.signal);
-		if (!workspace) out(chalk.dim(phaseLine("project", "no single app to register here; run warm from the app directory to list it in status while it warms")));
+		if (!workspace) out(chalk.dim(phaseLine("project", opts.refresh ? "no single app to register here; --refresh updates only the repository root. Run warm --refresh from the app directory to refresh that app and list it in status" : "no single app to register here; run warm from the app directory to list it in status while it warms")));
 		else {
 			await registerWarmedWorkspace(workspace, out);
 			progress = startWarmProgress(workspace, opts.refresh ? "refresh" : "copy", { note: (line) => out(chalk.yellow(line)) });
@@ -2624,7 +2973,7 @@ async function warmWorktreeTarget(opts) {
 				out(chalk.dim(SETTING_SHAPE_REMEDY));
 				return null;
 			}
-			for (const key of unknownSettingKeys(settings)) out(chalk.yellow(`Warning: setting "${key}" is not read by Stim and will be ignored.`));
+			for (const key of unknownSettingKeys(settings)) out(chalk.yellow(inertSettingWarning(settings, key)));
 			return settings;
 		};
 		const copy = async (wait) => {
@@ -2657,12 +3006,12 @@ async function warmWorktreeTarget(opts) {
 					}
 					const excluded = readWorktreeExclude(root);
 					const patterns = excluded?.length ? excluded : settings.worktree?.exclude || [];
-					const result = await cloneIgnoredEntries({
+					const result = await trace.spanAsync("carry ignored entries", () => cloneIgnoredEntries({
 						root,
 						target,
 						patterns,
 						operation
-					});
+					}));
 					for (const entry of result.skipped) out(chalk.dim(phaseLine("carry", `kept ${entry.file} (${entry.reason})`)));
 					for (const entry of result.failed) out(chalk.yellow(phaseLine("carry", `could not copy ${entry.file}: ${entry.error}`)));
 					if (result.copied.length) {
@@ -2783,7 +3132,7 @@ function customIosDirs(worktree) {
 	} catch {
 		return [];
 	}
-	return Object.keys(loadConfig$1()?.projects ?? {}).filter((path) => isPathPrefix(worktree, path)).map((path) => ({
+	return Object.keys(loadConfig$1()?.projects ?? {}).filter((path) => isPathPrefix$1(worktree, path)).map((path) => ({
 		path,
 		ios: appIosProjectDir(path)
 	})).filter(({ ios }) => ios.custom && existsSync$1(ios.dir)).map(({ path, ios }) => ({
@@ -2832,31 +3181,10 @@ function excludePodChurn(lines, iosDirs = []) {
 		restore
 	};
 }
-function nativeCanonicalPath(path) {
-	const missing = [];
-	for (let existing = resolve$1(path);; existing = dirname$1(existing)) try {
-		return resolve$1(realpathSync$1.native(existing), ...missing);
-	} catch {
-		if (dirname$1(existing) === existing) return resolve$1(path);
-		missing.unshift(basename$1(existing));
-	}
-}
 /** Other worktrees git lists inside `path`, which removing `path` would delete with it. */
 function nestedWorktrees(entries, path) {
 	const root = nativeCanonicalPath(path);
-	return entries.filter((candidate) => !candidate.bare && nativeCanonicalPath(candidate.path) !== root).filter((candidate) => isPathPrefix(root, nativeCanonicalPath(candidate.path))).map((candidate) => candidate.path);
-}
-function matchWorktreeEntry(entries, path) {
-	let best = null;
-	const target = nativeCanonicalPath(path);
-	(entries || []).forEach((entry, index) => {
-		if (!entry?.path || !isPathPrefix(nativeCanonicalPath(entry.path), target)) return;
-		if (!best || entry.path.length > best.path.length) best = {
-			...entry,
-			index
-		};
-	});
-	return best;
+	return entries.filter((candidate) => !candidate.bare && nativeCanonicalPath(candidate.path) !== root).filter((candidate) => isPathPrefix$1(root, nativeCanonicalPath(candidate.path))).map((candidate) => candidate.path);
 }
 function removalRemedy(dirtyLines, { worktree = "<worktree>" } = {}) {
 	const tracked = [];
@@ -2886,10 +3214,11 @@ function pathArgs(lines, limit = 5) {
 	const shown = paths.slice(0, limit).map((p) => /[\s"'\\$`]/.test(p) ? JSON.stringify(p) : p);
 	return `${shown.join(" ")}${paths.length > shown.length ? " ..." : ""}`;
 }
+const DIRTY_BLOCKER = "uncommitted changes or untracked files";
 function removalBlockers({ dirty, unpushed }) {
 	const blockers = [];
 	if (dirty === null || unpushed === null) blockers.push("could not determine git status; re-run with --force to override");
-	if (dirty) blockers.push("uncommitted changes or untracked files");
+	if (dirty) blockers.push(DIRTY_BLOCKER);
 	if (unpushed && unpushed.length) blockers.push(`${plural(unpushed.length, "commit")} not on any remote or any other local branch`);
 	return blockers;
 }
@@ -2901,7 +3230,7 @@ function reclaimKeys(rootPath) {
 	const keys = /* @__PURE__ */ new Set([rootPath]);
 	const root = nativeCanonicalPath(rootPath);
 	if (cfg?.projects) {
-		for (const key of Object.keys(cfg.projects)) if (isPathPrefix(rootPath, key) || isPathPrefix(root, nativeCanonicalPath(key))) keys.add(key);
+		for (const key of Object.keys(cfg.projects)) if (isPathPrefix$1(rootPath, key) || isPathPrefix$1(root, nativeCanonicalPath(key))) keys.add(key);
 	}
 	return [...keys].toSorted();
 }
@@ -3042,11 +3371,11 @@ function reportRetainedResources(root, result, output) {
 }
 function hasRegisteredProjectUnder(rootPath) {
 	const cfg = loadConfig$1();
-	return Object.keys(cfg?.projects ?? {}).some((key) => isPathPrefix(rootPath, key));
+	return Object.keys(cfg?.projects ?? {}).some((key) => isPathPrefix$1(rootPath, key));
 }
 function projectAtOrAbove(root, path) {
 	const here = nativeCanonicalPath(path);
-	return Object.keys(loadConfig$1()?.projects ?? {}).filter((key) => isPathPrefix(nativeCanonicalPath(root), nativeCanonicalPath(key)) && isPathPrefix(nativeCanonicalPath(key), here)).toSorted((a, b) => b.length - a.length)[0] ?? null;
+	return Object.keys(loadConfig$1()?.projects ?? {}).filter((key) => isPathPrefix$1(nativeCanonicalPath(root), nativeCanonicalPath(key)) && isPathPrefix$1(nativeCanonicalPath(key), here)).toSorted((a, b) => b.length - a.length)[0] ?? null;
 }
 async function reclaimEnvironment(root, why, output, operation, beforeRemove) {
 	await withManagedRemoteWorktreeRemovalLock(root, () => withReclaimLocks(root, async (lockedKeys) => {
@@ -3080,6 +3409,9 @@ const REMOVAL_OUTPUT = {
 		process.exitCode = 1;
 	}
 };
+function blockersOf(inspection, opts) {
+	return opts.archiveDirty ? inspection.blockers.filter((blocker) => blocker !== DIRTY_BLOCKER) : inspection.blockers;
+}
 function removalPath(target, cwd = process.cwd()) {
 	return canonicalExistingPath(target ?? cwd);
 }
@@ -3186,6 +3518,25 @@ function printRemovalCleanup(result, failed, output) {
 	if (result.dereferenced.length) output.error(chalk.dim(phaseLine("workspace", `no longer referenced: ${result.dereferenced.join(", ")}`)));
 	for (const skipped of result.skippedDevices) output.error((failed ? chalk.dim : chalk.yellow)(phaseLine("device", `kept ${describeKeptDevice(skipped)} (${skipped.reason})`)));
 }
+async function archiveBeforeRemoval(path, repository, branch, head, opts, output) {
+	try {
+		if (!head) throw new Error("its HEAD could not be read");
+		return await archiveWorktreeChanges({
+			path,
+			repository,
+			branch,
+			head,
+			pullRequest: opts.archiveDirty?.pullRequest ?? null,
+			operation: opts.operation
+		});
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		opts.operation?.signal.throwIfAborted();
+		output.error(chalk.red(`Refusing to remove ${path}: could not archive its uncommitted changes: ${(error instanceof Error ? error.message : String(error)).split("\n")[0]}`));
+		output.fail();
+		return null;
+	}
+}
 async function removeWorktreeTarget(target, opts = {}) {
 	let removed = false;
 	await runRemove(target, opts, () => {
@@ -3337,6 +3688,13 @@ async function removeOrRefuse(target, opts, onRemoved, output) {
 		output.fail();
 		return;
 	}
+	const cli = stimCliUseOf(path, nativeCanonicalPath, stimCliEntries(opts.operation?.env));
+	if (cli.length) {
+		output.error(chalk.red(`Refusing to remove ${path}: ${cli.join("; ")}.`));
+		output.error(chalk.dim("Run stim from another checkout or install, or point PATH elsewhere, then retry."));
+		output.fail();
+		return;
+	}
 	const project = getProject(path);
 	const branch = entry.branch;
 	const ownsBranch = Boolean(branch && project?.worktreeBranchOwned === true && project.worktreeBranch === branch);
@@ -3352,13 +3710,15 @@ async function removeOrRefuse(target, opts, onRemoved, output) {
 			output.error(chalk.dim(`HEAD is in the merged PR #${pr.number} (${pr.url}); its local-only commits stay on GitHub.`));
 		}
 	}
-	if (inspection.blockers.length && !opts.force) {
+	if (blockersOf(inspection, opts).length && !opts.force) {
 		await printRemovalRefusal(path, inspection, output, opts.operation);
 		return;
 	}
 	const deleteOwnedBranch = Boolean(ownsBranch && approvedBranchSha && inspection.unpushed?.length === 0);
 	const retainedBranchReason = !branch ? null : !ownsBranch ? "Stim did not create it" : inspection.unpushed === null ? "Stim could not verify whether it has unique commits" : inspection.unpushed.length > 0 ? `it has ${plural(inspection.unpushed.length, "unique commit")}` : null;
 	const branchDeleteCwd = source.path;
+	let archive = null;
+	let gitRemoving = false;
 	await withManagedRemoteWorktreeRemovalLock(path, () => withReclaimLocks(path, async (lockedKeys) => {
 		options.signal?.throwIfAborted();
 		if ((await opts.guard?.(lockedKeys))?.length) return;
@@ -3370,16 +3730,25 @@ async function removeOrRefuse(target, opts, onRemoved, output) {
 			return;
 		}
 		const current = await inspectRemoval(path, mergedHead, opts.operation);
-		if (current.blockers.length && !opts.force) {
+		if (blockersOf(current, opts).length && !opts.force) {
 			await printRemovalRefusal(path, current, output, opts.operation);
 			return;
 		}
+		if (opts.archiveDirty && !opts.force && current.dirtyLines.length) {
+			const saved = await archiveBeforeRemoval(path, source.path, branch ?? null, inspectedHead, opts, output);
+			if (!saved) return;
+			archive = saved;
+		}
+		const discardArchive = async () => {
+			if (archive) await discardWorktreeArchive(archive);
+		};
 		const result = await reclaimAll(path, lockedKeys, {
 			preserveRootProject: true,
 			removedBy: opts.removedBy ?? "worktree-remove",
 			operation: opts.operation
 		});
 		if (result.keptEntries.length) {
+			await discardArchive();
 			reportRetainedResources(path, result, output);
 			return;
 		}
@@ -3390,12 +3759,14 @@ async function removeOrRefuse(target, opts, onRemoved, output) {
 			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
 			opts.operation?.signal.throwIfAborted();
 			if (!isTimeoutError(error)) throw error;
+			await discardArchive();
 			await printRemovalRefusal(path, timedOutInspection(error), output, opts.operation);
 			output.error(chalk.dim(`The directory and Stim ownership record for ${path} were kept.`));
 			printRemovalCleanup(result, true, output);
 			return;
 		}
 		if (headMoved) {
+			await discardArchive();
 			output.error(chalk.red(`Refusing to remove ${path}: its HEAD moved while its environment was reclaimed.`));
 			output.error(chalk.dim(`The directory and Stim ownership record for ${path} were kept.`));
 			printRemovalCleanup(result, true, output);
@@ -3410,10 +3781,28 @@ async function removeOrRefuse(target, opts, onRemoved, output) {
 			signal: options.signal,
 			declareFor: opts.operation
 		});
+		let stale = null;
+		if (archive) try {
+			stale = await worktreeArchiveMismatch(path, archive, opts.operation);
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			stale = `its archive could not be checked: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		if (stale) {
+			const unrestored = trash ? await restoreTrashedTrees(trash) : [];
+			if (trash && unrestored.length) output.error(chalk.yellow(`Could not move ${unrestored.join(", ")} back into ${path}; ${unrestored.length === 1 ? "it stays" : "they stay"} in ${trash.dir}, which stim gc keeps while ${path} exists.`));
+			await discardArchive();
+			output.error(chalk.red(`Refusing to remove ${path}: ${stale}.`));
+			output.error(chalk.dim(`The directory and Stim ownership record for ${path} were kept.`));
+			printRemovalCleanup(result, true, output);
+			output.fail();
+			return;
+		}
+		gitRemoving = true;
 		try {
 			await removeWorktreeAsync(path, {
 				from: source.path,
-				force: opts.force,
+				force: opts.force || archive !== null,
 				env: options.env,
 				signal: options.signal,
 				declareFor: opts.operation
@@ -3426,10 +3815,15 @@ async function removeOrRefuse(target, opts, onRemoved, output) {
 			output.error(chalk.red(`git worktree remove failed: ${message}`));
 			if (process.platform === "win32" && /Permission denied/i.test(message)) output.error(chalk.dim("Another process holds a file or directory inside the worktree. An adb server or emulator started from it keeps its working directory open; `adb kill-server` releases the server, and Sysinternals handle.exe lists other holders."));
 			output.error(chalk.dim(`The directory and Stim ownership record for ${path} were kept.`));
+			if (archive) output.error(chalk.dim(`Its uncommitted changes stay archived in ${archive.dir}.`));
 			printRemovalCleanup(result, true, output);
 			output.fail();
 			return;
 		}
+		if (archive) {
+			opts.archiveDirty?.onArchived(archive);
+			output.error(chalk.dim(phaseLine("archive", `saved ${plural(archive.tracked.length + archive.untracked.length, "uncommitted file")} to ${archive.dir}; restore: ${archive.restore.join(" && ")}`)));
+		}
 		onRemoved();
 		try {
 			forgetStatusMeasures(path, result.reclaimedKeys);
@@ -3492,6 +3886,11 @@ async function removeOrRefuse(target, opts, onRemoved, output) {
 	}, opts.operation, opts.beforeRemove), {
 		signal: opts.operation?.signal,
 		declareSpawnsFor: opts.operation
+	}).catch(async (error) => {
+		if (archive && !gitRemoving) await discardWorktreeArchive(archive);
+		throw error;
+	}).finally(() => {
+		if (archive) releaseWorktreeArchive(archive);
 	});
 }
 function registerRemove(worktree) {
@@ -3505,4 +3904,4 @@ function worktreeCommand(program) {
 	registerRemove(worktree);
 }
 //#endregion
-export { measurePressureAsync as A, reclaimProject as C, measureDisk as D, cacheBlocked as E, levelStillShort as F, lowestFree as I, protectWindowMs as L, sizeScanDeferred as M, diskPressureLevel as N, measureDiskAsync as O, levelFloors as P, describeDereferenced as S, sweepArchiveStaging as T, worktreeCommand as _, matchWorktreeEntry as a, TRASH_MANIFEST as b, reclaimKeys as c, removalBlockers as d, removalPath as f, warmedWorkspace as g, warmWorktreeTarget as h, excludeWatchmanCookies as i, measureSizes as j, measurePressure as k, registerRemove as l, removeWorktreeTarget as m, dependencyInstallCommand as n, nestedWorktrees as o, removalRemedy as p, excludePodChurn as r, porcelainPath as s, customIosDirs as t, registerWarm as u, TRASH_CLAIMS as v, deleteSelectedArchives as w, deleteTrashEntry as x, TRASH_ENTRY_PREFIX as y };
+export { deleteSelectedArchives as A, sizeScanDeferred as C, stimCliUseOf as D, stimCliEntries as E, worktreeArchiveLimits as M, describeDereferenced as O, measureSizes as S, serviceRunningFrom as T, cacheBlocked as _, nestedWorktrees as a, measurePressure as b, registerRemove as c, removalPath as d, removalRemedy as f, worktreeCommand as g, warmedWorkspace as h, excludeWatchmanCookies as i, sweepArchiveStaging as j, reclaimProject as k, registerWarm as l, warmWorktreeTarget as m, dependencyInstallCommand as n, porcelainPath as o, removeWorktreeTarget as p, excludePodChurn as r, reclaimKeys as s, customIosDirs as t, removalBlockers as u, measureDisk as v, uncommittedActivityOf as w, measurePressureAsync as x, measureDiskAsync as y };