stim 1.14.0 → 1.16.0

package/dist/warm-progress-CpGv3Wb6.mjs

@@ -0,0 +1,732 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
+import { o as pullRequestLookups } from "./pull-request-pxnDCQzn.mjs";
+import { at as gitCommonDirOnDisk } from "./settings-oTSkkNrM.mjs";
+import { D as discoverAgentSessions, E as attributeAgentSessions, T as agentKey, a as updateWorkspaceState, u as ensureWorkspaceStorage, v as workspaceDir, w as withDirLock } from "./workspace-state-B8-aJ1_5.mjs";
+import { I as ownedAvdDirectory } from "./android-B_NumVyQ.mjs";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { ENDED_AGENT_RETENTION_MS, READY_PHASE_MS, WARM_KEY, agentSessionsCacheFile, diskUsageCacheFile, pullRequestCacheFile, readAgentSessionsCache, readDiskUsage, readEndedAgentSessions, readPullRequestCache, readWarmRecord, readWorkspaceAgent, readWorkspaceState, workspaceEndedAgentsFile, workspaceEndedAgentsLock } from "@stim-cli/core/state";
+import { homedir } from "node:os";
+//#region src/workspace/merge-state.ts
+const FETCH_TIMEOUT_MS = 3e4;
+const FETCH_FRESH_MS = 6e5;
+const GIT_TIMEOUT_MS$1 = 6e4;
+const REMOTE_PREFIX = "refs/remotes/origin/";
+const MAX_MERGE_STATE_COMMITS = 2e3;
+function failure(error) {
+	const { stderr, message } = error;
+	const text = String(stderr ?? "").trim() || String(message ?? error);
+	return text.split("\n")[0] ?? text;
+}
+function fetchedRecently(repo, now) {
+	const path = getExecutor().runFileQuiet("git", [
+		"-C",
+		repo,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-path",
+		"FETCH_HEAD"
+	])?.trim();
+	try {
+		return Boolean(path) && now - statSync(path).mtimeMs < FETCH_FRESH_MS;
+	} catch {
+		return false;
+	}
+}
+/**
+* Fetches the default branch that `origin/HEAD` names into its remote-tracking ref, bounded by a timeout and never
+* prompting for credentials. It skips the fetch when the checkout fetched anything in the last 10 minutes.
+*/
+function fetchDefaultBranch(repo, now = Date.now()) {
+	const exec = getExecutor();
+	const ref = exec.runFileQuiet("git", [
+		"-C",
+		repo,
+		"symbolic-ref",
+		"--quiet",
+		"refs/remotes/origin/HEAD"
+	])?.trim();
+	if (!ref?.startsWith(REMOTE_PREFIX)) return { error: `origin/HEAD is not set; run \`git -C ${repo} remote set-head origin --auto\`` };
+	const branch = ref.slice(20);
+	if (fetchedRecently(repo, now)) return {
+		ref,
+		name: `origin/${branch}`
+	};
+	try {
+		exec.runFile("git", [
+			"-C",
+			repo,
+			"fetch",
+			"--quiet",
+			"--no-tags",
+			"--no-recurse-submodules",
+			"origin",
+			`+refs/heads/${branch}:${ref}`
+		], {
+			timeoutMs: FETCH_TIMEOUT_MS,
+			env: { GIT_TERMINAL_PROMPT: "0" }
+		});
+	} catch (error) {
+		return { error: `git fetch origin ${branch} failed: ${failure(error)}` };
+	}
+	return {
+		ref,
+		name: `origin/${branch}`
+	};
+}
+function notMerged(detail) {
+	return {
+		merged: false,
+		unknown: false,
+		detail
+	};
+}
+function currentBranch(path) {
+	const ref = getExecutor().runFileQuiet("git", [
+		"-C",
+		path,
+		"symbolic-ref",
+		"--quiet",
+		"HEAD"
+	])?.trim();
+	return ref?.startsWith("refs/heads/") ? ref : null;
+}
+function upstreamGone(path, branch) {
+	if (!branch) return false;
+	const [upstream, state] = (getExecutor().runFileQuiet("git", [
+		"-C",
+		path,
+		"for-each-ref",
+		"--format=%(upstream)%00%(upstream:track)",
+		branch
+	]) ?? "").trim().split("\0");
+	return Boolean(upstream) && state === "[gone]";
+}
+function committedOn(path, branch, head) {
+	if (!branch) return false;
+	const exec = getExecutor();
+	return (exec.runFileQuiet("git", [
+		"-C",
+		path,
+		"reflog",
+		"show",
+		"--format=%H %gs",
+		branch
+	]) ?? "").split("\n").some((entry) => {
+		const [sha = "", ...subject] = entry.split(" ");
+		return /^(commit|cherry-pick|rebase|revert)\b/.test(subject.join(" ")) && exec.runFileQuiet("git", [
+			"-C",
+			path,
+			"merge-base",
+			"--is-ancestor",
+			sha,
+			head
+		]) !== null;
+	});
+}
+/**
+* Whether the worktree's HEAD is merged into `target`, and when: `mergedAt` is the committer date, in epoch
+* milliseconds, of the commit on `target` that brought the work in, the latest one for a rebase merge.
+* The signals, all local git:
+* - HEAD is an ancestor of the default branch, off its first-parent line, and the branch's reflog shows a commit made
+*   on it that HEAD contains, so a merge commit brought the branch's own work in. A branch with no commit of its own
+*   is not merged.
+* - The branch changes the tree, has no merge commits, and every commit since the merge base has the same
+*   `git patch-id --verbatim` as a commit on the default branch (a rebase merge).
+* - The branch changes the tree and its whole diff since the merge base has the same verbatim patch id as a commit on
+*   the default branch, limited to the files the branch changes (a squash merge).
+* Anything git cannot answer is unknown, never merged. `coversUnpushed` is true for a patch-equivalent HEAD whose
+* upstream branch was deleted: its commits exist only locally, but their change is on the default branch.
+*/
+function mergeState(path, { ref, name }, { timeoutMs = GIT_TIMEOUT_MS$1, maxCommits = MAX_MERGE_STATE_COMMITS } = {}) {
+	const git = (args, input) => getExecutor().runFile("git", [
+		"--literal-pathspecs",
+		"-C",
+		path,
+		...args
+	], {
+		timeoutMs,
+		input
+	});
+	const patch = (args, input) => getExecutor().runFile("git", [
+		"--literal-pathspecs",
+		"-C",
+		path,
+		...args
+	], {
+		timeoutMs,
+		input,
+		untrimmed: true
+	});
+	const patchIdCommits = (text) => new Map(text ? git(["patch-id", "--verbatim"], text).split("\n").flatMap((line) => {
+		const [id, commit] = line.split(" ");
+		return id && commit ? [[id, commit]] : [];
+	}) : []);
+	const patchIds = (text) => [...patchIdCommits(text).keys()];
+	const committedAt = (commits) => {
+		const times = commits.length ? git([
+			"log",
+			"--no-walk",
+			"--stdin",
+			"--format=%ct"
+		], commits.join("\n")).split("\n").map(Number) : [];
+		if (!times.length || !times.every(Number.isFinite)) throw new Error(`no committer date for ${commits.join(" ")}`);
+		return Math.max(...times) * 1e3;
+	};
+	const diffOptions = ["--no-color", "--no-ext-diff"];
+	const noOwnCommits = notMerged(`no commits of its own beyond ${name}`);
+	try {
+		const head = git([
+			"rev-parse",
+			"--verify",
+			"HEAD^{commit}"
+		]);
+		const base = git([
+			"merge-base",
+			head,
+			ref
+		]);
+		const branch = currentBranch(path);
+		if (base === head) {
+			if (git(["rev-parse", ref]) === head || git([
+				"rev-list",
+				"--first-parent",
+				"--parents",
+				`${head}..${ref}`
+			]).split("\n").some((line) => line.split(" ")[1] === head) || !committedOn(path, branch, head)) return noOwnCommits;
+			const descendants = new Set(git([
+				"rev-list",
+				"--ancestry-path",
+				`${head}..${ref}`
+			]).split("\n"));
+			const landed = git([
+				"rev-list",
+				"--first-parent",
+				"--reverse",
+				`${head}..${ref}`
+			]).split("\n").find((commit) => descendants.has(commit));
+			if (!landed) throw new Error(`no commit on ${name} merges ${head}`);
+			return {
+				merged: true,
+				into: name,
+				head,
+				coversUnpushed: false,
+				mergedAt: committedAt([landed])
+			};
+		}
+		const aheadCount = Number(git([
+			"rev-list",
+			"--count",
+			`${base}..${head}`
+		]));
+		if (aheadCount > maxCommits) return {
+			merged: false,
+			unknown: true,
+			detail: `merge state unknown: ${aheadCount} commits of its own ahead of the merge base with ${name} exceeds the ${maxCommits}-commit limit`
+		};
+		const files = git([
+			"diff",
+			"--name-only",
+			"--no-renames",
+			"-z",
+			base,
+			head
+		]).split("\0").filter(Boolean);
+		if (!files.length) return notMerged(`no net change beyond ${name}`);
+		const log = (range, pathspec = []) => patch([
+			"log",
+			"-p",
+			"--no-merges",
+			...diffOptions,
+			"--format=commit %H",
+			"--stdin"
+		], pathspec.length ? `${range}\n--\n${pathspec.join("\n")}\n` : `${range}\n`);
+		const upstream = patchIdCommits(log(`${base}..${ref}`, files));
+		const patchEquivalent = (ids) => ({
+			merged: true,
+			into: name,
+			head,
+			coversUnpushed: upstreamGone(path, branch),
+			mergedAt: committedAt(ids.map((id) => upstream.get(id)))
+		});
+		const squash = patchIds(patch([
+			"diff",
+			...diffOptions,
+			base,
+			head
+		]));
+		if (squash.length === 1 && upstream.has(squash[0])) return patchEquivalent(squash);
+		if (!git([
+			"rev-list",
+			"--merges",
+			`${base}..${head}`
+		])) {
+			const own = patchIds(log(`${base}..${head}`));
+			if (own.length && own.every((id) => upstream.has(id))) return patchEquivalent(own);
+		}
+		return notMerged(`not merged into ${name}`);
+	} catch (error) {
+		const timedOut = error?.code === "ETIMEDOUT" ? { timedOut: true } : {};
+		return {
+			merged: false,
+			unknown: true,
+			detail: `merge state unknown: ${failure(error)}`,
+			...timedOut
+		};
+	}
+}
+//#endregion
+//#region src/status-measures.ts
+const LIVE_DISK_MAX_AGE_MS = 3e5;
+const IDLE_DISK_MAX_AGE_MS = 36e5;
+const DU_TIMEOUT_MS = 12e4;
+const PULL_REQUEST_MAX_AGE_MS = 3e5;
+const PULL_REQUEST_CHECK_MS = 6e4;
+const GIT_TIMEOUT_MS = 5e3;
+const AGENT_DISCOVERY_MS = 15e3;
+const AGENT_CACHE_MAX_AGE_MS = 12e4;
+function writeCacheFile(file, entry) {
+	const temporary = `${file}.${randomUUID()}.tmp`;
+	try {
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(temporary, JSON.stringify(entry));
+		renameSync(temporary, file);
+	} catch {
+		rmSync(temporary, { force: true });
+	}
+}
+function forgetStatusMeasures(worktree, workspaces) {
+	const roots = [.../* @__PURE__ */ new Set([worktree, ...workspaces])];
+	const files = [pullRequestCacheFile(worktree), ...roots.flatMap((root) => [
+		diskUsageCacheFile(root),
+		diskUsageCacheFile(join(root, "node_modules")),
+		diskUsageCacheFile(workspaceDir(root))
+	])];
+	for (const file of files) try {
+		rmSync(file, { force: true });
+	} catch {}
+}
+function simulatorDataDir(udid) {
+	return join(homedir(), "Library", "Developer", "CoreSimulator", "Devices", udid);
+}
+function checkoutDir(state) {
+	if (state.worktree?.path) return state.worktree.path;
+	const common = gitCommonDirOnDisk(state.path);
+	return common && basename(common) === ".git" ? dirname(common) : state.path;
+}
+function deviceFolders(state) {
+	const folders = [];
+	for (const { ios, android } of [state, ...state.slots ?? []]) {
+		if (ios?.owned) folders.push({
+			device: ios,
+			path: simulatorDataDir(ios.udid)
+		});
+		if (android?.owned && !android.physical && android.name) {
+			const path = ownedAvdDirectory(android.name);
+			if (path) folders.push({
+				device: android,
+				path
+			});
+		}
+	}
+	return folders;
+}
+/** The folders an environment's disk use sums: its checkout, its node_modules folders and Stim's workspace folder. */
+function environmentFolders(state) {
+	const worktree = checkoutDir(state);
+	return {
+		worktree,
+		nodeModules: [.../* @__PURE__ */ new Set([join(worktree, "node_modules"), join(state.path, "node_modules")])],
+		build: workspaceDir(state.path)
+	};
+}
+/** The environment's disk use from the cached measurements; null before any folder was measured. */
+function environmentDisk(folders) {
+	const worktree = readDiskUsage(folders.worktree);
+	const modules = folders.nodeModules.map((path) => readDiskUsage(path));
+	const build = readDiskUsage(folders.build);
+	const measured = [
+		worktree,
+		...modules,
+		build
+	].filter((entry) => entry !== null);
+	if (!measured.length) return null;
+	return {
+		worktreeBytes: worktree?.bytes ?? null,
+		nodeModulesBytes: modules.every((entry) => entry !== null) ? modules.reduce((sum, entry) => sum + entry.bytes, 0) : null,
+		buildBytes: build?.bytes ?? null,
+		measuredAt: measured.map((entry) => entry.measuredAt).toSorted()[0]
+	};
+}
+function statusPullRequest(fact, checkedAt) {
+	return {
+		number: fact.number,
+		url: fact.url,
+		title: fact.title ?? "",
+		state: fact.state === "open" && fact.draft ? "draft" : fact.state,
+		checks: fact.checks ?? null,
+		reviewDecision: fact.reviewDecision ?? null,
+		checkedAt
+	};
+}
+function canonicalPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+function agentWorkspaces(states) {
+	return states.map((state) => ({
+		path: canonicalPath(state.path),
+		root: canonicalPath(checkoutDir(state)),
+		recorded: readWorkspaceAgent(readWorkspaceState(state.path))
+	}));
+}
+function applyAgentSessions(states, now) {
+	const cache = readAgentSessionsCache();
+	const sessions = cache && now - Date.parse(cache.discoveredAt) <= AGENT_CACHE_MAX_AGE_MS ? cache.sessions : [];
+	const discovered = new Set(sessions.map(agentKey));
+	const ended = states.map((state) => readEndedAgentSessions(state.path, now));
+	const workspaces = agentWorkspaces(states);
+	workspaces.forEach((workspace, i) => {
+		const { recorded } = workspace;
+		if (!recorded || discovered.has(agentKey(recorded))) return;
+		if (ended[i].some((session) => agentKey(session) === agentKey(recorded))) workspace.recorded = null;
+	});
+	attributeAgentSessions(workspaces, sessions, now).forEach((agents, i) => {
+		if (agents.length) states[i].agents = agents;
+		const running = new Set(agents.map(agentKey));
+		const endedAgents = ended[i].filter((session) => !running.has(agentKey(session)));
+		if (endedAgents.length) states[i].endedAgents = endedAgents;
+	});
+}
+function writeFileAtomic(file, entry) {
+	const temporary = `${file}.${randomUUID()}.tmp`;
+	try {
+		writeFileSync(temporary, JSON.stringify(entry));
+		renameSync(temporary, file);
+	} catch (error) {
+		rmSync(temporary, { force: true });
+		throw error;
+	}
+}
+function recordEndedAgents(states, gone, endedAt, now) {
+	const goneKeys = new Set(gone.map(agentKey));
+	const result = {
+		changed: false,
+		failed: false
+	};
+	attributeAgentSessions(agentWorkspaces(states), gone, now).forEach((sessions, i) => {
+		const root = states[i].path;
+		const ended = sessions.filter((session) => goneKeys.has(agentKey(session)));
+		if (!ended.length || !existsSync(workspaceDir(root))) return;
+		try {
+			withDirLock(workspaceEndedAgentsLock(root), () => {
+				const kept = new Map(readEndedAgentSessions(root, now).map((session) => [agentKey(session), session]));
+				for (const { pid: _pid, ...session } of ended) kept.set(agentKey(session), {
+					...session,
+					endedAt
+				});
+				writeFileAtomic(workspaceEndedAgentsFile(root), { sessions: [...kept.values()] });
+			});
+			result.changed = true;
+		} catch {
+			result.failed = true;
+		}
+	});
+	return result;
+}
+/**
+* Adds the cached measurements to a status read: each environment's `disk`, `agents` and `endedAgents`, each owned
+* device's `disk`, and each linked worktree's `pullRequest` when the cache holds a lookup for its current branch.
+* Reads files only.
+*/
+function applyStatusMeasures(states, worktrees) {
+	applyAgentSessions(states, Date.now());
+	for (const state of states) {
+		const disk = environmentDisk(environmentFolders(state));
+		if (disk) state.disk = disk;
+		for (const { device, path } of deviceFolders(state)) {
+			const measure = readDiskUsage(path);
+			if (measure) device.disk = measure;
+		}
+	}
+	for (const worktree of worktrees) {
+		const cached = worktree.branch ? readPullRequestCache(worktree.path) : null;
+		if (cached && cached.branch === worktree.branch) worktree.pullRequest = cached.pullRequest;
+	}
+}
+/** Kilobytes from `du -sk` output, or null when it printed none. */
+function parseDuKilobytes(output) {
+	const kb = Number(/^(\d+)\s/.exec(output)?.[1]);
+	return Number.isFinite(kb) ? kb : null;
+}
+function isStale(measure, maxAgeMs, now) {
+	return !measure || now - Date.parse(measure.measuredAt) >= maxAgeMs;
+}
+/**
+* Keeps the disk use, pull request and agent session caches fresh for `status --watch`, off its refresh path: one
+* agent session discovery at most every 15 seconds, which status ignores once it is over 2 minutes old, one `du -sk` at
+* a time, live environments first, each folder at most every 5 minutes while its environment is live and every hour otherwise, and one `gh api
+* graphql` per repository for worktrees whose lookup is over 5 minutes old or whose branch or HEAD moved. It
+* runs git only in the repository, never in a worktree, and only for worktrees whose git state status read. It rechecks
+* a folder's cache right before measuring, so two watchers rarely measure the same folder. A session the previous
+* discovery found and this one does not is recorded as ended in the workspaces it worked in. `updated` runs after each
+* write.
+*/
+function createStatusMeasurer({ updated, now = Date.now }) {
+	const exec = getExecutor();
+	let measuring = false;
+	let duMissing = false;
+	let checking = false;
+	let checkedAt = -Infinity;
+	let discovering = false;
+	let discoveredAt = -Infinity;
+	const failedAt = /* @__PURE__ */ new Map();
+	async function du(path) {
+		try {
+			return parseDuKilobytes(await exec.runFileAsync("du", ["-sk", path], { timeoutMs: DU_TIMEOUT_MS }));
+		} catch (error) {
+			const { code, status, stdout } = error;
+			if (code === "ENOENT") duMissing = true;
+			return status === 1 && typeof stdout === "string" ? parseDuKilobytes(stdout) : null;
+		}
+	}
+	async function measure(folders) {
+		for (const { path, maxAgeMs } of folders) {
+			if (duMissing || !isStale(readDiskUsage(path), maxAgeMs, now())) continue;
+			if (now() - (failedAt.get(path) ?? -Infinity) < maxAgeMs) continue;
+			let bytes = 0;
+			if (existsSync(path)) {
+				const kb = await du(path);
+				if (kb === null) {
+					failedAt.set(path, now());
+					continue;
+				}
+				bytes = kb * 1024;
+			} else if (!basename(path).startsWith("node_modules")) continue;
+			writeCacheFile(diskUsageCacheFile(path), {
+				path,
+				bytes,
+				measuredAt: new Date(now()).toISOString()
+			});
+			updated();
+		}
+	}
+	async function branchHead(repository, branch) {
+		try {
+			return (await exec.runFileAsync("git", [
+				"-C",
+				repository,
+				"rev-parse",
+				"--verify",
+				`refs/heads/${branch}`
+			], { timeoutMs: GIT_TIMEOUT_MS })).trim() || null;
+		} catch {
+			return null;
+		}
+	}
+	async function checkPullRequests(worktrees) {
+		const lookup = pullRequestLookups({ detail: true });
+		const byRepository = /* @__PURE__ */ new Map();
+		for (const { path, branch, repository, git } of worktrees) {
+			if (!branch || !repository || !git) continue;
+			const head = await branchHead(repository, branch);
+			if (!head) continue;
+			const cached = readPullRequestCache(path);
+			if (!(cached?.branch === branch && cached.head === head && now() - Date.parse(cached.checkedAt) < PULL_REQUEST_MAX_AGE_MS)) byRepository.set(repository, [...byRepository.get(repository) ?? [], {
+				path,
+				cwd: repository,
+				branch,
+				head
+			}]);
+		}
+		for (const [repository, queries] of byRepository) {
+			const results = await lookup(repository, queries);
+			const at = new Date(now()).toISOString();
+			results.forEach((result, i) => {
+				if (!("pullRequest" in result)) return;
+				const { path, branch, head } = queries[i];
+				const entry = {
+					path,
+					branch,
+					head,
+					checkedAt: at,
+					pullRequest: result.pullRequest ? statusPullRequest(result.pullRequest, at) : null
+				};
+				writeCacheFile(pullRequestCacheFile(path), entry);
+			});
+			if (results.some((result) => "pullRequest" in result)) updated();
+		}
+	}
+	async function discoverAgents(states) {
+		const at = now();
+		const sessions = await discoverAgentSessions({ now: at });
+		const previous = readAgentSessionsCache();
+		const running = new Set(sessions.map(agentKey));
+		const lastFound = previous ? Date.parse(previous.discoveredAt) : -Infinity;
+		const gone = at - lastFound <= ENDED_AGENT_RETENTION_MS ? previous.sessions.filter((session) => !running.has(agentKey(session))) : [];
+		const ended = gone.length ? recordEndedAgents(states, gone, previous.discoveredAt, at) : {
+			changed: false,
+			failed: false
+		};
+		if (ended.failed && at - lastFound <= AGENT_CACHE_MAX_AGE_MS) return;
+		writeCacheFile(agentSessionsCacheFile(), {
+			discoveredAt: new Date(at).toISOString(),
+			sessions
+		});
+		const shown = previous && at - Date.parse(previous.discoveredAt) <= AGENT_CACHE_MAX_AGE_MS;
+		if (ended.changed || !shown || JSON.stringify(previous.sessions) !== JSON.stringify(sessions)) updated();
+	}
+	return { schedule(states, worktrees) {
+		if (!discovering && now() - discoveredAt >= AGENT_DISCOVERY_MS) {
+			discovering = true;
+			discoveredAt = now();
+			discoverAgents(states).catch(() => {}).finally(() => {
+				discovering = false;
+			});
+		}
+		if (!measuring) {
+			const folders = /* @__PURE__ */ new Map();
+			for (const state of states.toSorted((a, b) => Number(b.live) - Number(a.live))) {
+				if (!existsSync(state.path)) continue;
+				const maxAgeMs = state.live ? LIVE_DISK_MAX_AGE_MS : IDLE_DISK_MAX_AGE_MS;
+				const { worktree, nodeModules, build } = environmentFolders(state);
+				for (const path of [
+					worktree,
+					...nodeModules,
+					build,
+					...deviceFolders(state).map((folder) => folder.path)
+				]) folders.set(path, Math.min(folders.get(path) ?? Infinity, maxAgeMs));
+			}
+			measuring = true;
+			measure([...folders].map(([path, maxAgeMs]) => ({
+				path,
+				maxAgeMs
+			}))).catch(() => {}).finally(() => {
+				measuring = false;
+			});
+		}
+		if (!checking && now() - checkedAt >= PULL_REQUEST_CHECK_MS) {
+			checking = true;
+			checkedAt = now();
+			checkPullRequests(worktrees).catch(() => {}).finally(() => {
+				checking = false;
+			});
+		}
+	} };
+}
+//#endregion
+//#region src/engine/warm-progress.ts
+const NO_WARM_PROGRESS = {
+	step: () => {},
+	finish: () => {}
+};
+function warmProgressClaimRoot(root) {
+	return join(workspaceDir(root), "warm.lock");
+}
+/**
+* Records that `stim worktree warm` runs in the workspace at `root`, under an ownership claim this process holds
+* until `finish`, so a warm that was killed reads as over. A process that cannot take the claim records nothing.
+*/
+function startWarmProgress(root, step, { note, now = Date.now }) {
+	let claim;
+	try {
+		ensureWorkspaceStorage(root);
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: warmProgressClaimRoot(root),
+			mode: "shared",
+			label: "worktree warm"
+		});
+		if (!attempt.acquired) throw new Error("another process holds its claim exclusively");
+		claim = attempt.acquired;
+	} catch (error) {
+		note(`Warm progress is not recorded for status: ${error?.message || error}`);
+		return NO_WARM_PROGRESS;
+	}
+	const startedAt = new Date(now()).toISOString();
+	const ours = (state) => {
+		const record = readWarmRecord(state);
+		return record?.phase === "warming" && record.claim.claimId === claim.claimId;
+	};
+	let warned = false;
+	const write = (update) => {
+		try {
+			updateWorkspaceState(root, update);
+		} catch (error) {
+			if (warned) return;
+			warned = true;
+			note(`Warm progress could not be recorded in the workspace state: ${error?.message || error}`);
+		}
+	};
+	const warming = (current) => ({
+		phase: "warming",
+		step: current,
+		startedAt,
+		claim: {
+			root: claim.root,
+			claimId: claim.claimId
+		}
+	});
+	write((state) => ({
+		...state,
+		[WARM_KEY]: warming(step)
+	}));
+	return {
+		step(next) {
+			write((state) => ours(state) ? {
+				...state,
+				[WARM_KEY]: warming(next)
+			} : state);
+		},
+		finish(succeeded) {
+			write((state) => {
+				if (!ours(state)) return state;
+				const { [WARM_KEY]: _, ...rest } = state;
+				return succeeded ? {
+					...rest,
+					[WARM_KEY]: {
+						phase: "ready",
+						at: new Date(now()).toISOString()
+					}
+				} : rest;
+			});
+			(0, ownership_claim_exports.releaseClaim)(claim);
+		}
+	};
+}
+/**
+* The lifecycle phase status reports. A warming record counts only while a warm holds the workspace's claim, and a ready
+* record only until the workspace is next used or `READY_PHASE_MS` passes.
+*/
+function workspacePhase(live, state, { now = Date.now(), survey = ownership_claim_exports.readClaimSet } = {}) {
+	if (live) return {
+		phase: "live",
+		phaseSince: null
+	};
+	const record = readWarmRecord(state);
+	if (record?.phase === "warming") {
+		if (survey(record.claim.root).live.length) return {
+			phase: "warming",
+			phaseSince: record.startedAt,
+			warmStep: record.step
+		};
+	}
+	if (record?.phase === "ready") {
+		const at = Date.parse(record.at);
+		const used = Date.parse(String(state?.lastUsedAt ?? ""));
+		if (now - at < READY_PHASE_MS && !(used > at)) return {
+			phase: "ready",
+			phaseSince: record.at
+		};
+	}
+	return {
+		phase: "idle",
+		phaseSince: null
+	};
+}
+//#endregion
+export { forgetStatusMeasures as a, createStatusMeasurer as i, workspacePhase as n, fetchDefaultBranch as o, applyStatusMeasures as r, mergeState as s, startWarmProgress as t };