stim 1.8.0 → 1.9.0

package/dist/{worktree-CFLA-6MX.mjs → worktree-LGB-UwgG.mjs}

@@ -1,23 +1,514 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { E as ownership_claim_exports, S as upsertProject, f as getProject, g as loadConfig, h as isPathPrefix, u as getConfigDir, v as removeProject, w as process_identity_exports } from "./config-B7iyKWkL.mjs";
-import { S as warmWorktreePaths, _ as resolveFullRef, b as sourceCheckoutOf, c as hasRemote, d as listWorktrees, f as locallyKnownUpstream, h as removeWorktree, i as depsOutOfSync, l as hasUncommittedWork, m as readWorktreeExclude, n as cloneIgnoredEntries, o as dirtyPaths, p as podsOutOfSync, r as deleteBranch, s as gitCommonDir, t as branchExists, u as isPodInstallChurn, x as unpushedCommits, y as restoreFile } from "./worktree-FG_ZKKdb.mjs";
-import { a as findProjectRoot } from "./project-DDZWf_16.mjs";
-import { l as readRemoteSession, s as readMetroTunnel } from "./state-DZobzxLW.mjs";
-import { A as resolveSettings, I as unknownSettingKeys, N as settingShapeErrors, a as SETTING_SHAPE_REMEDY } from "./settings-BXXorVM2.mjs";
-import { a as formatElapsed, f as releasedLeaseFact, i as formatDuration, l as phaseLine, m as shortUdid, u as plural } from "./command-output-B3ycpsYv.mjs";
-import { a as POOL_SETTING_REMEDY, l as parkedMaxSetting } from "./teardown-BJqEzPo_.mjs";
-import { h as podInstallCommand, n as HEARTBEAT_INTERVAL_MS } from "./xcode-B6YaWeg0.mjs";
-import { n as hasInstalledDependencies, r as installedNpmTreeIsValid, t as dependencyState } from "./dependency-state-D0M7oKA7.mjs";
-import { c as withManagedTunnelRemovalLock, o as withManagedRemoteWorktreeRemovalLock } from "./ownership-wolE-0Do.mjs";
-import { n as reclaimProject } from "./reclaim-KJ-0uWEF.mjs";
-import { a as runPodInstall, i as runCaptured, n as podsAreStale, r as readPodState, t as DEPS_ERROR } from "./deps-oCXVNEqQ.mjs";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { createHash, randomUUID } from "node:crypto";
-import { join, relative } from "node:path";
+import { D as process_identity_exports, K as projectDeviceSlots, O as acquireAvdClaim, b as removeProject, f as getProject, g as loadConfig, h as isPathPrefix, i as clearDevice, k as ownership_claim_exports, u as getConfigDir, w as upsertProject } from "./config-Cp9lM3wX.mjs";
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { _ as workspaceDir, i as recordWorkspaceUse, r as readWorkspaceState } from "./workspace-state-DF2gCFhx.mjs";
+import { C as warmWorktreePaths, S as unpushedCommits, b as restoreFile, c as hasPopulatedSubmodules, d as isPodInstallChurn, f as listWorktrees, g as removeWorktree, h as readWorktreeExclude, i as depsOutOfSync, l as hasRemote, m as podsOutOfSync, n as cloneIgnoredEntries, o as dirtyPaths, p as locallyKnownUpstream, r as deleteBranch, s as gitCommonDir, t as branchExists, u as hasUncommittedWork, v as resolveFullRef, x as sourceCheckoutOf } from "./worktree-R_cUlE7s.mjs";
+import { o as findProjectRoot } from "./project-DS112DYB.mjs";
+import { a as clearRemoteSession, i as clearManagedMetroTunnel, l as readRemoteSession, s as readMetroTunnel, u as readRemoteSessionId } from "./state-NcJzMEBF.mjs";
+import { a as pidExists, c as resolveProjectMetro, l as signalProcessTree, n as killMetroTree } from "./metro-DrLHaMn2.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-D15Op8vN.mjs";
+import { F as unknownSettingKeys, M as settingShapeErrors, i as SETTING_SHAPE_REMEDY, k as resolveSettings } from "./settings-D030k0t4.mjs";
+import { a as formatElapsed, h as shortUdid, i as formatDuration, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-gByVmIjy.mjs";
+import { n as listBuildLocks } from "./build-lock-DPXPLgTc.mjs";
+import { b as resolveEasCliBin, o as parkedMaxSetting, t as POOL_SETTING_REMEDY } from "./sim-pool-KaIsp2Ft.mjs";
+import { n as workspaceProcessLockError, r as workspaceProcessLockPath, t as withWorkspaceProcessLock } from "./workspace-process-lock-DWaiRD0e.mjs";
+import { l as releaseWorkspaceLeases } from "./device-lease-Crs-HkJY.mjs";
+import { _ as listBuildSlots, h as podInstallCommand, n as HEARTBEAT_INTERVAL_MS } from "./xcode-BZqyxh3e.mjs";
+import { E as teardownOwnedIosSim, T as teardownOwnedAvd, i as endRecordedSession } from "./device-remote-AQ5rQPqr.mjs";
+import { n as hasInstalledDependencies, r as installedNpmTreeIsValid, t as dependencyState } from "./dependency-state-Bq5DcLGn.mjs";
+import { t as clearNamedPorts } from "./named-ports-CmLQSIRj.mjs";
+import { i as stopTunnel, l as withManagedTunnelRemovalLock, n as managedLockHolders, s as withManagedRemoteWorktreeRemovalLock, t as resolveSupervisorTarget } from "./ownership-DCQPuWEc.mjs";
+import { a as runPodInstall, i as runCaptured, n as podsAreStale, r as readPodState, t as DEPS_ERROR } from "./deps-Cip5vUm1.mjs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, unlinkSync, writeFileSync } from "node:fs";
 import { existsSync as existsSync$1, realpathSync as realpathSync$1 } from "fs";
-import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, relative as relative$1, resolve as resolve$1 } from "path";
+import { basename, dirname, isAbsolute, relative, resolve } from "path";
 import { workspaceName } from "@stim-cli/core";
