stim 1.21.0 → 1.22.0

package/dist/{start-7lpH7hmN.mjs → start-EojN4WFz.mjs}

@@ -1,19 +1,19 @@
-import { p as process_identity_exports, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { a as workspaceProcessLockError, g as process_identity_exports, h as withDrainingCancellation, i as withWorkspaceProcessLock, r as WorkspaceProcessCleanupError, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
 import { l as workspaceAgentDeviceDir, m as workspaceLogsDir$1, n as ensureWorkspaceStorage, s as supervisorLogFile } from "./paths-DQtTgsBf.mjs";
-import { E as upsertProject, p as getProject } from "./config-CYcBF478.mjs";
-import { _ as stepTimer, l as phaseLine } from "./command-output-B1UrjZHL.mjs";
-import { d as writeWorkspaceState, i as recordWorkspaceUse, n as clearWorkspaceStateKeys, r as readWorkspaceState$1 } from "./workspace-state-Cjuigeeu.mjs";
-import { A as metroIdleStopMinutesSetting, G as resolveCacheProviderConfig, J as resolveProjectSettingsAsync, K as resolveIosProjectDir, M as metroTunnelSettingError, O as metroCommandSetting, P as ngrokUrlSetting, Qt as cancellableSleep, R as publicUrlSetting, U as remoteIosSetting, V as remoteAndroidSetting, W as resolveAndroidLayout, a as SETTING_SHAPE_REMEDY, ct as detectProviders, en as throwIfCancelled, et as settingShapeErrors, h as deviceIdleShutdownMinutesSetting, it as unknownSettingKeys, j as metroPortSetting, k as metroCommandSettingError, lt as planMetroReach, m as defaultAndroidLayout, p as cacheProviderSettingError, rt as tunnelModeSetting, st as PUBLIC_METRO_ENV } from "./settings-CsJDEXgK.mjs";
-import { E as MODE_EXPO, M as readMetroTunnel, O as clearManagedMetroTunnel, S as readAppJson, T as MODE_COMMAND, c as projectProblem, i as findProjectRoot$1, t as NO_PROJECT_REFUSAL, v as detectIsExpo, w as MODE_BARE, x as readAppConfigText } from "./project-BZNjmW_8.mjs";
+import { E as upsertProject, O as withConfigLockAsync$1, p as getProject } from "./config-DlrsduwG.mjs";
+import { _ as stepTimer, l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { f as throwIfCancelled, u as cancellableSleep } from "./operation-exec-BW0em61G.mjs";
+import { i as recordWorkspaceUse, l as withWorkspaceStateLockAsync, n as clearWorkspaceStateKeys, r as readWorkspaceState$1, s as updateWorkspaceStateAsync } from "./workspace-state-U08dEzhG.mjs";
+import { A as metroIdleStopMinutesSetting, G as resolveCacheProviderConfig, J as resolveProjectSettingsAsync, K as resolveIosProjectDir, M as metroTunnelSettingError, O as metroCommandSetting, P as ngrokUrlSetting, R as publicUrlSetting, U as remoteIosSetting, V as remoteAndroidSetting, W as resolveAndroidLayout, a as SETTING_SHAPE_REMEDY, ct as detectProviders, et as settingShapeErrors, h as deviceIdleShutdownMinutesSetting, it as unknownSettingKeys, j as metroPortSetting, k as metroCommandSettingError, lt as planMetroReach, m as defaultAndroidLayout, p as cacheProviderSettingError, rt as tunnelModeSetting, st as PUBLIC_METRO_ENV } from "./settings-C7O8A6ZI.mjs";
+import { E as MODE_EXPO, M as readMetroTunnel, O as clearManagedMetroTunnel, S as readAppJson, T as MODE_COMMAND, c as projectProblem, i as findProjectRoot$1, t as NO_PROJECT_REFUSAL, v as detectIsExpo, w as MODE_BARE, x as readAppConfigText } from "./project-wM_XFTvE.mjs";
 import { i as levelRank } from "./ndjson-CgE_o3Dl.mjs";
-import { _ as reserveMetroPort, d as processCwds, f as resolveProjectMetro, g as isMetroRunning, l as pidExists, o as listeningPidsAsync, p as signalProcessTree, v as PORT_INSPECTION_REMEDY, y as PortInspectionError } from "./metro-DEXpIhHC.mjs";
-import { Kn as readProjectConfig, p as stopOwnedMetroForReset, t as budgetGate } from "./budget-Bs6SxxzO.mjs";
-import { _ as terminateChild, b as withManagedTunnelLock, g as stopTunnel, h as startTunnelSequence, m as resolveSupervisorTarget, v as withManagedRemoteWorktreeLock } from "./workspaces-BccMFmGQ.mjs";
-import { a as workspaceLinkLine, o as workspaceLinks } from "./stim-desktop-C12we7lz.mjs";
-import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-1_1OoVW5.mjs";
+import { _ as PORT_INSPECTION_REMEDY, a as listeningPidsAsync, c as pidExists, d as resolveProjectMetro, f as signalProcessTree, g as reserveMetroPort, h as isMetroRunning, u as processCwds, v as PortInspectionError } from "./metro-DiXtA3Ty.mjs";
+import { In as runProcessOperation, Kn as readProjectConfig, Pn as exitAfterFlush, Zn as remoteCliInvocation, p as stopOwnedMetroForReset, t as budgetGate } from "./budget-Cvwn54qV.mjs";
+import { _ as stopTunnel, g as startTunnelSequence, h as resolveSupervisorTarget, v as terminateChild, x as withManagedTunnelLock, y as withManagedRemoteWorktreeLock } from "./workspaces-CpANmBlq.mjs";
+import { a as workspaceLinkLine, o as workspaceLinks } from "./stim-desktop-D5OGpYZM.mjs";
 import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-DFRyG1_o.mjs";
-import { appendFileSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { n as windowsLauncherArgs } from "./detached-entry-BwNEtIrP.mjs";
+import { appendFileSync, closeSync, mkdirSync, openSync, readFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { ambientContext, ambientEnv } from "@stim-cli/core";
 import { IDLE_STOP_KEY, queryLogs } from "@stim-cli/core/state";
@@ -42,8 +42,8 @@ function configString(config, platform, key) {
 function literalString(text, key) {
 	return text?.match(new RegExp(`${key}\\s*:\\s*["']([^"']+)["']`))?.[1] ?? null;
 }
-async function idsFromConfig(projectRoot) {
-	const read = await readProjectConfig(projectRoot);
+async function idsFromConfig(projectRoot, options) {
+	const read = await readProjectConfig(projectRoot, options);
 	if (!read.unavailable) return {
 		bundleId: configString(read.config, "ios", "bundleIdentifier"),
 		androidPackage: configString(read.config, "android", "package")
@@ -55,8 +55,8 @@ async function idsFromConfig(projectRoot) {
 		androidPackage: configString(appJson, "android", "package") ?? literalString(text, "package")
 	};
 }
-async function detectAppIds(projectRoot, iosDir = join$1(projectRoot, "ios"), androidModuleDir = defaultAndroidLayout(projectRoot).moduleDir) {
-	const ids = await idsFromConfig(projectRoot);
+async function detectAppIds(projectRoot, iosDir = join$1(projectRoot, "ios"), androidModuleDir = defaultAndroidLayout(projectRoot).moduleDir, config = {}) {
+	const ids = await idsFromConfig(projectRoot, config);
 	const problems = [];
 	const accept = androidPackageFilter(problems);
 	return {
@@ -127,8 +127,8 @@ async function resolveStartupMetro(port, root) {
 	const signal = ambientContext()?.signal;
 	throwIfCancelled(signal, "Metro startup");
 	const result = await resolveProjectMetro(port, root, {
-		pidsOf: listeningPidsAsync,
-		cwdOf: async (pid) => (await processCwds([pid])).get(pid) ?? null,
+		pidsOf: (candidate) => listeningPidsAsync(candidate, process.platform, signal),
+		cwdOf: async (pid) => (await processCwds([pid], signal)).get(pid) ?? null,
 		probe: (candidate) => isMetroRunning(candidate, signal)
 	});
 	throwIfCancelled(signal, "Metro startup");
@@ -227,20 +227,33 @@ function providersOnPath(mode) {
 const DEFAULT_START_DEPS = {
 	providers: providersOnPath,
 	startTunnelSequence,
-	isTunnelAlive: pidExists,
-	writeTunnelRecord: writeWorkspaceState,
+	isTunnelAlive: (pid, processToken) => processToken === void 0 ? pidExists(pid) : (0, process_identity_exports.inspectProcessIdentity)({
+		pid,
+		processToken
+	}) === "same",
+	writeTunnelRecord: (root, patch) => updateWorkspaceStateAsync(root, (state) => ({
+		...state,
+		...patch
+	})),
 	stopTunnel,
-	writeSupervisorRecord: writeWorkspaceState,
-	terminateSupervisorChild: (child) => terminateChild(child, {
-		alreadyExited: false,
-		timeoutMs: 1e3,
-		now: Date.now,
-		sleep: cancellableSleep,
-		isAlive: pidExists
-	}),
+	writeSupervisorRecord: (root, patch) => updateWorkspaceStateAsync(root, (state) => ({
+		...state,
+		...patch
+	})),
+	terminateSupervisorChild: async (child) => {
+		if (child.pid && process.platform !== "win32") try {
+			signalProcessTree(child.pid, "SIGTERM", { group: true });
+		} catch {}
+		return terminateChild(child, {
+			alreadyExited: false,
+			timeoutMs: 1e3,
+			isAlive: pidExists,
+			waitForGroup: process.platform !== "win32"
+		});
+	},
 	withWorktreeLock: withManagedRemoteWorktreeLock,
 	withTunnelLock: withManagedTunnelLock,
-	clearTunnelRecord: clearManagedMetroTunnel,
+	clearTunnelRecord: (root, record) => withWorkspaceStateLockAsync(root, () => clearManagedMetroTunnel(root, record)),
 	budgetGate,
 	platform: process.platform
 };
@@ -259,7 +272,7 @@ function registerStart(program, overrides = {}) {
 			else console.log(line);
 		};
 		const note = writeNote;
-		const fail = ({ code, message, remedy = null, lines = [], reclaimed = [] }) => {
+		const fail = ({ code, message, remedy = null, lines = [], reclaimed = [], exitCode = 1 }) => {
 			note(chalk.red(message));
 			for (const line of lines) note(chalk.dim(`  ${line}`));
 			if (remedy) note(chalk.dim(remedy));
@@ -272,7 +285,7 @@ function registerStart(program, overrides = {}) {
 				}),
 				...reclaimed.length ? { reclaimed } : {}
 			}));
-			process.exit(1);
+			process.exit(exitCode);
 		};
 		const wait = parseWait(opts.wait);
 		if (wait.error) return fail({
@@ -310,20 +323,36 @@ function registerStart(program, overrides = {}) {
 		for (const key of unknownSettingKeys(settings)) note(chalk.yellow(`Warning: setting "${key}" is not read by Stim and will be ignored.`));
 		const cacheProviderError = cacheProviderSettingError(settings);
 		if (cacheProviderError) note(chalk.yellow(`Warning: ${cacheProviderError} No cache provider is used.`));
-		const result = await startDevServer({
-			root,
-			settings,
-			settingsContext,
-			waitSeconds,
-			remote: Boolean(opts.remote),
-			resetCache: Boolean(opts.resetCache),
-			out,
-			note
-		}, d);
+		const { value: result, interrupted } = await runProcessOperation(root, (context) => withDrainingCancellation(context, context.signal, async () => {
+			try {
+				return await startDevServer({
+					root,
+					settings,
+					settingsContext,
+					waitSeconds,
+					remote: Boolean(opts.remote),
+					resetCache: Boolean(opts.resetCache),
+					out,
+					note
+				}, d);
+			} catch (error) {
+				if (!(error instanceof Error) || !("code" in error) || error.code !== "STIM_CANCELLED") throw error;
+				return {
+					ok: false,
+					error: startError({
+						code: "STIM_CANCELLED",
+						message: error.message
+					}),
+					lines: [],
+					reclaimed: []
+				};
+			}
+		}));
 		if (!result.ok) return fail({
 			...result.error,
 			lines: result.lines,
-			reclaimed: result.reclaimed
+			reclaimed: result.reclaimed,
+			exitCode: interrupted ?? 1
 		});
 		report({
 			json,
@@ -333,6 +362,7 @@ function registerStart(program, overrides = {}) {
 			reclaimed: result.reclaimed,
 			links: await workspaceLinks(root)
 		});
+		if (interrupted !== null) exitAfterFlush(interrupted);
 	});
 }
 var StartRefusal = class extends Error {
@@ -347,6 +377,8 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 		...DEFAULT_START_DEPS,
 		...overrides
 	};
+	const operationSignal = ambientContext()?.signal;
+	throwIfCancelled(operationSignal, "Metro startup");
 	const waitTimer = stepTimer();
 	let reclaimed = [];
 	const fail = (refusal) => {
@@ -392,18 +424,63 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 		});
 		if (tunnel) note(chalk.dim("note   requesting an Expo tunnel for this workspace's dev server"));
 		const managedRemote = remote && !tunnel && !publicUrl && tunnelMode !== "off";
-		const runStart = async () => {
-			const appIds = await detectAppIds(root, resolveIosProjectDir(settings, root).dir, resolveAndroidLayout(settings, root, settingsContext.repoRoot ?? root).moduleDir);
-			upsertProject(root, {
-				bundleId: appIds.bundleId ?? void 0,
-				androidPackage: appIds.androidPackage ?? void 0,
-				isExpo
+		const runStart = async (claim, tunnelClaim) => {
+			const claims = [claim, tunnelClaim];
+			const appIds = await detectAppIds(root, resolveIosProjectDir(settings, root).dir, resolveAndroidLayout(settings, root, settingsContext.repoRoot ?? root).moduleDir, {
+				context: ambientContext(),
+				run: async (file, args, options) => {
+					for (const held of claims) (0, ownership_claim_exports.markClaimChildPending)(held);
+					let child;
+					let identity;
+					let output = "";
+					let failure;
+					try {
+						const invocation = remoteCliInvocation(file, args, "expo");
+						output = await getExecutor().runFileAsync(invocation.file, invocation.args, {
+							...options,
+							cwd: root,
+							containProcessTree: true,
+							signal: operationSignal ?? new AbortController().signal,
+							onSpawn: (spawned) => {
+								child = spawned;
+								if (!spawned.pid) return;
+								const processToken = (0, process_identity_exports.captureProcessToken)(spawned.pid);
+								if (!processToken) throw new Error("Cannot record the Expo config process identity.");
+								identity = {
+									pid: spawned.pid,
+									processToken
+								};
+								for (const held of claims) (0, ownership_claim_exports.setClaimChild)(held, identity);
+							}
+						});
+					} catch (error) {
+						failure = { error };
+					}
+					const pid = child?.pid;
+					if (pid) {
+						const alive = () => d.platform === "win32" ? !identity || (0, process_identity_exports.inspectProcessIdentity)(identity) !== "gone" : (0, ownership_claim_exports.processGroupAlive)(pid);
+						const deadline = Date.now() + 1e3;
+						while (alive() && Date.now() < deadline) await cancellableSleep(25);
+						if (alive()) throw new WorkspaceProcessCleanupError(claims, `Could not confirm cleanup of Expo config process ${pid}.`, "Inspect and stop the Expo config process and its helpers before retrying.");
+					}
+					for (const held of claims) (0, ownership_claim_exports.clearClaimChild)(held);
+					if (failure) throw failure.error;
+					return output;
+				}
 			});
+			await withConfigLockAsync$1(() => {
+				upsertProject(root, {
+					bundleId: appIds.bundleId ?? void 0,
+					androidPackage: appIds.androidPackage ?? void 0,
+					isExpo
+				});
+			}, operationSignal);
 			const gateBudget = async () => {
 				const budget = await d.budgetGate({
 					root,
 					note,
-					env: ambientEnv()
+					env: ambientEnv(),
+					signal: operationSignal
 				});
 				reclaimed = budget.reclaimed;
 				if (budget.refusal) return fail(budget.refusal);
@@ -416,7 +493,7 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 					if (typeof pinCheck !== "number") return fail(pinCheck);
 				}
 				try {
-					await stopOwnedMetroForReset(root);
+					await stopOwnedMetroForReset(root, operationSignal);
 				} catch (error) {
 					const failure = error;
 					return fail({
@@ -449,21 +526,44 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 			});
 			if (!resetCache && !resolution.metro && !supervisor) await gateBudget();
 			let managedTunnel = null;
-			let spawnedChild = null;
+			const spawned = { child: null };
 			let spawnedTs = null;
 			let childExit = null;
+			let spawnedIdentity = null;
+			let unknownWindowsSpawn = false;
+			let windowsLauncher = null;
+			let tunnelPending = null;
+			const handedOffSupervisor = () => {
+				if (!spawnedIdentity) return null;
+				const target = resolveSupervisorTarget({
+					state: readWorkspaceState$1(root)?.supervisor,
+					record: getProject(root)?.supervisor,
+					reservedPort: port
+				});
+				return target.status === "ours" && typeof target.pid === "number" && target.pid === spawnedIdentity.pid && target.processToken === spawnedIdentity.processToken && target.port === port ? {
+					pid: target.pid,
+					port,
+					mode: target.mode ?? null,
+					startedAt: target.startedAt ?? null
+				} : null;
+			};
 			const spawnDirect = (supervisorArgs, childEnv) => {
 				const fd = openSync(logFile, "a");
-				const child = getExecutor().spawn(process.execPath, supervisorArgs, {
-					cwd: root,
-					detached: true,
-					stdio: [
-						"ignore",
-						fd,
-						fd
-					],
-					env: childEnv
-				});
+				let child;
+				try {
+					child = getExecutor().spawn(process.execPath, supervisorArgs, {
+						cwd: root,
+						detached: true,
+						stdio: [
+							"ignore",
+							fd,
+							fd
+						],
+						env: childEnv
+					});
+				} finally {
+					closeSync(fd);
+				}
 				child.unref?.();
 				child.on?.("exit", (code, signal) => {
 					childExit = {
@@ -480,8 +580,8 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 				});
 				return child;
 			};
-			const recordedSupervisor = async (since) => {
-				const deadline = Date.now() + RECORDED_SUPERVISOR_WAIT_MS;
+			const recordedSupervisor = async (since, waitMs = RECORDED_SUPERVISOR_WAIT_MS) => {
+				const deadline = Date.now() + waitMs;
 				while (Date.now() < deadline) {
 					const record = readWorkspaceState$1(root)?.supervisor;
 					if (record?.pid && record.port === port && Date.parse(String(record.startedAt)) >= since && pidExists(record.pid)) return {
@@ -514,21 +614,48 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 					},
 					windowsHide: true
 				});
+				const launch = {
+					child: shell,
+					since,
+					closed: false
+				};
+				windowsLauncher = launch;
+				unknownWindowsSpawn = shell.pid !== void 0;
 				const stderr = [];
 				shell.stderr?.on("data", (chunk) => stderr.push(String(chunk)));
-				const exit = await new Promise((resolve) => {
-					shell.on?.("close", (code, signal) => resolve({
-						code,
-						signal
-					}));
-					shell.on?.("error", (error) => resolve({
+				const closed = new Promise((resolve) => {
+					shell.once("close", (code, signal) => {
+						launch.closed = true;
+						resolve({
+							code,
+							signal
+						});
+					});
+					shell.once("error", (error) => resolve({
 						code: null,
 						signal: null,
 						error
 					}));
 				});
+				const waiting = new AbortController();
+				const signal = operationSignal ? AbortSignal.any([operationSignal, waiting.signal]) : waiting.signal;
+				let exit;
+				try {
+					exit = await Promise.race([closed, cancellableSleep(Math.min(RECORDED_SUPERVISOR_WAIT_MS, waitSeconds * 1e3), {
+						signal,
+						what: "Windows supervisor launcher"
+					}).then(() => fail({
+						code: "STIM_METRO_TIMEOUT",
+						message: "The Windows supervisor launcher did not finish before the startup deadline.",
+						remedy: "Inspect the launcher and supervisor before retrying."
+					}))]);
+				} finally {
+					waiting.abort();
+				}
 				const launcherFailed = exit.code !== 0 || exit.error;
+				unknownWindowsSpawn = !launcherFailed;
 				const recorded = launcherFailed ? null : await recordedSupervisor(since);
+				if (recorded) unknownWindowsSpawn = false;
 				if (recorded === null) {
 					const reason = launcherFailed ? `the supervisor launcher exited (${exit.error ? exit.error.message : `code ${exit.code}`})` : `the supervisor did not record itself within ${RECORDED_SUPERVISOR_WAIT_MS / 1e3}s`;
 					appendFileSync(logFile, `Stim start: ${reason}.\n${stderr.join("")}`);
@@ -538,6 +665,7 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 						...exit.error ? { error: exit.error } : {}
 					};
 				}
+				windowsLauncher = null;
 				return recordedSupervisorProcess(recorded);
 			};
 			const spawnSupervisor = async (origin) => {
@@ -564,404 +692,497 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 					} : {}
 				};
 				childEnv[CACHE_PROVIDER_ENV] = cacheProviderEnv(cacheProvider);
+				for (const held of claims) (0, ownership_claim_exports.markClaimChildPending)(held);
 				const child = d.platform === "win32" ? await spawnThroughWindowsShell(supervisorArgs, childEnv) : spawnDirect(supervisorArgs, childEnv);
+				spawned.child = child;
+				if (child.pid) {
+					const processToken = child.recordedIdentity?.processToken ?? (0, process_identity_exports.captureProcessToken)(child.pid);
+					if (processToken) {
+						spawnedIdentity = {
+							pid: child.pid,
+							processToken
+						};
+						for (const held of claims) (0, ownership_claim_exports.setClaimChild)(held, spawnedIdentity);
+					}
+				}
 				out(chalk.dim(phaseLine("metro", `starting on port ${port} (${serverMode}, supervisor pid ${child.pid})`)));
-				spawnedChild = child;
 				return child;
 			};
 			const waitForSupervisorHandoff = async (child) => {
 				const deadline = Date.now() + 5e3;
 				while (Date.now() < deadline) {
-					const found = liveSupervisor({
-						state: readWorkspaceState$1(root),
-						project: getProject(root),
-						port
-					});
-					if (found?.pid === child.pid) return found;
+					const found = handedOffSupervisor();
+					if (found) return found;
 					if (childExit !== null || (child.pid ? !pidExists(child.pid) : true)) return null;
 					await cancellableSleep(25);
 				}
 				return null;
 			};
-			if (remote && !tunnel && !publicUrl && tunnelMode !== "off") {
-				const available = d.providers(tunnelMode);
-				const plan = planMetroReach({
-					mode: tunnelMode,
-					metroPort: port,
-					publicUrl,
-					isExpo: expoServer,
-					available
-				});
-				if ("failed" in plan) return fail({
-					code: "STIM_REMOTE_METRO_UNREACHABLE",
-					message: plan.failed,
-					remedy: plan.remedy
-				});
-				if ("start" in plan) {
-					const candidates = tunnelMode === "auto" ? available.filter((provider) => provider !== "tailscale") : [plan.start];
-					const expectedStableUrl = ngrokUrlSetting(settings);
-					let acquisition;
-					try {
-						acquisition = await d.withTunnelLock(root, async () => {
-							let tracking;
-							let startedCleanup = null;
-							const recorded = readMetroTunnel(root);
-							if (recorded?.kind === "managed" && d.isTunnelAlive(recorded.pid)) {
-								if (!recorded.processToken) return { failed: {
-									code: "STIM_REMOTE_START_REQUIRED",
-									message: "The recorded managed Metro tunnel has no process identity token.",
-									remedy: "Inspect the process, stop it with the provider tooling, remove the stale metroTunnel state, and retry."
-								} };
-								if (!(recorded.port === port && candidates.includes(recorded.provider) && (!expectedStableUrl || normalizeManagedTunnelUrl(recorded.url) === expectedStableUrl))) return { failed: {
-									code: "STIM_REMOTE_START_REQUIRED",
-									message: `A different managed Metro tunnel is already running for this workspace.`,
-									remedy: "Run `stim stop`, then `stim start --remote`."
-								} };
-								tracking = {
-									record: {
-										provider: recorded.provider,
-										pid: recorded.pid,
-										url: normalizeManagedTunnelUrl(recorded.url),
-										port: recorded.port,
-										startedAt: recorded.startedAt,
-										processToken: recorded.processToken,
-										logFile: recorded.logFile
-									},
-									startedHere: false
-								};
-							} else {
+			const reconcileSpawnedSupervisor = async () => {
+				try {
+					const launch = windowsLauncher;
+					if (launch) {
+						if (!await terminateChild(launch.child, {
+							alreadyExited: launch.closed || launch.child.exitCode !== null || launch.child.signalCode !== null,
+							timeoutMs: 1e3,
+							isAlive: pidExists
+						})) throw new WorkspaceProcessCleanupError(claims, `Could not confirm cleanup of Windows supervisor launcher pid ${launch.child.pid}.`, "Inspect and stop the launcher and its supervisor with their original tooling before retrying.");
+						if (unknownWindowsSpawn) {
+							const recorded = await recordedSupervisor(launch.since, 1e3);
+							if (recorded) {
+								spawned.child = recordedSupervisorProcess(recorded);
+								spawnedIdentity = recorded;
+								for (const held of claims) (0, ownership_claim_exports.setClaimChild)(held, recorded);
+								unknownWindowsSpawn = false;
+							}
+						}
+						windowsLauncher = null;
+					}
+					const child = spawned.child;
+					if (tunnelPending) throw tunnelPending;
+					if (child?.pid && !handedOffSupervisor()) {
+						const hasPublishedSupervisor = () => {
+							const identity = spawnedIdentity;
+							return identity !== null && [readWorkspaceState$1(root)?.supervisor, getProject(root)?.supervisor].some((record) => record?.pid === identity.pid && record?.processToken === identity.processToken);
+						};
+						if (hasPublishedSupervisor()) {
+							for (const held of claims) (0, ownership_claim_exports.markClaimChildPending)(held);
+							throw new WorkspaceProcessCleanupError(claims, `Supervisor pid ${child.pid} published ownership that cannot be reconciled with the workspace registry.`, "Inspect the supervisor and its dev server, then stop them with their original tooling before retrying.");
+						}
+						const same = spawnedIdentity && (0, process_identity_exports.inspectProcessIdentity)(spawnedIdentity) === "same";
+						const supervisorCleanup = childExit !== null && !(0, ownership_claim_exports.processGroupAlive)(child.pid) || Boolean(same && supervisorSignalable(child) && await d.terminateSupervisorChild(child));
+						const publicationRacedCleanup = hasPublishedSupervisor();
+						if (!supervisorCleanup || d.platform !== "win32" && (0, ownership_claim_exports.processGroupAlive)(child.pid) || publicationRacedCleanup) {
+							if (publicationRacedCleanup) for (const held of claims) (0, ownership_claim_exports.markClaimChildPending)(held);
+							throw new WorkspaceProcessCleanupError(claims, `Could not confirm cleanup of supervisor pid ${child.pid}.`, `Stop supervisor pid ${child.pid} with its original tooling before retrying.`);
+						}
+						for (const held of claims) (0, ownership_claim_exports.clearClaimChild)(held);
+					} else if (unknownWindowsSpawn) throw new WorkspaceProcessCleanupError(claims, "The Windows launcher started a supervisor but its identity was not recorded.", "Inspect and stop it with its original tooling before retrying.");
+				} catch (cause) {
+					if (cause instanceof WorkspaceProcessCleanupError) throw cause;
+					throw new WorkspaceProcessCleanupError(claims, `Could not reconcile supervisor ownership: ${cause.message}`, "Inspect and stop the supervisor with its original tooling before retrying.");
+				}
+			};
+			try {
+				if (remote && !tunnel && !publicUrl && tunnelMode !== "off") {
+					const available = d.providers(tunnelMode);
+					const plan = planMetroReach({
+						mode: tunnelMode,
+						metroPort: port,
+						publicUrl,
+						isExpo: expoServer,
+						available
+					});
+					if ("failed" in plan) return fail({
+						code: "STIM_REMOTE_METRO_UNREACHABLE",
+						message: plan.failed,
+						remedy: plan.remedy
+					});
+					if ("start" in plan) {
+						const candidates = tunnelMode === "auto" ? available.filter((provider) => provider !== "tailscale") : [plan.start];
+						const expectedStableUrl = ngrokUrlSetting(settings);
+						let acquisition;
+						try {
+							acquisition = await (async () => {
+								let tracking;
+								let startedCleanup = null;
+								const recorded = readMetroTunnel(root);
+								if (recorded?.kind === "managed" && d.isTunnelAlive(recorded.pid)) {
+									if (!recorded.processToken) return { failed: {
+										code: "STIM_REMOTE_START_REQUIRED",
+										message: "The recorded managed Metro tunnel has no process identity token.",
+										remedy: "Inspect the process, stop it with the provider tooling, remove the stale metroTunnel state, and retry."
+									} };
+									if (!d.isTunnelAlive(recorded.pid, recorded.processToken)) return { failed: {
+										code: "STIM_REMOTE_START_REQUIRED",
+										message: `The recorded ${recorded.provider} tunnel pid ${recorded.pid} no longer has its recorded process identity.`,
+										remedy: "Run `stim stop`, resolve any ownership refusal, then retry `stim start --remote`."
+									} };
+									if (!(recorded.port === port && candidates.includes(recorded.provider) && (!expectedStableUrl || normalizeManagedTunnelUrl(recorded.url) === expectedStableUrl))) return { failed: {
+										code: "STIM_REMOTE_START_REQUIRED",
+										message: `A different managed Metro tunnel is already running for this workspace.`,
+										remedy: "Run `stim stop`, then `stim start --remote`."
+									} };
+									tracking = {
+										record: {
+											provider: recorded.provider,
+											pid: recorded.pid,
+											url: normalizeManagedTunnelUrl(recorded.url),
+											port: recorded.port,
+											startedAt: recorded.startedAt,
+											processToken: recorded.processToken,
+											logFile: recorded.logFile
+										},
+										startedHere: false
+									};
+								} else {
+									const currentResolution = await resolveStartupMetro(port, root);
+									const currentSupervisor = liveSupervisor({
+										state: readWorkspaceState$1(root),
+										project: getProject(root),
+										port
+									});
+									if (currentResolution.metro || currentSupervisor) return { failed: {
+										code: "STIM_REMOTE_START_REQUIRED",
+										message: `The dev server on port ${port} is local-only and cannot gain a managed tunnel while it is running.`,
+										remedy: "Run `stim stop`, then `stim start --remote`."
+									} };
+									throwIfCancelled(operationSignal, "Metro tunnel startup");
+									for (const held of claims) (0, ownership_claim_exports.markClaimChildPending)(held);
+									tunnelPending = new WorkspaceProcessCleanupError(claims, "A new managed Metro tunnel could not be recorded or confirmed stopped.", "Inspect and stop the tunnel with its provider tooling before retrying.");
+									const started = await d.startTunnelSequence({
+										claims,
+										signal: operationSignal,
+										providers: candidates,
+										port,
+										ngrokUrl: expectedStableUrl,
+										requireReachable: false
+									});
+									if ("failed" in started) {
+										if (started.cleanupFailed) {
+											tunnelPending = new WorkspaceProcessCleanupError(claims, started.reason, "Stop the tunnel with its provider tooling before retrying.");
+											throw tunnelPending;
+										}
+										for (const held of claims) (0, ownership_claim_exports.clearClaimChild)(held);
+										tunnelPending = null;
+										throwIfCancelled(operationSignal, "Metro tunnel startup");
+										return { failed: {
+											code: "STIM_REMOTE_METRO_UNREACHABLE",
+											message: `Could not start a managed Metro tunnel for port ${port}.`,
+											remedy: started.reason
+										} };
+									}
+									for (const held of claims) (0, ownership_claim_exports.setClaimChild)(held, {
+										pid: started.pid,
+										processToken: started.processToken
+									});
+									const record = {
+										provider: started.provider,
+										pid: started.pid,
+										url: normalizeManagedTunnelUrl(started.url),
+										port,
+										startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+										processToken: started.processToken,
+										logFile: started.logFile
+									};
+									startedCleanup = started.cleanup;
+									try {
+										await d.writeTunnelRecord(root, { metroTunnel: {
+											kind: "managed",
+											...record
+										} });
+										const stored = readMetroTunnel(root);
+										if (stored?.kind !== "managed" || stored.pid !== record.pid || stored.processToken !== record.processToken || stored.port !== record.port || stored.provider !== record.provider || stored.url !== record.url) throw new Error("The workspace did not retain this tunnel ownership record.");
+										for (const held of claims) (0, ownership_claim_exports.clearClaimChild)(held);
+										tunnelPending = null;
+									} catch (err) {
+										const recordError = err instanceof Error ? err.message : String(err);
+										const stopped = await started.cleanup();
+										if (stopped.status === "stopped") {
+											for (const held of claims) (0, ownership_claim_exports.clearClaimChild)(held);
+											tunnelPending = null;
+										} else tunnelPending = new WorkspaceProcessCleanupError(claims, `Could not record the managed Metro tunnel: ${recordError}`, `Cleanup failed. Unmanaged pid ${record.pid} may still be running: ${stopped.reason ?? "unknown error"}`);
+										return { failed: {
+											code: "STIM_REMOTE_METRO_UNREACHABLE",
+											message: `Could not record the managed Metro tunnel: ${recordError}`,
+											remedy: stopped.status === "failed" ? `Cleanup failed. Unmanaged pid ${record.pid} may still be running: ${stopped.reason ?? "unknown error"}` : "The tunnel process was stopped. Fix the workspace write error, then retry `stim start --remote`."
+										} };
+									}
+									tracking = {
+										record,
+										startedHere: true
+									};
+								}
 								const currentResolution = await resolveStartupMetro(port, root);
 								const currentSupervisor = liveSupervisor({
 									state: readWorkspaceState$1(root),
 									project: getProject(root),
 									port
 								});
-								if (currentResolution.metro || currentSupervisor) return { failed: {
-									code: "STIM_REMOTE_START_REQUIRED",
-									message: `The dev server on port ${port} is local-only and cannot gain a managed tunnel while it is running.`,
-									remedy: "Run `stim stop`, then `stim start --remote`."
-								} };
-								const started = await d.startTunnelSequence({
-									providers: candidates,
-									port,
-									ngrokUrl: expectedStableUrl,
-									requireReachable: false
-								});
-								if ("failed" in started) return { failed: {
-									code: "STIM_REMOTE_METRO_UNREACHABLE",
-									message: `Could not start a managed Metro tunnel for port ${port}.`,
-									remedy: started.reason
-								} };
-								const record = {
-									provider: started.provider,
-									pid: started.pid,
-									url: normalizeManagedTunnelUrl(started.url),
-									port,
-									startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-									processToken: started.processToken,
-									logFile: started.logFile
-								};
-								startedCleanup = started.cleanup;
-								try {
-									d.writeTunnelRecord(root, { metroTunnel: {
-										kind: "managed",
-										...record
-									} });
-								} catch (err) {
-									const stopped = await started.cleanup();
+								if (currentResolution.metro || currentSupervisor) {
+									if (tracking.startedHere && startedCleanup) {
+										const stopped = await startedCleanup();
+										if (stopped.status === "failed") return { failed: {
+											code: "STIM_REMOTE_START_REQUIRED",
+											message: `The dev server on port ${port} started before the managed tunnel was ready.`,
+											remedy: `Tunnel cleanup failed for pid ${tracking.record.pid}: ${stopped.reason ?? "unknown error"}. The tunnel record remains available to \`stim stop\`.`
+										} };
+										await d.clearTunnelRecord(root, tracking.record);
+										return { failed: {
+											code: "STIM_REMOTE_START_REQUIRED",
+											message: `The dev server on port ${port} started before the managed tunnel was ready.`,
+											remedy: "Run `stim stop`, then `stim start --remote`."
+										} };
+									}
+									return {
+										origin: tracking.record.url,
+										tunnel: tracking
+									};
+								}
+								if (!d.isTunnelAlive(tracking.record.pid, tracking.record.processToken)) {
+									if (tracking.startedHere && startedCleanup) {
+										const stopped = await startedCleanup();
+										if (stopped.status === "failed") return { failed: {
+											code: "STIM_REMOTE_METRO_UNREACHABLE",
+											message: `The managed ${tracking.record.provider} tunnel is no longer verified running before supervisor startup.`,
+											remedy: `Cleanup failed. Unmanaged pid ${tracking.record.pid} may still be running: ${stopped.reason ?? "unknown error"}. The tunnel record remains available to \`stim stop\`.`
+										} };
+									}
+									await d.clearTunnelRecord(root, tracking.record);
 									return { failed: {
 										code: "STIM_REMOTE_METRO_UNREACHABLE",
-										message: `Could not record the managed Metro tunnel: ${err?.message || err}`,
-										remedy: stopped.status === "failed" ? `Cleanup failed. Unmanaged pid ${record.pid} may still be running: ${stopped.reason ?? "unknown error"}` : "The tunnel process was stopped. Fix the workspace write error, then retry `stim start --remote`."
+										message: `The managed ${tracking.record.provider} tunnel is no longer verified running before supervisor startup.`,
+										remedy: "Retry `stim start --remote`."
 									} };
 								}
-								tracking = {
-									record,
-									startedHere: true
-								};
-							}
-							const currentResolution = await resolveStartupMetro(port, root);
-							const currentSupervisor = liveSupervisor({
-								state: readWorkspaceState$1(root),
-								project: getProject(root),
-								port
-							});
-							if (currentResolution.metro || currentSupervisor) {
-								if (tracking.startedHere && startedCleanup) {
-									const stopped = await startedCleanup();
-									if (stopped.status === "failed") return { failed: {
-										code: "STIM_REMOTE_START_REQUIRED",
-										message: `The dev server on port ${port} started before the managed tunnel was ready.`,
-										remedy: `Tunnel cleanup failed for pid ${tracking.record.pid}: ${stopped.reason ?? "unknown error"}. The tunnel record remains available to \`stim stop\`.`
-									} };
-									d.clearTunnelRecord(root, tracking.record);
+								let child;
+								try {
+									child = await spawnSupervisor(tracking.record.url);
+								} catch (err) {
 									return { failed: {
-										code: "STIM_REMOTE_START_REQUIRED",
-										message: `The dev server on port ${port} started before the managed tunnel was ready.`,
-										remedy: "Run `stim stop`, then `stim start --remote`."
+										code: "STIM_SUPERVISOR_EXITED",
+										message: `Could not spawn the dev server supervisor: ${err?.message || err}`,
+										remedy: "Fix the spawn error, then retry `stim start --remote`."
 									} };
 								}
-								return {
-									origin: tracking.record.url,
-									tunnel: tracking
+								const handoffRecord = {
+									pid: child.pid,
+									processToken: child.recordedIdentity ? child.recordedIdentity.processToken ?? null : child.pid ? (0, process_identity_exports.captureProcessToken)(child.pid) : null,
+									port,
+									mode: serverMode,
+									startedAt: new Date(spawnedTs ?? Date.now()).toISOString()
 								};
-							}
-							if (!d.isTunnelAlive(tracking.record.pid)) {
-								if (tracking.startedHere && startedCleanup) {
-									const stopped = await startedCleanup();
-									if (stopped.status === "failed") return { failed: {
-										code: "STIM_REMOTE_METRO_UNREACHABLE",
-										message: `The managed ${tracking.record.provider} tunnel exited before the supervisor started.`,
-										remedy: `Cleanup failed. Unmanaged pid ${tracking.record.pid} may still be running: ${stopped.reason ?? "unknown error"}. The tunnel record remains available to \`stim stop\`.`
-									} };
-								}
-								d.clearTunnelRecord(root, tracking.record);
-								return { failed: {
-									code: "STIM_REMOTE_METRO_UNREACHABLE",
-									message: `The managed ${tracking.record.provider} tunnel exited before the supervisor started.`,
-									remedy: "Retry `stim start --remote`."
-								} };
-							}
-							let child;
-							try {
-								child = await spawnSupervisor(tracking.record.url);
-							} catch (err) {
-								return { failed: {
-									code: "STIM_SUPERVISOR_EXITED",
-									message: `Could not spawn the dev server supervisor: ${err?.message || err}`,
-									remedy: "Fix the spawn error, then retry `stim start --remote`."
-								} };
-							}
-							const handoffRecord = {
-								pid: child.pid,
-								processToken: child.recordedIdentity ? child.recordedIdentity.processToken ?? null : child.pid ? (0, process_identity_exports.captureProcessToken)(child.pid) : null,
-								port,
-								mode: serverMode,
-								startedAt: new Date(spawnedTs ?? Date.now()).toISOString()
-							};
-							try {
-								d.writeSupervisorRecord(root, { supervisor: handoffRecord });
-							} catch {
-								if (!await waitForSupervisorHandoff(child)) {
-									const stopped = supervisorSignalable(child) && await d.terminateSupervisorChild(child);
-									return { failed: {
+								try {
+									await d.writeSupervisorRecord(root, { supervisor: handoffRecord });
+								} catch {
+									if (!await waitForSupervisorHandoff(child)) return { failed: {
 										code: "STIM_SUPERVISOR_EXITED",
 										message: `Could not record supervisor pid ${child.pid ?? "unknown"} before releasing the managed start lock.`,
-										remedy: stopped ? "The supervisor process was stopped. Retry `stim start --remote`." : `Cleanup failed. Unmanaged supervisor pid ${child.pid ?? "unknown"} may still be running. Stop it with \`stim stop\`${child.pid === void 0 ? "" : `, or \`${d.platform === "win32" ? `taskkill /PID ${child.pid} /T /F` : `kill ${child.pid}`}\``} before retrying.`
+										remedy: "The supervisor process was stopped. Retry `stim start --remote`."
 									} };
 								}
-							}
-							return {
-								origin: tracking.record.url,
-								tunnel: tracking
-							};
+								return {
+									origin: tracking.record.url,
+									tunnel: tracking
+								};
+							})();
+						} catch (err) {
+							if (err instanceof WorkspaceProcessCleanupError) throw err;
+							throwIfCancelled(operationSignal, "Metro startup");
+							if (err instanceof Error && "code" in err && err.code === "STIM_CANCELLED") throw err;
+							return fail({
+								code: "STIM_REMOTE_METRO_UNREACHABLE",
+								message: `Could not start the managed Metro tunnel: ${err?.message || err}`,
+								remedy: "Retry `stim start --remote` after the other start command finishes."
+							});
+						}
+						if ("failed" in acquisition) return fail(acquisition.failed);
+						publicOrigin = acquisition.origin;
+						managedTunnel = acquisition.tunnel;
+						if (managedTunnel.record.provider === "tailscale") note(phaseLine("lan", `tailnet-only Metro: ${publicOrigin}`));
+						resolution = await resolveStartupMetro(port, root);
+						supervisor = liveSupervisor({
+							state: readWorkspaceState$1(root),
+							project: getProject(root),
+							port
 						});
-					} catch (err) {
-						if (err instanceof Error && "code" in err && err.code === "STIM_CANCELLED") throw err;
-						return fail({
-							code: "STIM_REMOTE_METRO_UNREACHABLE",
-							message: `Could not acquire the managed Metro tunnel lock: ${err?.message || err}`,
-							remedy: "Retry `stim start --remote` after the other start command finishes."
+					}
+				}
+				const managedTunnelExited = () => managedTunnel !== null && !d.isTunnelAlive(managedTunnel.record.pid, managedTunnel.record.processToken);
+				const failExitedManagedTunnel = async () => {
+					const tracked = managedTunnel;
+					const record = tracked.record;
+					const stopped = tracked.startedHere ? await d.stopTunnel(record) : { status: "missing" };
+					if (stopped.status !== "failed") await d.clearTunnelRecord(root, record);
+					return fail({
+						code: "STIM_REMOTE_METRO_UNREACHABLE",
+						message: `The managed ${record.provider} tunnel is no longer verified running before the dev server became ready.`,
+						remedy: stopped.status === "failed" ? `The tunnel cleanup also failed: ${stopped.reason ?? "unknown error"}. Run \`stim stop\`, then retry.` : "Run `stim stop`, then `stim start --remote`."
+					});
+				};
+				const requireExpoTunnel = () => {
+					if (tunnel && (!supervisor || readMetroTunnel(root)?.kind !== "expo")) fail({
+						code: "STIM_REMOTE_START_REQUIRED",
+						message: `The Expo dev server on port ${port} is local-only and cannot gain a tunnel while it is running.`,
+						remedy: "Run `stim stop`, then `stim start --remote`."
+					});
+				};
+				if (!spawned.child && resolution.metro) {
+					if (managedTunnelExited()) return failExitedManagedTunnel();
+					if (tunnel && supervisor) {
+						if (!await waitForExpoTunnel({
+							root,
+							seconds: waitSeconds,
+							aborted: () => !liveSupervisor({
+								state: readWorkspaceState$1(root),
+								project: getProject(root),
+								port
+							})
+						})) {
+							const stillLive = liveSupervisor({
+								state: readWorkspaceState$1(root),
+								project: getProject(root),
+								port
+							});
+							return fail({
+								code: "STIM_REMOTE_START_REQUIRED",
+								message: stillLive ? `The Expo dev server on port ${port} is local-only and cannot gain a tunnel while it is running.` : `The Expo dev server on port ${port} stopped before its tunnel became ready.`,
+								remedy: stillLive ? "Run `stim stop`, then `stim start --remote`." : "Run `stim start --remote` again."
+							});
+						}
+						supervisor = liveSupervisor({
+							state: readWorkspaceState$1(root),
+							project: getProject(root),
+							port
 						});
 					}
-					if ("failed" in acquisition) return fail(acquisition.failed);
-					publicOrigin = acquisition.origin;
-					managedTunnel = acquisition.tunnel;
-					if (managedTunnel.record.provider === "tailscale") note(phaseLine("lan", `tailnet-only Metro: ${publicOrigin}`));
-					resolution = await resolveStartupMetro(port, root);
-					supervisor = liveSupervisor({
-						state: readWorkspaceState$1(root),
-						project: getProject(root),
-						port
+					requireExpoTunnel();
+					if (!supervisor) {
+						note(chalk.dim(`A dev server for this project already answers on port ${port}, started outside Stim.`));
+						note(chalk.dim("Leaving it alone: Stim will not start a second bundler over a working one."));
+					}
+					if (managedTunnelExited()) return failExitedManagedTunnel();
+					await withWorkspaceStateLockAsync(root, () => clearWorkspaceStateKeys(root, [IDLE_STOP_KEY]), operationSignal);
+					return startFacts({
+						root,
+						port,
+						supervisor,
+						logsDir,
+						alreadyRunning: true
 					});
 				}
-			}
-			const managedTunnelExited = () => managedTunnel !== null && !d.isTunnelAlive(managedTunnel.record.pid);
-			const failExitedManagedTunnel = async () => {
-				const tracked = managedTunnel;
-				const record = tracked.record;
-				const stopped = tracked.startedHere ? await d.stopTunnel(record) : { status: "missing" };
-				if (stopped.status !== "failed") d.clearTunnelRecord(root, record);
-				return fail({
-					code: "STIM_REMOTE_METRO_UNREACHABLE",
-					message: `The managed ${record.provider} tunnel exited before the dev server became ready.`,
-					remedy: stopped.status === "failed" ? `The tunnel cleanup also failed: ${stopped.reason ?? "unknown error"}. Run \`stim stop\`, then retry.` : "Run `stim stop`, then `stim start --remote`."
-				});
-			};
-			const requireExpoTunnel = () => {
-				if (tunnel && (!supervisor || readMetroTunnel(root)?.kind !== "expo")) fail({
-					code: "STIM_REMOTE_START_REQUIRED",
-					message: `The Expo dev server on port ${port} is local-only and cannot gain a tunnel while it is running.`,
-					remedy: "Run `stim stop`, then `stim start --remote`."
-				});
-			};
-			if (!spawnedChild && resolution.metro) {
-				if (managedTunnelExited()) return failExitedManagedTunnel();
-				if (tunnel && supervisor) {
-					if (!await waitForExpoTunnel({
+				if (!spawned.child && supervisor) {
+					note(chalk.dim(`Supervisor pid ${supervisor.pid} is already running for this workspace; waiting for it to answer on port ${port}...`));
+					if (!await waitForMetro({
 						root,
+						port,
 						seconds: waitSeconds,
-						aborted: () => !liveSupervisor({
-							state: readWorkspaceState$1(root),
-							project: getProject(root),
-							port
-						})
+						aborted: managedTunnel ? managedTunnelExited : void 0
 					})) {
-						const stillLive = liveSupervisor({
-							state: readWorkspaceState$1(root),
-							project: getProject(root),
-							port
-						});
+						if (managedTunnelExited()) return failExitedManagedTunnel();
 						return fail({
-							code: "STIM_REMOTE_START_REQUIRED",
-							message: stillLive ? `The Expo dev server on port ${port} is local-only and cannot gain a tunnel while it is running.` : `The Expo dev server on port ${port} stopped before its tunnel became ready.`,
-							remedy: stillLive ? "Run `stim stop`, then `stim start --remote`." : "Run `stim start --remote` again."
+							code: "STIM_METRO_TIMEOUT",
+							message: `Supervisor pid ${supervisor.pid} did not serve port ${port} within ${waitSeconds}s.`,
+							lines: logTailLines(logFile),
+							remedy: "Run `stim stop` to halt it, then `stim start` again."
 						});
 					}
+					if (tunnel) {
+						if (!await waitForExpoTunnel({
+							root,
+							seconds: waitSeconds,
+							aborted: () => !liveSupervisor({
+								state: readWorkspaceState$1(root),
+								project: getProject(root),
+								port
+							})
+						})) {
+							const stillLive = liveSupervisor({
+								state: readWorkspaceState$1(root),
+								project: getProject(root),
+								port
+							});
+							return fail({
+								code: "STIM_REMOTE_START_REQUIRED",
+								message: stillLive ? `The Expo dev server on port ${port} is local-only and cannot gain a tunnel while it is running.` : `The Expo dev server on port ${port} stopped before its tunnel became ready.`,
+								remedy: stillLive ? "Run `stim stop`, then `stim start --remote`." : "Run `stim start --remote` again."
+							});
+						}
+					}
 					supervisor = liveSupervisor({
 						state: readWorkspaceState$1(root),
 						project: getProject(root),
 						port
+					}) || (tunnel ? null : supervisor);
+					requireExpoTunnel();
+					if (managedTunnelExited()) return failExitedManagedTunnel();
+					return startFacts({
+						root,
+						port,
+						supervisor,
+						logsDir,
+						alreadyRunning: true
 					});
 				}
-				requireExpoTunnel();
-				if (!supervisor) {
-					note(chalk.dim(`A dev server for this project already answers on port ${port}, started outside Stim.`));
-					note(chalk.dim("Leaving it alone: Stim will not start a second bundler over a working one."));
-				}
 				if (managedTunnelExited()) return failExitedManagedTunnel();
-				clearWorkspaceStateKeys(root, [IDLE_STOP_KEY]);
-				return startFacts({
-					root,
-					port,
-					supervisor,
-					logsDir,
-					alreadyRunning: true
-				});
-			}
-			if (!spawnedChild && supervisor) {
-				note(chalk.dim(`Supervisor pid ${supervisor.pid} is already running for this workspace; waiting for it to answer on port ${port}...`));
+				const child = spawned.child ?? await spawnSupervisor(publicOrigin);
+				const attemptStartedTs = spawnedTs ?? Date.now();
 				if (!await waitForMetro({
 					root,
 					port,
 					seconds: waitSeconds,
-					aborted: managedTunnel ? managedTunnelExited : void 0
+					aborted: () => childExit !== null || (child.pid ? !pidExists(child.pid) : false) || managedTunnelExited()
 				})) {
 					if (managedTunnelExited()) return failExitedManagedTunnel();
-					return fail({
+					const gone = childExit !== null || (child.pid ? !pidExists(child.pid) : false);
+					const exitInfo = childExit;
+					const how = exitInfo ? exitInfo.signal ? `signal ${exitInfo.signal}` : `code ${exitInfo.code}` : "without being observed";
+					return fail(gone ? {
+						code: "STIM_SUPERVISOR_EXITED",
+						message: `The supervisor exited (${how}) before the dev server came up on port ${port}.`,
+						lines: failureEvidence({
+							logFile,
+							logsDir,
+							sinceTs: attemptStartedTs
+						}),
+						remedy: "Fix the error above and run `stim start` again; `stim logs --errors` has the full records."
+					} : {
 						code: "STIM_METRO_TIMEOUT",
-						message: `Supervisor pid ${supervisor.pid} did not serve port ${port} within ${waitSeconds}s.`,
-						lines: logTailLines(logFile),
-						remedy: "Run `stim stop` to halt it, then `stim start` again."
+						message: `The dev server did not answer on port ${port} within ${waitSeconds}s.`,
+						lines: failureEvidence({
+							logFile,
+							logsDir,
+							sinceTs: attemptStartedTs
+						}),
+						remedy: "It may still be starting. Run `stim stop` to halt it, or `stim logs` to follow along."
 					});
 				}
+				if (managedTunnelExited()) return failExitedManagedTunnel();
 				if (tunnel) {
 					if (!await waitForExpoTunnel({
 						root,
 						seconds: waitSeconds,
-						aborted: () => !liveSupervisor({
-							state: readWorkspaceState$1(root),
-							project: getProject(root),
-							port
-						})
+						aborted: () => childExit !== null || (child.pid ? !pidExists(child.pid) : false)
 					})) {
-						const stillLive = liveSupervisor({
-							state: readWorkspaceState$1(root),
-							project: getProject(root),
-							port
-						});
+						const gone = childExit !== null || (child.pid ? !pidExists(child.pid) : false);
 						return fail({
-							code: "STIM_REMOTE_START_REQUIRED",
-							message: stillLive ? `The Expo dev server on port ${port} is local-only and cannot gain a tunnel while it is running.` : `The Expo dev server on port ${port} stopped before its tunnel became ready.`,
-							remedy: stillLive ? "Run `stim stop`, then `stim start --remote`." : "Run `stim start --remote` again."
+							code: gone ? "STIM_SUPERVISOR_EXITED" : "STIM_METRO_TIMEOUT",
+							message: gone ? `The supervisor exited before the Expo tunnel became ready on port ${port}.` : `Expo did not report a tunnel URL within ${waitSeconds}s.`,
+							remedy: "Run `stim stop`, then `stim start --remote`."
 						});
 					}
 				}
-				supervisor = liveSupervisor({
-					state: readWorkspaceState$1(root),
-					project: getProject(root),
-					port
-				}) || (tunnel ? null : supervisor);
-				requireExpoTunnel();
-				if (managedTunnelExited()) return failExitedManagedTunnel();
+				supervisor = await waitForSupervisorHandoff(child);
+				if (!supervisor) return fail({
+					code: "STIM_SUPERVISOR_EXITED",
+					message: "The dev server answered before its supervisor ownership could be verified.",
+					remedy: "Retry `stim start` after the supervisor exits or records its ownership."
+				});
 				return startFacts({
 					root,
 					port,
 					supervisor,
 					logsDir,
-					alreadyRunning: true
+					alreadyRunning: false
 				});
+			} finally {
+				await reconcileSpawnedSupervisor();
 			}
-			if (managedTunnelExited()) return failExitedManagedTunnel();
-			const child = spawnedChild ?? await spawnSupervisor(publicOrigin);
-			const attemptStartedTs = spawnedTs ?? Date.now();
-			if (!await waitForMetro({
-				root,
-				port,
-				seconds: waitSeconds,
-				aborted: () => childExit !== null || (child.pid ? !pidExists(child.pid) : false) || managedTunnelExited()
-			})) {
-				if (managedTunnelExited()) return failExitedManagedTunnel();
-				const gone = childExit !== null || (child.pid ? !pidExists(child.pid) : false);
-				const exitInfo = childExit;
-				const how = exitInfo ? exitInfo.signal ? `signal ${exitInfo.signal}` : `code ${exitInfo.code}` : "without being observed";
-				return fail(gone ? {
-					code: "STIM_SUPERVISOR_EXITED",
-					message: `The supervisor exited (${how}) before the dev server came up on port ${port}.`,
-					lines: failureEvidence({
-						logFile,
-						logsDir,
-						sinceTs: attemptStartedTs
-					}),
-					remedy: "Fix the error above and run `stim start` again; `stim logs --errors` has the full records."
-				} : {
-					code: "STIM_METRO_TIMEOUT",
-					message: `The dev server did not answer on port ${port} within ${waitSeconds}s.`,
-					lines: failureEvidence({
-						logFile,
-						logsDir,
-						sinceTs: attemptStartedTs
-					}),
-					remedy: "It may still be starting. Run `stim stop` to halt it, or `stim logs` to follow along."
-				});
-			}
-			if (managedTunnelExited()) return failExitedManagedTunnel();
-			if (tunnel) {
-				if (!await waitForExpoTunnel({
-					root,
-					seconds: waitSeconds,
-					aborted: () => childExit !== null || (child.pid ? !pidExists(child.pid) : false)
-				})) {
-					const gone = childExit !== null || (child.pid ? !pidExists(child.pid) : false);
-					return fail({
-						code: gone ? "STIM_SUPERVISOR_EXITED" : "STIM_METRO_TIMEOUT",
-						message: gone ? `The supervisor exited before the Expo tunnel became ready on port ${port}.` : `Expo did not report a tunnel URL within ${waitSeconds}s.`,
-						remedy: "Run `stim stop`, then `stim start --remote`."
-					});
-				}
-			}
-			supervisor = liveSupervisor({
-				state: readWorkspaceState$1(root),
-				project: getProject(root),
-				port
-			}) || {
-				pid: child.pid,
-				port,
-				mode: null,
-				startedAt: null
-			};
-			return startFacts({
-				root,
-				port,
-				supervisor,
-				logsDir,
-				alreadyRunning: false
-			});
 		};
 		const startLocked = async () => {
 			try {
-				return await withWorkspaceProcessLock(dirname(workspaceLogsDir$1(root)), "metro-start", runStart, { external: true });
+				return await d.withTunnelLock(root, (tunnelClaim) => withWorkspaceProcessLock(dirname(workspaceLogsDir$1(root)), "metro-start", (claim) => runStart(claim, tunnelClaim), {
+					external: true,
+					signal: operationSignal
+				}), { signal: operationSignal });
 			} catch (error) {
+				if (error instanceof WorkspaceProcessCleanupError || error instanceof StartRefusal) throw error;
+				throwIfCancelled(operationSignal, "Metro startup");
+				if (workspaceProcessLockError(error) === "refused") return fail({
+					code: "STIM_WORKTREE_REMOVAL_IN_PROGRESS",
+					message: `The workspace at ${root} is being removed.`,
+					remedy: "Retry `stim start` after workspace removal finishes."
+				});
 				if (workspaceProcessLockError(error) !== "timeout") throw error;
 				return fail({
 					code: "STIM_METRO_TIMEOUT",
@@ -972,7 +1193,7 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 		};
 		if (!managedRemote) return startLocked();
 		try {
-			return await d.withWorktreeLock(worktreeRoot, startLocked);
+			return await d.withWorktreeLock(worktreeRoot, startLocked, { signal: operationSignal });
 		} catch (err) {
 			const lockError = workspaceProcessLockError(err);
 			if (lockError === "refused") return fail({
@@ -996,6 +1217,13 @@ async function startDevServer({ root, settings, settingsContext, waitSeconds = D
 			reclaimed
 		};
 	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError) return {
+			ok: false,
+			error: startError(error),
+			lines: [],
+			reclaimed,
+			retainedClaimRoots: [...new Set(error.claims.map((claim) => claim.root))]
+		};
 		if (!(error instanceof StartRefusal)) throw error;
 		return {
 			ok: false,
@@ -1063,8 +1291,9 @@ async function resolveWorkspaceMetroPort(root, settings, note, command, reserve
 }
 async function reservePort(root, pinned) {
 	try {
-		return await reserveMetroPort(root, void 0, void 0, pinned);
+		return await reserveMetroPort(root, void 0, void 0, pinned, ambientContext()?.signal);
 	} catch (error) {
+		throwIfCancelled(ambientContext()?.signal, "Metro startup");
 		if (error instanceof PortInspectionError) return {
 			code: error.code,
 			message: error.reason,