+import { join as join$1, relative as relative$1 } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
 import chalk from "chalk";
+//#region src/commands/gc/paths.ts
+function canonicalPath(p) {
+	try {
+		return realpathSync$1(p);
+	} catch {
+		return resolve(p);
+	}
+}
+//#endregion
+//#region src/workspace/in-use.ts
+const NATIVE_RUN = "native-run";
+const NATIVE_RUN_HELD = "a stim ios, android or stop run holds its native-run.lock";
+function workspaceInUse(root, { supervisor = true, managedLocks = true, nativeRun = true } = {}) {
+	const reasons = [];
+	if (supervisor) {
+		const project = getProject(root);
+		const target = resolveSupervisorTarget({
+			state: readWorkspaceState(root)?.supervisor,
+			record: project?.supervisor,
+			reservedPort: project?.metroPort
+		});
+		if (target.status === "ours") reasons.push(`its dev server supervisor (pid ${target.pid}) is running`);
+		else if (target.status === "unverified") reasons.push(`its dev server supervisor cannot be verified: ${target.reason ?? "unknown identity"}`);
+	}
+	if (nativeRun) {
+		const claims = (0, ownership_claim_exports.readClaimSet)(workspaceProcessLockPath(workspaceDir(root), NATIVE_RUN, true));
+		if (claims.live.length) reasons.push(NATIVE_RUN_HELD);
+		else if (claims.unresolved[0]) reasons.push(`its native-run.lock cannot be resolved: ${claims.unresolved[0].reason}`);
+	}
+	const self = canonicalPath(root);
+	for (const [kind, entries] of [["build lock", listBuildLocks()], ["build slot", listBuildSlots()]]) for (const entry of entries) {
+		if (!entry.alive && !entry.unresolved) continue;
+		if (entry.projectRoot !== null && canonicalPath(entry.projectRoot) === self) reasons.push(`a ${entry.alive ? "live" : "unresolvable"} ${kind} at ${entry.path} names it`);
+	}
+	if (managedLocks) reasons.push(...managedLockHolders(root));
+	return reasons;
+}
+function emptyWorkspaceDir(dir) {
+	if (lstatSync(dir).isSymbolicLink()) {
+		unlinkSync(dir);
+		return;
+	}
+	for (const name of readdirSync(dir)) if (name !== `${NATIVE_RUN}.lock`) rmSync(join$1(dir, name), {
+		recursive: true,
+		force: true
+	});
+}
+async function withIdleWorkspace(root, fn, { purpose, ...checks }) {
+	try {
+		return await withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN, async () => {
+			const reasons = workspaceInUse(root, {
+				...checks,
+				nativeRun: false
+			});
+			if (reasons.length) return {
+				ran: false,
+				reasons
+			};
+			return {
+				ran: true,
+				value: await fn()
+			};
+		}, {
+			external: true,
+			waitMs: 0,
+			ownerPurpose: purpose
+		});
+	} catch (error) {
+		if (workspaceProcessLockError(error)) return {
+			ran: false,
+			reasons: [NATIVE_RUN_HELD]
+		};
+		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return {
+			ran: false,
+			reasons: [`its native-run.lock cannot be taken: ${error.reason}`]
+		};
+		throw error;
+	} finally {
+		try {
+			const dir = workspaceDir(root);
+			if (!lstatSync(dir).isSymbolicLink()) rmdirSync(dir);
+		} catch {}
+	}
+}
+//#endregion
+//#region src/devices/reclaim.ts
+async function reapCollectors(root, { verify = verifyCollectorOwnership, collectors }) {
+	const skippedDevices = [];
+	const failedDevices = [];
+	for (const [platform, record] of Object.entries(collectors)) {
+		const rec = record;
+		const pid = rec?.pid;
+		if (typeof pid !== "number" || pid <= 0 || pid === process.pid || !pidExists(pid)) continue;
+		const ownership = verify({
+			pid,
+			platform,
+			root,
+			expected: rec
+		});
+		if (ownership.status === "gone") continue;
+		if (ownership.status === "unverified") {
+			const name = `${platform} log collector (pid ${pid})`;
+			const entry = {
+				platform: platform.split(":")[0] === "android" ? "android" : "ios",
+				name,
+				reason: `${ownership.reason}; keeping the record without signalling the process`
+			};
+			skippedDevices.push(entry);
+			failedDevices.push(entry);
+			continue;
+		}
+		try {
+			process.kill(pid, "SIGTERM");
+			if (await (0, process_identity_exports.waitForProcessExit)(rec, 5e3)) continue;
+		} catch (error) {
+			if (error.code === "ESRCH") continue;
+		}
+		const entry = {
+			platform: platform.split(":")[0] === "android" ? "android" : "ios",
+			name: `${platform} log collector (pid ${pid})`,
+			reason: "Collector exit could not be confirmed; keeping its ownership record."
+		};
+		skippedDevices.push(entry);
+		failedDevices.push(entry);
+	}
+	return {
+		skippedDevices,
+		failedDevices
+	};
+}
+function reclaimRemoteSession(root, { stopSession = defaultStopSession } = {}) {
+	const sessionId = readRemoteSessionId(root);
+	if (!sessionId) return {
+		stopped: null,
+		failed: null
+	};
+	let result;
+	try {
+		result = stopSession(root, sessionId);
+	} catch (err) {
+		result = {
+			status: "failed",
+			reason: String(err?.message ?? err)
+		};
+	}
+	if (result.status === "torn-down") {
+		if (result.reason) return {
+			stopped: sessionId,
+			failed: {
+				platform: "ios",
+				name: `remote session ${sessionId}`,
+				reason: `${result.reason} The session is stopped. Re-run cleanup to reconcile its retained ownership claim.`
+			}
+		};
+		clearRemoteSession(root, sessionId);
+		return {
+			stopped: sessionId,
+			failed: null
+		};
+	}
+	return {
+		stopped: null,
+		failed: {
+			platform: "ios",
+			name: `remote session ${sessionId}`,
+			reason: `${result.reason ?? "stop failed"} -- it keeps billing until its max duration. Stop it by hand from any directory of this project: eas simulator:stop --id ${sessionId}`
+		}
+	};
+}
+function defaultStopSession(root, sessionId) {
+	return endRecordedSession({
+		root,
+		sessionId,
+		easBin: resolveEasCliBin(root)?.file ?? null
+	});
+}
+function defaultStopMetroTunnel(record) {
+	return stopTunnel(record);
+}
+async function reclaimMetroTunnel(root, { stopMetroTunnel = defaultStopMetroTunnel } = {}) {
+	const record = readMetroTunnel(root);
+	if (record?.kind !== "managed") return {
+		stopped: null,
+		failed: null
+	};
+	let result;
+	try {
+		result = await stopMetroTunnel(record);
+	} catch (err) {
+		result = {
+			status: "failed",
+			reason: String(err?.message ?? err)
+		};
+	}
+	if (result.status === "failed") return {
+		stopped: null,
+		failed: {
+			platform: "ios",
+			name: `${record.provider} tunnel (pid ${record.pid})`,
+			reason: `${result.reason ?? "stop failed"} The process identity could not be verified or the stop could not be confirmed. The ownership record is kept. Inspect the process and retry \`stim worktree remove\`.`
+		}
+	};
+	if (!clearManagedMetroTunnel(root, record)) return {
+		stopped: null,
+		failed: {
+			platform: "ios",
+			name: "replacement managed tunnel",
+			reason: "A replacement managed tunnel record appeared during cleanup and is retained for a later stop."
+		}
+	};
+	return {
+		stopped: record.provider,
+		failed: null
+	};
+}
+function describeDereferenced(project) {
+	const devices = Object.entries(project?.ports ?? {}).map(([label, port]) => `port ${label} (${port})`);
+	for (const { platforms } of projectDeviceSlots(project)) {
+		const ios = platforms.ios;
+		if (ios?.deviceUdid) devices.push(`ios sim ${ios.deviceUdid}`);
+		const android = platforms.android;
+		if (android?.avdName) devices.push(`android avd ${android.avdName}`);
+		else if (android?.serial) devices.push(`android device ${android.serial}`);
+	}
+	return devices;
+}
+function parkedIosCacheKey(lastBuild) {
+	if (lastBuild === null || typeof lastBuild !== "object" || Array.isArray(lastBuild)) return null;
+	const build = lastBuild;
+	return build.platform === "ios" && typeof build.cacheKey === "string" ? build.cacheKey : null;
+}
+function parkRequest(project, projectPath, slot, simslimManaged) {
+	const { max, error } = parkedMaxSetting("ios");
+	if (error || max <= 0) return void 0;
+	const cacheKey = parkedIosCacheKey(readWorkspaceState(projectPath)?.lastBuild);
+	return {
+		projectPath,
+		max,
+		bundleId: typeof project?.bundleId === "string" ? project.bundleId : null,
+		cacheKey,
+		simslimManaged,
+		slot
+	};
+}
+function reclaimOwnedDevices(project, projectPath, { park = false } = {}) {
+	const deletedDevices = [];
+	const parkedDevices = [];
+	const evictedDevices = [];
+	const poolNotes = [];
+	const skippedDevices = [];
+	const failedDevices = [];
+	for (const { slot, platforms } of projectDeviceSlots(project)) {
+		const ios = platforms.ios;
+		if (ios?.owned && ios.deviceUdid) {
+			const udid = ios.deviceUdid;
+			const label = ios.deviceName || udid;
+			const r = teardownOwnedIosSim(udid, {
+				del: true,
+				label,
+				...park ? { park: parkRequest(project, projectPath, slot, Boolean(ios.simslimManaged)) } : {}
+			});
+			if (r.parkFallback) poolNotes.push(`could not park ${label}: ${r.parkFallback} -- deleted it instead`);
+			for (const failure of r.evictionFailures ?? []) poolNotes.push(failure);
+			if (r.parked) {
+				parkedDevices.push(r.parked);
+				evictedDevices.push(...r.evicted ?? []);
+			} else if (r.status === "torn-down") deletedDevices.push(r.label);
+			if (!r.parked && (r.status === "torn-down" || r.status === "missing")) clearDevice(projectPath, "ios", slot, udid);
+			if (r.status === "skipped") skippedDevices.push({
+				platform: "ios",
+				name: label,
+				udid,
+				reason: `${r.reason} -- not touched`
+			});
+			else if (r.status === "failed") {
+				const entry = {
+					platform: "ios",
+					name: label,
+					udid,
+					reason: `teardown failed: ${r.reason}`
+				};
+				skippedDevices.push(entry);
+				failedDevices.push(entry);
+			}
+		}
+		const android = platforms.android;
+		if (android?.owned && android.avdName) {
+			const bound = parkedMaxSetting("android");
+			const r = teardownOwnedAvd(android.avdName, {
+				del: true,
+				owner: {
+					projectPath,
+					slot
+				},
+				...park && !bound.error && bound.max > 0 ? { park: {
+					projectPath,
+					slot,
+					max: bound.max,
+					configuration: typeof android.poolConfiguration === "string" ? android.poolConfiguration : void 0
+				} } : {}
+			});
+			if (r.parkFallback) poolNotes.push(`could not park ${android.avdName}: ${r.parkFallback} -- deleted it instead`);
+			for (const failure of r.evictionFailures ?? []) poolNotes.push(failure);
+			if (!r.parked && (r.status === "torn-down" || r.status === "missing")) clearDevice(projectPath, "android", slot, android.avdName);
+			if (r.parked) {
+				parkedDevices.push(r.parked);
+				evictedDevices.push(...r.evicted ?? []);
+			} else if (r.status === "torn-down") deletedDevices.push(android.avdName);
+			else if (r.status === "skipped") skippedDevices.push({
+				platform: "android",
+				name: android.avdName,
+				reason: `${r.reason} -- not touched`
+			});
+			else if (r.status === "failed") {
+				const entry = {
+					platform: "android",
+					name: android.avdName,
+					reason: `teardown failed: ${r.reason}`
+				};
+				skippedDevices.push(entry);
+				failedDevices.push(entry);
+			}
+		}
+	}
+	return {
+		deletedDevices,
+		parkedDevices,
+		evictedDevices,
+		poolNotes,
+		skippedDevices,
+		failedDevices
+	};
+}
+async function reclaimProject(path, options = {}) {
+	const dir = workspaceDir(path);
+	const existed = existsSync(dir);
+	const run = await withIdleWorkspace(path, () => reclaimIdleProject(path, existed, options), {
+		purpose: "workspace removal",
+		supervisor: false,
+		managedLocks: false
+	});
+	if (run.ran) return run.value;
+	const kept = {
+		name: `workspace ${dir}`,
+		reason: `kept because ${run.reasons.join("; ")}`
+	};
+	return {
+		path,
+		dereferenced: [],
+		killedPid: null,
+		skippedMetro: null,
+		metroPort: getProject(path)?.metroPort ?? null,
+		deletedDevices: [],
+		parkedDevices: [],
+		evictedDevices: [],
+		poolNotes: [],
+		skippedDevices: [kept],
+		failedDevices: [kept],
+		keptEntry: true,
+		stoppedSession: null,
+		stoppedTunnel: null,
+		releasedLeases: [],
+		removedWorkspaceDirs: [],
+		failedWorkspaceDirs: []
+	};
+}
+async function reclaimIdleProject(path, workspaceExisted, { deleteOwnedDevices = false, parkOwnedDevices = false, preserveProjectRecord = false, stopSession = defaultStopSession, stopMetroTunnel = defaultStopMetroTunnel, releaseLeases = releaseWorkspaceLeases, verifyCollector = verifyCollectorOwnership }) {
+	await clearNamedPorts(path, { stop: true });
+	const project = getProject(path);
+	for (const { platforms } of projectDeviceSlots(project)) if (platforms.android?.owned && platforms.android.avdName) (0, ownership_claim_exports.releaseClaim)(acquireAvdClaim(platforms.android.avdName));
+	const dereferenced = describeDereferenced(project);
+	const initialState = readWorkspaceState(path);
+	let killedPid = null;
+	let skippedMetro = null;
+	let supervisorHeld = false;
+	const supervisor = resolveSupervisorTarget({
+		state: initialState?.supervisor,
+		record: project?.supervisor,
+		reservedPort: project?.metroPort
+	});
+	const orphanServer = {
+		pid: Number(initialState?.supervisor?.serverPid),
+		processToken: initialState?.supervisor?.serverProcessToken
+	};
+	const orphanIdentity = supervisor.status === "stale" && typeof orphanServer.processToken === "string" ? (0, process_identity_exports.inspectProcessIdentity)(orphanServer) : null;
+	if (supervisor.status === "ours") {
+		if (killMetroTree(supervisor.pid, supervisor.processToken) && await (0, process_identity_exports.waitForProcessExit)(supervisor, 1e4)) killedPid = supervisor.pid;
+		else {
+			skippedMetro = `could not confirm supervisor pid ${supervisor.pid} exited`;
+			supervisorHeld = true;
+		}
+	} else if (supervisor.status === "unverified") {
+		skippedMetro = supervisor.reason ?? "supervisor identity could not be verified";
+		supervisorHeld = true;
+	} else if (orphanIdentity === "same") {
+		let signalled = false;
+		try {
+			signalled = signalProcessTree(orphanServer.pid, "SIGTERM");
+		} catch {}
+		if (signalled ? await (0, process_identity_exports.waitForProcessExit)(orphanServer, 1e4) : ["gone", "different"].includes((0, process_identity_exports.inspectProcessIdentity)(orphanServer))) killedPid = orphanServer.pid;
+		else {
+			skippedMetro = `could not confirm dev server pid ${orphanServer.pid} left by the supervisor exited`;
+			supervisorHeld = true;
+		}
+	} else if (orphanIdentity === "unknown") {
+		skippedMetro = `the identity of dev server pid ${orphanServer.pid} left by the supervisor could not be verified`;
+		supervisorHeld = true;
+	} else if (typeof project?.metroPort === "number") {
+		if (!(await resolveProjectMetro(project.metroPort, path)).missing) skippedMetro = "Externally started server left alone; no verified Stim supervisor owns it";
+	}
+	const { skippedDevices: skippedCollectors, failedDevices: failedCollectors } = await reapCollectors(path, {
+		verify: verifyCollector,
+		collectors: initialState?.collectors ?? {}
+	});
+	function retainReplacementProcesses() {
+		const currentState = readWorkspaceState(path);
+		const currentProject = getProject(path);
+		if (Boolean(currentState?.supervisor && !(0, process_identity_exports.sameProcessRecord)(currentState.supervisor, initialState?.supervisor) || currentProject?.supervisor && !(0, process_identity_exports.sameProcessRecord)(currentProject.supervisor, project?.supervisor) || Object.entries(currentState?.collectors ?? {}).some(([platform, record]) => !(0, process_identity_exports.sameProcessRecord)(record, initialState?.collectors?.[platform])))) {
+			supervisorHeld = true;
+			skippedMetro = "A replacement process appeared during cleanup; its ownership records are retained";
+		}
+	}
+	retainReplacementProcesses();
+	const { deletedDevices, parkedDevices, evictedDevices, poolNotes, skippedDevices, failedDevices } = deleteOwnedDevices && !supervisorHeld && failedCollectors.length === 0 ? reclaimOwnedDevices(project, path, { park: parkOwnedDevices }) : {
+		deletedDevices: [],
+		parkedDevices: [],
+		evictedDevices: [],
+		poolNotes: [],
+		skippedDevices: [],
+		failedDevices: []
+	};
+	skippedDevices.push(...skippedCollectors);
+	failedDevices.push(...failedCollectors);
+	const remote = reclaimRemoteSession(path, { stopSession });
+	if (remote.failed) {
+		skippedDevices.push(remote.failed);
+		failedDevices.push(remote.failed);
+	}
+	const tunnel = await reclaimMetroTunnel(path, { stopMetroTunnel });
+	if (tunnel.failed) {
+		skippedDevices.push(tunnel.failed);
+		failedDevices.push(tunnel.failed);
+	}
+	let releasedLeases = [];
+	try {
+		releasedLeases = releaseLeases(path);
+	} catch {
+		releasedLeases = [];
+	}
+	retainReplacementProcesses();
+	const removedWorkspaceDirs = [];
+	const failedWorkspaceDirs = [];
+	if (failedDevices.length === 0 && !supervisorHeld) {
+		const dir = workspaceDir(path);
+		if (existsSync(dir)) try {
+			emptyWorkspaceDir(dir);
+			if (workspaceExisted) removedWorkspaceDirs.push(dir);
+		} catch {
+			failedWorkspaceDirs.push(dir);
+		}
+	}
+	const keptEntry = supervisorHeld || failedDevices.length > 0 || failedWorkspaceDirs.length > 0;
+	if (project && !keptEntry && !preserveProjectRecord) removeProject(path);
+	return {
+		path,
+		dereferenced,
+		killedPid,
+		skippedMetro,
+		metroPort: project?.metroPort ?? null,
+		deletedDevices,
+		parkedDevices,
+		evictedDevices,
+		poolNotes,
+		skippedDevices,
+		failedDevices,
+		keptEntry,
+		stoppedSession: remote.stopped,
+		stoppedTunnel: tunnel.stopped,
+		releasedLeases,
+		removedWorkspaceDirs,
+		failedWorkspaceDirs
+	};
+}
+//#endregion
 //#region src/engine/warm-claim.ts
 const WARM_CLAIM_LABEL = "worktree warm";
 const WARM_CLAIM_POLL_MS = 250;
@@ -38,10 +529,10 @@ function defaultSleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function warmClaimsDir() {
-	return join(getConfigDir(), "warm-locks");
+	return join$1(getConfigDir(), "warm-locks");
 }
 function warmClaimPath(repositoryRoot) {
-	return join(warmClaimsDir(), `${workspaceName(repositoryRoot)}.lock`);
+	return join$1(warmClaimsDir(), `${workspaceName(repositoryRoot)}.lock`);
 }
 function warmCommand(phase) {
 	return phase === "refresh" ? "stim worktree warm --refresh" : "stim worktree warm";
@@ -368,11 +859,11 @@ function stepLine(label, reason, action) {
 	return phaseLine(label, `${reason} -> ${action}`);
 }
 function installRecordFile(depsRoot) {
-	return join(getConfigDir(), "warm-installs", `${workspaceName(depsRoot)}.json`);
+	return join$1(getConfigDir(), "warm-installs", `${workspaceName(depsRoot)}.json`);
 }
 function lockfileHash(depsRoot, lockfile) {
 	try {
-		return createHash("sha256").update(readFileSync(join(depsRoot, lockfile))).digest("hex");
+		return createHash("sha256").update(readFileSync(join$1(depsRoot, lockfile))).digest("hex");
 	} catch {
 		return null;
 	}
@@ -394,7 +885,7 @@ function readInstallEvidence(depsRoot) {
 function writeInstallEvidence(depsRoot, lockfile, hash, completed) {
 	const file = installRecordFile(depsRoot);
 	const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
-	mkdirSync(join(getConfigDir(), "warm-installs"), { recursive: true });
+	mkdirSync(join$1(getConfigDir(), "warm-installs"), { recursive: true });
 	writeFileSync(tmp, JSON.stringify({
 		lock: lockfile,
 		hash: hash ?? "",
@@ -412,9 +903,9 @@ function restoreInstallEvidence(depsRoot, prior) {
 	else rmSync(installRecordFile(depsRoot), { force: true });
 }
 function inProgressOperation(gitDir) {
-	if (existsSync(join(gitDir, "rebase-merge"))) return "rebase";
-	if (existsSync(join(gitDir, "rebase-apply"))) return existsSync(join(gitDir, "rebase-apply", "applying")) ? "am" : "rebase";
-	return existsSync(join(gitDir, "MERGE_HEAD")) ? "merge" : null;
+	if (existsSync(join$1(gitDir, "rebase-merge"))) return "rebase";
+	if (existsSync(join$1(gitDir, "rebase-apply"))) return existsSync(join$1(gitDir, "rebase-apply", "applying")) ? "am" : "rebase";
+	return existsSync(join$1(gitDir, "MERGE_HEAD")) ? "merge" : null;
 }
 function readMainCheckoutState(root) {
 	const exec = getExecutor();
@@ -668,7 +1159,7 @@ async function refreshMainCheckout({ root, appDir, settings, emit, spawnFn = nul
 	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,
+		lockfileChanged: dependencies ? pathChangedBetween(root, before, head, gitPath(relative$1(root, dependencies.root), dependencies.lock)) : false,
 		installed,
 		treeValid: dependencies?.lock === "package-lock.json" && installed ? installedNpmTreeIsValid(dependencies.root) : null,
 		lastInstall: priorInstall,
@@ -700,11 +1191,11 @@ async function refreshMainCheckout({ root, appDir, settings, emit, spawnFn = nul
 		if (marked) restoreInstallEvidence(marked.root, priorInstall);
 		emit(stepLine("deps", depsSubject, "skipped"));
 	}
-	const app = relative(root, appDir) || ".";
+	const app = relative$1(root, appDir) || ".";
 	const where = `source ${appDir}: `;
 	const podState = readPodState(appDir);
 	const pods = podsPlan({
-		hasIos: existsSync(join(appDir, "ios")),
+		hasIos: existsSync(join$1(appDir, "ios")),
 		hasPodfile: podState.hasPodfile,
 		podfileLockChanged: pathChangedBetween(root, before, head, gitPath(app, "ios", "Podfile.lock")),
 		stale: podsAreStale(podState.lockText, podState.manifestText)
@@ -735,12 +1226,12 @@ async function refreshMainCheckout({ root, appDir, settings, emit, spawnFn = nul
 //#endregion
 //#region src/commands/worktree.ts
 function dependencyInstallCommand(target, dir = ".") {
-	const installRoot = resolve$1(target, dir);
+	const installRoot = resolve(target, dir);
 	let command = "npm install";
-	if (existsSync$1(resolve$1(installRoot, "pnpm-lock.yaml"))) command = "pnpm install";
-	else if (existsSync$1(resolve$1(installRoot, "yarn.lock"))) command = "yarn install";
-	else if (existsSync$1(resolve$1(installRoot, "bun.lock")) || existsSync$1(resolve$1(installRoot, "bun.lockb"))) command = "bun install";
-	else if (existsSync$1(resolve$1(installRoot, "package-lock.json"))) command = "npm ci";
+	if (existsSync$1(resolve(installRoot, "pnpm-lock.yaml"))) command = "pnpm install";
+	else if (existsSync$1(resolve(installRoot, "yarn.lock"))) command = "yarn install";
+	else if (existsSync$1(resolve(installRoot, "bun.lock")) || existsSync$1(resolve(installRoot, "bun.lockb"))) command = "bun install";
+	else if (existsSync$1(resolve(installRoot, "package-lock.json"))) command = "npm ci";
 	return `cd '${installRoot.replaceAll("'", "'\\''")}' && ${command}`;
 }
 function reportCarriedStateHealth(root, target, copied) {
@@ -752,7 +1243,7 @@ function reportCarriedStateHealth(root, target, copied) {
 	}
 	for (const p of podsOutOfSync(target, copied)) {
 		const where = p.dir === "." ? "Podfile.lock" : `${p.dir}/Podfile.lock`;
-		const pod = podInstallCommand(p.dir === "." ? target : resolve$1(target, p.dir, ".."));
+		const pod = podInstallCommand(p.dir === "." ? target : resolve(target, p.dir, ".."));
 		console.error(chalk.yellow(phaseLine("carry", p.reason === "missing" ? `carried ${p.dir === "." ? "Pods" : `${p.dir}/Pods`} but there is no ${where}. Run \`${pod}\` before building.` : `carried ${p.dir === "." ? "Pods" : `${p.dir}/Pods`} does not match the ${where} on disk here. Pods are gitignored and cloned; Podfile.lock is tracked, so the two can disagree. Run \`${pod}\` before building, or xcodebuild fails with "sandbox is not in sync" only after every pod has compiled.`)));
 	}
 }
@@ -766,14 +1257,16 @@ function reportRefreshFailure(failure) {
 function mainCheckoutAppDir(root, target) {
 	const app = findProjectRoot(process.cwd());
 	if (!app) return root;
-	const rel = relative$1(target, app);
-	if (!rel || rel.startsWith("..") || isAbsolute$1(rel)) return root;
-	return resolve$1(root, rel);
+	const rel = relative(target, app);
+	if (!rel || rel.startsWith("..") || isAbsolute(rel)) return root;
+	return resolve(root, rel);
 }
 function registerWarm(worktree) {
 	worktree.command("warm").description("Copy missing ignored paths from the source checkout into the current linked worktree.").option("--refresh", "Before copying, fast-forward the source checkout to its upstream and install what the new commits moved.").action(async (opts) => {
 		try {
 			const { root, target, common } = warmWorktreePaths(process.cwd());
+			const app = findProjectRoot(process.cwd());
+			if (app) recordWorkspaceUse(app);
 			const readSettings = () => {
 				const settings = resolveSettings({
 					gitCommonDir: common,
@@ -920,10 +1413,20 @@ function excludePodChurn(lines) {
 		restore
 	};
 }
+function nativeCanonicalPath(path) {
+	const missing = [];
+	for (let existing = resolve(path);; existing = dirname(existing)) try {
+		return resolve(realpathSync$1.native(existing), ...missing);
+	} catch {
+		if (dirname(existing) === existing) return resolve(path);
+		missing.unshift(basename(existing));
+	}
+}
 function matchWorktreeEntry(entries, path) {
 	let best = null;
+	const target = nativeCanonicalPath(path);
 	(entries || []).forEach((entry, index) => {
-		if (!entry?.path || !isPathPrefix(entry.path, path)) return;
+		if (!entry?.path || !isPathPrefix(nativeCanonicalPath(entry.path), target)) return;
 		if (!best || entry.path.length > best.path.length) best = {
 			...entry,
 			index
@@ -972,8 +1475,9 @@ function describeKeptDevice(s) {
 function reclaimKeys(rootPath) {
 	const cfg = loadConfig();
 	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)) keys.add(key);
+		for (const key of Object.keys(cfg.projects)) if (isPathPrefix(rootPath, key) || isPathPrefix(root, nativeCanonicalPath(key))) keys.add(key);
 	}
 	return [...keys].toSorted();
 }
@@ -998,11 +1502,22 @@ async function reclaimAll(rootPath, keys = reclaimKeys(rootPath), { preserveRoot
 	const removedWorkspaceDirs = [];
 	const failedWorkspaceDirs = [];
 	for (const key of keys) {
-		const r = await reclaimProject(key, {
-			deleteOwnedDevices: true,
-			parkOwnedDevices: true,
-			preserveProjectRecord: preserveRootProject && key === rootPath
-		});
+		let r;
+		try {
+			r = await reclaimProject(key, {
+				deleteOwnedDevices: true,
+				parkOwnedDevices: true,
+				preserveProjectRecord: preserveRootProject && key === rootPath
+			});
+		} catch (error) {
+			keptEntries.push(key);
+			retainedResources.push({
+				name: "ownership state",
+				reason: String(error?.message || error),
+				project: key
+			});
+			continue;
+		}
 		dereferenced.push(...r.dereferenced);
 		if (r.killedPid) killedPids.push(r.killedPid);
 		deletedDevices.push(...r.deletedDevices);
@@ -1116,30 +1631,32 @@ function removalPath(target) {
 	return canonicalExistingPath(target ?? process.cwd());
 }
 function canonicalExistingPath(target) {
-	const resolved = resolve$1(target);
+	const resolved = resolve(target);
 	let existing = resolved;
 	const missing = [];
 	while (!existsSync$1(existing)) {
-		const parent = dirname$1(existing);
+		const parent = dirname(existing);
 		if (parent === existing) return resolved;
-		missing.unshift(basename$1(existing));
+		missing.unshift(basename(existing));
 		existing = parent;
 	}
-	return resolve$1(realpathSync$1(existing), ...missing);
+	return resolve(realpathSync$1(existing), ...missing);
 }
 function inspectRemoval(path) {
 	const gitAnswered = hasUncommittedWork(path);
 	const { lines: dirtyLines, restore: podChurn } = excludePodChurn(gitAnswered ? dirtyPaths(path, { limit: Infinity }) : []);
 	const dirty = gitAnswered === null ? null : dirtyLines.length > 0;
 	const unpushed = unpushedCommits(path);
+	const blockers = removalBlockers({
+		dirty,
+		unpushed
+	});
+	if (hasPopulatedSubmodules(path)) blockers.push("initialized submodules, which git removes only with --force");
 	return {
 		dirtyLines,
 		podChurn,
 		unpushed,
-		blockers: removalBlockers({
-			dirty,
-			unpushed
-		})
+		blockers
 	};
 }
 function printRemovalRefusal(path, inspection) {
@@ -1171,7 +1688,14 @@ function printRemovalCleanup(result, failed) {
 	if (result.dereferenced.length) console.error(chalk.dim(phaseLine("workspace", `no longer referenced: ${result.dereferenced.join(", ")}`)));
 	for (const skipped of result.skippedDevices) console.error((failed ? chalk.dim : chalk.yellow)(phaseLine("device", `kept ${describeKeptDevice(skipped)} (${skipped.reason})`)));
 }
-async function runRemove(target, opts = {}) {
+async function removeWorktreeTarget(target, opts = {}) {
+	let removed = false;
+	await runRemove(target, opts, () => {
+		removed = true;
+	});
+	return removed;
+}
+async function runRemove(target, opts, onRemoved) {
 	const poolError = parkedMaxSetting("ios").error || parkedMaxSetting("android").error;
 	if (poolError) {
 		console.error(chalk.red(poolError));
@@ -1196,7 +1720,7 @@ async function runRemove(target, opts = {}) {
 				console.error(chalk.dim(phaseLine("branch", `${branch} is already absent; cleared its pending cleanup record`)));
 				return;
 			}
-			const checkedOutAt = listWorktrees(mainRoot).find((candidate) => candidate.branch === branch && resolve$1(candidate.path) !== resolve$1(path))?.path;
+			const checkedOutAt = listWorktrees(mainRoot).find((candidate) => candidate.branch === branch && resolve(candidate.path) !== resolve(path))?.path;
 			if (checkedOutAt) {
 				console.error(chalk.red(`Refusing pending cleanup for ${branch}: it is checked out at ${checkedOutAt}.`));
 				console.error(chalk.dim("Switch that worktree to another branch, then retry this command."));
@@ -1228,7 +1752,7 @@ async function runRemove(target, opts = {}) {
 	const worktrees = listWorktrees(path);
 	const entry = matchWorktreeEntry(worktrees, path);
 	if (!entry) {
-		if (gitCommonDir(path) === null && hasRegisteredProjectUnder(path)) {
+		if (!opts.linkedOnly && gitCommonDir(path) === null && hasRegisteredProjectUnder(path)) {
 			await reclaimEnvironment(path, "it is not a git repository");
 			return;
 		}
@@ -1249,6 +1773,11 @@ async function runRemove(target, opts = {}) {
 		process.exitCode = 1;
 		return;
 	}
+	if (entry.path === source.path && opts.linkedOnly) {
+		console.error(chalk.red(`Refusing to remove ${path}: ${entry.path} is the source checkout.`));
+		process.exitCode = 1;
+		return;
+	}
 	if (entry.path === source.path) {
 		if (entry.path !== path) console.error(chalk.dim(`${path} is inside the source checkout ${entry.path}; reclaiming its environment.`));
 		await reclaimEnvironment(entry.path, "it is the source checkout");
@@ -1258,6 +1787,12 @@ async function runRemove(target, opts = {}) {
 		console.error(chalk.dim(`${path} is inside the worktree ${entry.path}; removing that.`));
 		path = entry.path;
 	}
+	if (entry.locked) {
+		console.error(chalk.red(`Refusing to remove ${path}: git has it locked.`));
+		console.error(chalk.dim(`Unlock it, then retry: git -C ${source.path} worktree unlock ${path}`));
+		process.exitCode = 1;
+		return;
+	}
 	const project = getProject(path);
 	const branch = entry.branch;
 	const ownsBranch = Boolean(branch && project?.worktreeBranchOwned === true && project.worktreeBranch === branch);
@@ -1271,12 +1806,18 @@ async function runRemove(target, opts = {}) {
 	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;
 	await withManagedRemoteWorktreeRemovalLock(path, () => withReclaimLocks(path, async (lockedKeys) => {
+		if (opts.guard?.(lockedKeys).length) return;
+		const current = inspectRemoval(path);
+		if (current.blockers.length && !opts.force) {
+			printRemovalRefusal(path, current);
+			return;
+		}
 		const result = await reclaimAll(path, lockedKeys, { preserveRootProject: true });
 		if (result.keptEntries.length) {
 			reportRetainedResources(path, result);
 			return;
 		}
-		restorePodChurn(path, inspection.podChurn);
+		restorePodChurn(path, current.podChurn);
 		try {
 			removeWorktree(path, {
 				from: source.path,
@@ -1291,6 +1832,7 @@ async function runRemove(target, opts = {}) {
 			process.exitCode = 1;
 			return;
 		}
+		onRemoved();
 		const finish = () => {
 			printRemovalCleanup(result, false);
 			console.error(chalk.dim(phaseLine("removed", path)));
@@ -1306,7 +1848,7 @@ async function runRemove(target, opts = {}) {
 				worktreeRemovalComplete: true,
 				worktreePendingBranchSha: approvedBranchSha
 			});
-			const checkedOutAt = listWorktrees(branchDeleteCwd).find((candidate) => candidate.branch === branch && resolve$1(candidate.path) !== resolve$1(path))?.path;
+			const checkedOutAt = listWorktrees(branchDeleteCwd).find((candidate) => candidate.branch === branch && resolve(candidate.path) !== resolve(path))?.path;
 			if (checkedOutAt) {
 				console.error(chalk.yellow(phaseLine("branch", `kept ${branch} (it is checked out at ${checkedOutAt})`)));
 				console.error(chalk.dim(`  Switch that worktree to another branch, then retry: stim worktree remove ${path}`));
@@ -1330,7 +1872,9 @@ async function runRemove(target, opts = {}) {
 	}));
 }
 function registerRemove(worktree) {
-	worktree.command("remove [target]").description("Remove a worktree, its unused Stim-created branch, build artifacts, owned devices, and Metro port. Defaults to the current workspace. On the source checkout it reclaims the environment only and leaves the tree in place.").option("--force", "remove even when the worktree holds uncommitted or unpushed work").action(runRemove);
+	worktree.command("remove [target]").description("Remove a worktree, its unused Stim-created branch, build artifacts, owned devices, and Metro port. Defaults to the current workspace. On the source checkout it reclaims the environment only and leaves the tree in place.").option("--force", "remove even when the worktree holds uncommitted or unpushed work or initialized submodules").action(async (target, opts) => {
+		await removeWorktreeTarget(target, { force: opts.force });
+	});
 }
 function worktreeCommand(program) {
 	const worktree = program.command("worktree").description("Warm and remove Git worktrees");
@@ -1338,4 +1882,4 @@ function worktreeCommand(program) {
 	registerRemove(worktree);
 }
 //#endregion
-export { worktreeCommand as default, dependencyInstallCommand, excludePodChurn, matchWorktreeEntry, porcelainPath, registerRemove, registerWarm, removalBlockers, removalPath, removalRemedy };
+export { workspaceInUse as _, reclaimKeys as a, removalBlockers as c, removeWorktreeTarget as d, worktreeCommand as f, withIdleWorkspace as g, emptyWorkspaceDir as h, porcelainPath as i, removalPath as l, reclaimProject as m, excludePodChurn as n, registerRemove as o, describeDereferenced as p, matchWorktreeEntry as r, registerWarm as s, dependencyInstallCommand as t, removalRemedy as u, canonicalPath as v };