stim 1.26.0 → 1.28.0

package/dist/{warm-progress-DvhTX_eu.mjs → warm-progress-B0Vpuvpl.mjs}

@@ -1,808 +1,808 @@
-import { D as ownership_claim_exports, E as debugLog, l as WorkspaceProcessCleanupError, n as isTimeoutError, t as getExecutor } from "./exec-VFRpu1iA.mjs";
-import { E as workspaceDir, M as withDirLock, _ as ensureWorkspaceStorage, h as discoverAgentSessions, m as attributeAgentSessions, o as updateWorkspaceState, p as agentKey } from "./workspace-state-pUg3_RRA.mjs";
-import { l as gitQuietAsync, o as git$1, s as gitAsync } from "./operation-exec-CUZifp6Z.mjs";
-import { Tt as linkedWorktreesOnDisk, bt as gitCommonDirOnDisk } from "./settings-CosW5X-S.mjs";
-import { V as ownedAvdDirectory } from "./android-DTAcRwBC.mjs";
-import { s as pullRequestLookups } from "./pull-request-CbNlkFok.mjs";
+import { D as ownership_claim_exports, E as debugLog, l as WorkspaceProcessCleanupError, n as isTimeoutError, t as getExecutor } from "./exec-aULwtNly.mjs";
+import { E as workspaceDir, M as withDirLock, _ as ensureWorkspaceStorage, h as discoverAgentSessions, m as attributeAgentSessions, o as updateWorkspaceState, p as agentKey } from "./workspace-state-kIZrdlSg.mjs";
+import { l as gitQuietAsync, o as git$1, s as gitAsync } from "./operation-exec-Dp4FuIGR.mjs";
+import { Ct as gitCommonDirOnDisk, Ot as linkedWorktreesOnDisk } from "./settings-CY5JZlNN.mjs";
+import { V as ownedAvdDirectory } from "./android-CsPs-7Mg.mjs";
+import { s as pullRequestLookups } from "./pull-request-BzLmzAIQ.mjs";
 import { clearClaimChild, markClaimChildPending, releaseClaim, setClaimChild, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join, sep } from "node:path";
-import { ENDED_AGENT_RETENTION_MS, READY_PHASE_MS, WARM_KEY, agentSessionsCacheFile, diskUsageCacheFile, diskUsageFailureFile, diskUsageWalkClaims, pullRequestCacheFile, readAgentSessionsCache, readDiskUsage, readDiskUsageFailure, readEndedAgentSessions, readPullRequestCache, readWarmRecord, readWorkspaceAgent, readWorkspaceState, workspaceEndedAgentsFile, workspaceEndedAgentsLock } from "@stim-cli/core/state";
+import { ENDED_AGENT_RETENTION_MS, READY_PHASE_MS, WARM_KEY, agentSessionsCacheFile, diskUsageCacheFile, diskUsageFailureFile, diskUsageWalkClaims, pullRequestCacheFile, readAgentSessionsCache, readDiskUsage, readDiskUsageFailure, readEndedAgentSessions, readPullRequestCache, readWarmRecord, readWorkspaceAgent, readWorkspaceState, trace, workspaceEndedAgentsFile, workspaceEndedAgentsLock } from "@stim-cli/core/state";
 import { captureProcessIdentity } from "@stim-cli/core/process-identity";
-//#region src/workspace/merge-state.ts
-const FETCH_TIMEOUT_MS = 3e4;
-/** How old a fetch or a cached lookup can be and still count as fresh. */
-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 { code, stderr, message } = error;
-	const text = (code === "ENOBUFS" ? "" : String(stderr ?? "").trim()) || String(message ?? error);
-	return text.split("\n")[0] ?? text;
-}
-function fetchTime(path) {
-	path = path?.trim() ?? null;
+//#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 DU_NICENESS = "19";
+const PULL_REQUEST_MAX_AGE_MS = 3e5;
+const PULL_REQUEST_CHECK_MS = 6e4;
+const GIT_TIMEOUT_MS$1 = 5e3;
+const AGENT_DISCOVERY_MS = 15e3;
+const AGENT_CACHE_MAX_AGE_MS = 12e4;
+function writeCacheFile(file, entry) {
+	const temporary = `${file}.${randomUUID()}.tmp`;
 	try {
-		return path ? statSync(path).mtimeMs : null;
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(temporary, JSON.stringify(entry));
+		renameSync(temporary, file);
 	} catch {
-		return null;
+		rmSync(temporary, { force: true });
 	}
 }
-function defaultBranch(repo, ref) {
-	ref = ref?.trim() ?? null;
-	if (!ref?.startsWith(REMOTE_PREFIX)) return { error: `origin/HEAD is not set; run \`git -C ${repo} remote set-head origin --auto\`` };
+function forgetStatusMeasures(worktree, workspaces) {
+	const roots = [.../* @__PURE__ */ new Set([worktree, ...workspaces])];
+	const files = [pullRequestCacheFile(worktree), ...roots.flatMap((root) => [
+		diskUsageCacheFile(root),
+		diskUsageFailureFile(root),
+		diskUsageCacheFile(join(root, "node_modules")),
+		diskUsageFailureFile(join(root, "node_modules")),
+		diskUsageCacheFile(workspaceDir(root)),
+		diskUsageFailureFile(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 {
-		ref,
-		name: `origin/${ref.slice(20)}`
+		worktree,
+		nodeModules: [.../* @__PURE__ */ new Set([join(worktree, "node_modules"), join(state.path, "node_modules")])],
+		build: workspaceDir(state.path)
 	};
 }
-function notMerged(detail) {
+/** 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 {
-		merged: false,
-		unknown: false,
-		detail
+		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* git(args, input) {
-	return yield {
-		args: ["--literal-pathspecs", ...args],
-		options: { input }
+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* patch(args, input) {
-	return yield {
-		args: ["--literal-pathspecs", ...args],
-		options: {
-			input,
-			untrimmed: true
-		}
+/**
+* Writes a pull request lookup into the cache `status` and report-only `gc` read. A lookup made without detail is
+* marked `partial`, so `status` asks again for the title, checks and review decision; until then it keeps the title
+* cached for the same pull request, and the checks and review decision cached for the same HEAD.
+*/
+function recordPullRequestLookup({ path, branch, head }, fact, checkedAt) {
+	let pullRequest = fact ? statusPullRequest(fact, checkedAt) : null;
+	const partial = pullRequest !== null && fact?.title === void 0;
+	const previous = partial ? readPullRequestCache(path) : null;
+	if (pullRequest && previous?.pullRequest?.number === pullRequest.number) {
+		const same = previous.head === head;
+		pullRequest = {
+			...pullRequest,
+			title: previous.pullRequest.title,
+			checks: same ? previous.pullRequest.checks : null,
+			reviewDecision: same ? previous.pullRequest.reviewDecision : null
+		};
+	}
+	const entry = {
+		path,
+		branch,
+		head,
+		checkedAt,
+		pullRequest,
+		...fact ? {
+			containsHead: fact.containsHead,
+			endedAt: fact.endedAt
+		} : {},
+		...partial ? { partial: true } : {}
 	};
+	writeCacheFile(pullRequestCacheFile(path), entry);
 }
-function* probe(args) {
+function canonicalPath(path) {
 	try {
-		return yield { args };
-	} catch (error) {
-		if (isTimeoutError(error) || typeof error === "object" && error !== null && "code" in error && error.code === "ENOBUFS") throw error;
-		return null;
+		return realpathSync(path);
+	} catch {
+		return path;
 	}
 }
-function* patchIdCommits(text) {
-	const output = text ? yield* git(["patch-id", "--verbatim"], text) : "";
-	return new Map(output.split("\n").flatMap((line) => {
-		const [id, commit] = line.split(" ");
-		return id && commit ? [[id, commit]] : [];
+function agentWorkspaces(states) {
+	return states.map((state) => ({
+		path: canonicalPath(state.path),
+		root: canonicalPath(checkoutDir(state)),
+		recorded: readWorkspaceAgent(readWorkspaceState(state.path))
 	}));
 }
-function* patchIds(text) {
-	return [...(yield* patchIdCommits(text)).keys()];
-}
-function* committedAt(commits) {
-	const times = commits.length ? (yield* 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;
-}
-function* currentBranch() {
-	const ref = (yield* probe([
-		"symbolic-ref",
-		"--quiet",
-		"HEAD"
-	]))?.trim();
-	return ref?.startsWith("refs/heads/") ? ref : null;
-}
-function* upstreamGone(branch) {
-	if (!branch) return false;
-	const [upstream, state] = ((yield* probe([
-		"for-each-ref",
-		"--format=%(upstream)%00%(upstream:track)",
-		branch
-	])) ?? "").trim().split("\0");
-	return Boolean(upstream) && state === "[gone]";
+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* committedOn(branch, head) {
-	if (!branch) return false;
-	const entries = (yield* probe([
-		"reflog",
-		"show",
-		"--format=%H %gs",
-		branch
-	])) ?? "";
-	for (const entry of entries.split("\n")) {
-		const [sha = "", ...subject] = entry.split(" ");
-		if (/^(commit|cherry-pick|rebase|revert)\b/.test(subject.join(" ")) && (yield* probe([
-			"merge-base",
-			"--is-ancestor",
-			sha,
-			head
-		])) !== null) return true;
+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;
 	}
-	return false;
 }
-function* mergeStateReads({ ref, name }, maxCommits) {
-	const diffOptions = ["--no-color", "--no-ext-diff"];
-	const noOwnCommits = {
-		merged: false,
-		unknown: false,
-		detail: `no commits of its own beyond ${name}`,
-		noOwnCommits: true
+function recordEndedAgents(states, gone, endedAt, now) {
+	const goneKeys = new Set(gone.map(agentKey));
+	const result = {
+		changed: false,
+		failed: false
 	};
-	try {
-		const head = yield* git([
-			"rev-parse",
-			"--verify",
-			"HEAD^{commit}"
-		]);
-		const base = yield* git([
-			"merge-base",
-			head,
-			ref
-		]);
-		const branch = yield* currentBranch();
-		if (base === head) {
-			if ((yield* git(["rev-parse", ref])) === head || (yield* git([
-				"rev-list",
-				"--first-parent",
-				"--parents",
-				`${head}..${ref}`
-			])).split("\n").some((line) => line.split(" ")[1] === head) || !(yield* committedOn(branch, head))) return noOwnCommits;
-			const descendants = new Set((yield* git([
-				"rev-list",
-				"--ancestry-path",
-				`${head}..${ref}`
-			])).split("\n"));
-			const landed = (yield* 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: yield* committedAt([landed])
-			};
-		}
-		const aheadCount = Number(yield* 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 = (yield* 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 = function* (range, pathspec = []) {
-			return yield* patch([
-				"log",
-				"-p",
-				"--no-merges",
-				...diffOptions,
-				"--format=commit %H",
-				"--stdin"
-			], pathspec.length ? `${range}\n--\n${pathspec.join("\n")}\n` : `${range}\n`);
-		};
-		const upstream = yield* patchIdCommits(yield* log(`${base}..${ref}`, files));
-		const patchEquivalent = function* (ids) {
-			return {
-				merged: true,
-				into: name,
-				head,
-				coversUnpushed: yield* upstreamGone(branch),
-				mergedAt: yield* committedAt(ids.map((id) => upstream.get(id)))
-			};
-		};
-		const squash = yield* patchIds(yield* patch([
-			"diff",
-			...diffOptions,
-			base,
-			head
-		]));
-		if (squash.length === 1 && upstream.has(squash[0])) return yield* patchEquivalent(squash);
-		if (!(yield* git([
-			"rev-list",
-			"--merges",
-			`${base}..${head}`
-		]))) {
-			const own = yield* patchIds(yield* log(`${base}..${head}`));
-			if (own.length && own.every((id) => upstream.has(id))) return yield* patchEquivalent(own);
+	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 notMerged(`not merged into ${name}`);
-	} catch (error) {
-		const timedOut = isTimeoutError(error) ? { timedOut: true } : {};
-		return {
-			merged: false,
-			unknown: true,
-			detail: `merge state unknown: ${failure(error)}`,
-			...timedOut
-		};
-	}
+	});
+	return result;
 }
 /**
-* 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).
-* A HEAD the default branch contains with no commit of its own on the branch is not merged and carries
-* `noOwnCommits`. 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.
+* 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 mergeState(path, target, { timeoutMs = GIT_TIMEOUT_MS$1, maxCommits = MAX_MERGE_STATE_COMMITS } = {}) {
-	const reads = mergeStateReads(target, maxCommits);
-	let step = reads.next();
-	while (!step.done) {
-		const { args, options } = step.value;
-		try {
-			step = reads.next(git$1(path, args, {
-				timeoutMs,
-				...options
-			}));
-		} catch (error) {
-			step = reads.throw(error);
+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;
 		}
 	}
-	return step.value;
+	for (const worktree of worktrees) {
+		const cached = worktree.branch ? readPullRequestCache(worktree.path) : null;
+		if (cached && cached.branch === worktree.branch) worktree.pullRequest = cached.pullRequest;
+	}
 }
-/** `mergeState` without blocking the event loop during Git reads. */
-async function mergeStateAsync(path, target, { timeoutMs = GIT_TIMEOUT_MS$1, maxCommits = MAX_MERGE_STATE_COMMITS, ...execution } = {}) {
-	const reads = mergeStateReads(target, maxCommits);
-	let step = reads.next();
-	while (!step.done) {
-		execution.signal?.throwIfAborted();
-		const { args, options } = step.value;
+/** Kilobytes from `du -sk` output, summed over its lines, or null when it printed none. */
+function parseDuKilobytes(output) {
+	const sizes = [...output.matchAll(/^(\d+)\s/gm)].map((match) => Number(match[1]));
+	return sizes.length ? sizes.reduce((sum, kb) => sum + kb, 0) : null;
+}
+/** The folders inside a checkout that another measurement owns: its linked worktrees and Stim's workspace folder. */
+function nestedFolders(state) {
+	const common = gitCommonDirOnDisk(state.path);
+	return [workspaceDir(state.path), ...common ? linkedWorktreesOnDisk(common).map((entry) => entry.path) : []];
+}
+/** The entries to hand to `du` so it sums `root` without descending into `nested`; `[root]` when none is inside it. */
+function walkTargets(root, nested) {
+	const top = canonicalPath(root);
+	const skip = new Set(nested.map(canonicalPath));
+	const inside = [...skip].filter((path) => path.startsWith(top + sep));
+	if (!inside.length) return [root];
+	const targets = [];
+	const visit = (dir) => {
+		let names;
 		try {
-			step = reads.next(await gitAsync(path, args, {
-				...execution,
-				timeoutMs,
-				...options
-			}));
-		} catch (error) {
-			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
-			execution.signal?.throwIfAborted();
-			step = reads.throw(error);
+			names = readdirSync(dir);
+		} catch {
+			targets.push(dir);
+			return;
 		}
-	}
-	execution.signal?.throwIfAborted();
-	return step.value;
-}
-/** The last fetch timestamp, or null, read without blocking on Git. */
-async function lastFetchedAtAsync(repo, execution = {}) {
-	return fetchTime(await gitQuietAsync(repo, [
-		"rev-parse",
-		"--path-format=absolute",
-		"--git-path",
-		"FETCH_HEAD"
-	], execution));
+		for (const name of names) {
+			const path = join(dir, name);
+			if (skip.has(path)) continue;
+			if (inside.some((nestedPath) => nestedPath.startsWith(path + sep))) visit(path);
+			else targets.push(path);
+		}
+	};
+	visit(top);
+	return targets;
 }
-/** The existing origin/HEAD target, or a refusal, without fetching or blocking on Git. */
-async function localDefaultBranchAsync(repo, execution = {}) {
-	return defaultBranch(repo, await gitQuietAsync(repo, [
-		"symbolic-ref",
-		"--quiet",
-		"refs/remotes/origin/HEAD"
-	], execution));
+function isStale(measure, maxAgeMs, now) {
+	return !measure || now - Date.parse(measure.measuredAt) >= maxAgeMs;
 }
-/** Refreshes origin/HEAD without credential prompts when the last fetch is at least ten minutes old. */
-async function fetchDefaultBranchAsync(repo, now = Date.now(), execution = {}) {
-	execution.signal?.throwIfAborted();
-	const target = await localDefaultBranchAsync(repo, execution);
-	if ("error" in target) return target;
-	const at = await lastFetchedAtAsync(repo, execution);
-	if (at !== null && now - at < 6e5) return target;
-	const branch = target.ref.slice(20);
+function takeWalkClaim() {
 	try {
-		await gitAsync(repo, [
-			"fetch",
-			"--quiet",
-			"--no-tags",
-			"--no-recurse-submodules",
-			"origin",
-			`+refs/heads/${branch}:${target.ref}`
-		], {
-			...execution,
-			write: true,
-			timeoutMs: FETCH_TIMEOUT_MS,
-			env: {
-				...execution.env,
-				GIT_TERMINAL_PROMPT: "0"
-			},
-			omitEnv: execution.omitEnv?.filter((name) => name !== "GIT_TERMINAL_PROMPT")
+		const attempt = tryAcquireClaim({
+			root: diskUsageWalkClaims(),
+			mode: "exclusive",
+			label: "disk usage walk"
 		});
+		if (attempt.pending) releaseClaim(attempt.pending);
+		return attempt.acquired ?? null;
 	} catch (error) {
-		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
-		execution.signal?.throwIfAborted();
-		return { error: `git fetch origin ${branch} failed: ${failure(error)}` };
-	}
-	return target;
-}
-//#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 DU_NICENESS = "19";
-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),
-		diskUsageFailureFile(root),
-		diskUsageCacheFile(join(root, "node_modules")),
-		diskUsageFailureFile(join(root, "node_modules")),
-		diskUsageCacheFile(workspaceDir(root)),
-		diskUsageFailureFile(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
-			});
-		}
+		debugLog.log("disk-walk-claim", { error: String(error?.message ?? error) });
+		return null;
 	}
-	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
-	};
 }
 /**
-* Writes a pull request lookup into the cache `status` and report-only `gc` read. A lookup made without detail is
-* marked `partial`, so `status` asks again for the title, checks and review decision; until then it keeps the title
-* cached for the same pull request, and the checks and review decision cached for the same HEAD.
+* 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 on the whole machine (an ownership claim; a failed walk is recorded so other watchers do not repeat it), at low
+* priority, live environments first, a checkout without the linked worktrees nested in it, 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 recordPullRequestLookup({ path, branch, head }, fact, checkedAt) {
-	let pullRequest = fact ? statusPullRequest(fact, checkedAt) : null;
-	const partial = pullRequest !== null && fact?.title === void 0;
-	const previous = partial ? readPullRequestCache(path) : null;
-	if (pullRequest && previous?.pullRequest?.number === pullRequest.number) {
-		const same = previous.head === head;
-		pullRequest = {
-			...pullRequest,
-			title: previous.pullRequest.title,
-			checks: same ? previous.pullRequest.checks : null,
-			reviewDecision: same ? previous.pullRequest.reviewDecision : null
+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;
+	async function du(targets, claim) {
+		const hold = (child) => {
+			if (child.pid === void 0) return;
+			const captured = captureProcessIdentity(child.pid);
+			if (!captured.ok) throw new Error(`Cannot record the du process: ${captured.reason}`);
+			setClaimChild(claim, {
+				pid: child.pid,
+				processToken: captured.token
+			});
 		};
+		try {
+			markClaimChildPending(claim);
+			return parseDuKilobytes(await exec.runFileAsync("nice", [
+				"-n",
+				DU_NICENESS,
+				"du",
+				"-sk",
+				...targets
+			], {
+				timeoutMs: DU_TIMEOUT_MS,
+				onSpawn: hold
+			}));
+		} catch (error) {
+			const { code, status, stdout } = error;
+			if (code === "ENOENT") duMissing = true;
+			return status === 1 && typeof stdout === "string" ? parseDuKilobytes(stdout) : null;
+		} finally {
+			clearClaimChild(claim);
+		}
 	}
-	const entry = {
-		path,
-		branch,
-		head,
-		checkedAt,
-		pullRequest,
-		...fact ? {
-			containsHead: fact.containsHead,
-			endedAt: fact.endedAt
-		} : {},
-		...partial ? { partial: true } : {}
-	};
-	writeCacheFile(pullRequestCacheFile(path), entry);
-}
-function canonicalPath(path) {
-	try {
-		return realpathSync(path);
-	} catch {
-		return path;
+	function due(path, maxAgeMs) {
+		const failedAt = readDiskUsageFailure(path);
+		return isStale(readDiskUsage(path), maxAgeMs, now()) && (!failedAt || now() - Date.parse(failedAt) >= maxAgeMs);
 	}
-}
-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;
+	async function measure(folders) {
+		for (const { path, maxAgeMs, nested } of folders) {
+			if (duMissing || !due(path, maxAgeMs)) continue;
+			const stamp = () => ({
+				path,
+				measuredAt: new Date(now()).toISOString()
+			});
+			if (!existsSync(path)) {
+				if (!basename(path).startsWith("node_modules")) continue;
+				writeCacheFile(diskUsageCacheFile(path), {
+					...stamp(),
+					bytes: 0
+				});
+				updated();
+				continue;
+			}
+			const claim = takeWalkClaim();
+			if (!claim) return;
+			try {
+				if (!due(path, maxAgeMs)) continue;
+				const targets = walkTargets(path, nested?.() ?? []);
+				const kb = targets.length ? await du(targets, claim) : 0;
+				if (kb === null) {
+					writeCacheFile(diskUsageFailureFile(path), {
+						path,
+						failedAt: new Date(now()).toISOString()
+					});
+					continue;
+				}
+				writeCacheFile(diskUsageCacheFile(path), {
+					...stamp(),
+					bytes: kb * 1024
+				});
+				updated();
+			} finally {
+				releaseClaim(claim);
+			}
+		}
 	}
-}
-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;
+	async function branchHead(repository, branch) {
 		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;
+			return (await gitAsync(repository, [
+				"rev-parse",
+				"--verify",
+				`refs/heads/${branch}`
+			], { timeoutMs: GIT_TIMEOUT_MS$1 })).trim() || null;
 		} catch {
-			result.failed = true;
+			return null;
 		}
-	});
-	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;
+	}
+	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 && !cached.partial && 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];
+				recordPullRequestLookup({
+					path,
+					branch,
+					head
+				}, result.pullRequest, at);
+			});
+			if (results.some((result) => "pullRequest" in result)) updated();
 		}
 	}
-	for (const worktree of worktrees) {
-		const cached = worktree.branch ? readPullRequestCache(worktree.path) : null;
-		if (cached && cached.branch === worktree.branch) worktree.pullRequest = cached.pullRequest;
+	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)
+				]) {
+					const known = folders.get(path);
+					folders.set(path, {
+						path,
+						maxAgeMs: Math.min(known?.maxAgeMs ?? Infinity, maxAgeMs),
+						nested: known?.nested ?? (path === worktree ? () => nestedFolders(state) : void 0)
+					});
+				}
+			}
+			measuring = true;
+			measure([...folders.values()]).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/workspace/merge-state.ts
+const FETCH_TIMEOUT_MS = 3e4;
+/** How old a fetch or a cached lookup can be and still count as fresh. */
+const FETCH_FRESH_MS = 6e5;
+const GIT_TIMEOUT_MS = 6e4;
+const REMOTE_PREFIX = "refs/remotes/origin/";
+const MAX_MERGE_STATE_COMMITS = 2e3;
+function failure(error) {
+	const { code, stderr, message } = error;
+	const text = (code === "ENOBUFS" ? "" : String(stderr ?? "").trim()) || String(message ?? error);
+	return text.split("\n")[0] ?? text;
+}
+function fetchTime(path) {
+	path = path?.trim() ?? null;
+	try {
+		return path ? statSync(path).mtimeMs : null;
+	} catch {
+		return null;
 	}
 }
-/** Kilobytes from `du -sk` output, summed over its lines, or null when it printed none. */
-function parseDuKilobytes(output) {
-	const sizes = [...output.matchAll(/^(\d+)\s/gm)].map((match) => Number(match[1]));
-	return sizes.length ? sizes.reduce((sum, kb) => sum + kb, 0) : null;
+function defaultBranch(repo, ref) {
+	ref = ref?.trim() ?? null;
+	if (!ref?.startsWith(REMOTE_PREFIX)) return { error: `origin/HEAD is not set; run \`git -C ${repo} remote set-head origin --auto\`` };
+	return {
+		ref,
+		name: `origin/${ref.slice(20)}`
+	};
 }
-/** The folders inside a checkout that another measurement owns: its linked worktrees and Stim's workspace folder. */
-function nestedFolders(state) {
-	const common = gitCommonDirOnDisk(state.path);
-	return [workspaceDir(state.path), ...common ? linkedWorktreesOnDisk(common).map((entry) => entry.path) : []];
+function notMerged(detail) {
+	return {
+		merged: false,
+		unknown: false,
+		detail
+	};
 }
-/** The entries to hand to `du` so it sums `root` without descending into `nested`; `[root]` when none is inside it. */
-function walkTargets(root, nested) {
-	const top = canonicalPath(root);
-	const skip = new Set(nested.map(canonicalPath));
-	const inside = [...skip].filter((path) => path.startsWith(top + sep));
-	if (!inside.length) return [root];
-	const targets = [];
-	const visit = (dir) => {
-		let names;
-		try {
-			names = readdirSync(dir);
-		} catch {
-			targets.push(dir);
-			return;
-		}
-		for (const name of names) {
-			const path = join(dir, name);
-			if (skip.has(path)) continue;
-			if (inside.some((nestedPath) => nestedPath.startsWith(path + sep))) visit(path);
-			else targets.push(path);
-		}
+function* git(args, input) {
+	return yield {
+		args: ["--literal-pathspecs", ...args],
+		options: { input }
 	};
-	visit(top);
-	return targets;
 }
-function isStale(measure, maxAgeMs, now) {
-	return !measure || now - Date.parse(measure.measuredAt) >= maxAgeMs;
+function* patch(args, input) {
+	return yield {
+		args: ["--literal-pathspecs", ...args],
+		options: {
+			input,
+			untrimmed: true
+		}
+	};
 }
-function takeWalkClaim() {
+function* probe(args) {
 	try {
-		const attempt = tryAcquireClaim({
-			root: diskUsageWalkClaims(),
-			mode: "exclusive",
-			label: "disk usage walk"
-		});
-		if (attempt.pending) releaseClaim(attempt.pending);
-		return attempt.acquired ?? null;
+		return yield { args };
 	} catch (error) {
-		debugLog.log("disk-walk-claim", { error: String(error?.message ?? error) });
+		if (isTimeoutError(error) || typeof error === "object" && error !== null && "code" in error && error.code === "ENOBUFS") throw error;
 		return null;
 	}
 }
-/**
-* 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 on the whole machine (an ownership claim; a failed walk is recorded so other watchers do not repeat it), at low
-* priority, live environments first, a checkout without the linked worktrees nested in it, 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;
-	async function du(targets, claim) {
-		const hold = (child) => {
-			if (child.pid === void 0) return;
-			const captured = captureProcessIdentity(child.pid);
-			if (!captured.ok) throw new Error(`Cannot record the du process: ${captured.reason}`);
-			setClaimChild(claim, {
-				pid: child.pid,
-				processToken: captured.token
-			});
+function* patchIdCommits(text) {
+	const output = text ? yield* git(["patch-id", "--verbatim"], text) : "";
+	return new Map(output.split("\n").flatMap((line) => {
+		const [id, commit] = line.split(" ");
+		return id && commit ? [[id, commit]] : [];
+	}));
+}
+function* patchIds(text) {
+	return [...(yield* patchIdCommits(text)).keys()];
+}
+function* committedAt(commits) {
+	const times = commits.length ? (yield* 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;
+}
+function* currentBranch() {
+	const ref = (yield* probe([
+		"symbolic-ref",
+		"--quiet",
+		"HEAD"
+	]))?.trim();
+	return ref?.startsWith("refs/heads/") ? ref : null;
+}
+function* upstreamGone(branch) {
+	if (!branch) return false;
+	const [upstream, state] = ((yield* probe([
+		"for-each-ref",
+		"--format=%(upstream)%00%(upstream:track)",
+		branch
+	])) ?? "").trim().split("\0");
+	return Boolean(upstream) && state === "[gone]";
+}
+function* committedOn(branch, head) {
+	if (!branch) return false;
+	const entries = (yield* probe([
+		"reflog",
+		"show",
+		"--format=%H %gs",
+		branch
+	])) ?? "";
+	for (const entry of entries.split("\n")) {
+		const [sha = "", ...subject] = entry.split(" ");
+		if (/^(commit|cherry-pick|rebase|revert)\b/.test(subject.join(" ")) && (yield* probe([
+			"merge-base",
+			"--is-ancestor",
+			sha,
+			head
+		])) !== null) return true;
+	}
+	return false;
+}
+function* mergeStateReads({ ref, name }, maxCommits) {
+	const diffOptions = ["--no-color", "--no-ext-diff"];
+	const noOwnCommits = {
+		merged: false,
+		unknown: false,
+		detail: `no commits of its own beyond ${name}`,
+		noOwnCommits: true
+	};
+	try {
+		const head = yield* git([
+			"rev-parse",
+			"--verify",
+			"HEAD^{commit}"
+		]);
+		const base = yield* git([
+			"merge-base",
+			head,
+			ref
+		]);
+		const branch = yield* currentBranch();
+		if (base === head) {
+			if ((yield* git(["rev-parse", ref])) === head || (yield* git([
+				"rev-list",
+				"--first-parent",
+				"--parents",
+				`${head}..${ref}`
+			])).split("\n").some((line) => line.split(" ")[1] === head) || !(yield* committedOn(branch, head))) return noOwnCommits;
+			const descendants = new Set((yield* git([
+				"rev-list",
+				"--ancestry-path",
+				`${head}..${ref}`
+			])).split("\n"));
+			const landed = (yield* 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: yield* committedAt([landed])
+			};
+		}
+		const aheadCount = Number(yield* 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 = (yield* 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 = function* (range, pathspec = []) {
+			return yield* patch([
+				"log",
+				"-p",
+				"--no-merges",
+				...diffOptions,
+				"--format=commit %H",
+				"--stdin"
+			], pathspec.length ? `${range}\n--\n${pathspec.join("\n")}\n` : `${range}\n`);
+		};
+		const upstream = yield* patchIdCommits(yield* log(`${base}..${ref}`, files));
+		const patchEquivalent = function* (ids) {
+			return {
+				merged: true,
+				into: name,
+				head,
+				coversUnpushed: yield* upstreamGone(branch),
+				mergedAt: yield* committedAt(ids.map((id) => upstream.get(id)))
+			};
+		};
+		const squash = yield* patchIds(yield* patch([
+			"diff",
+			...diffOptions,
+			base,
+			head
+		]));
+		if (squash.length === 1 && upstream.has(squash[0])) return yield* patchEquivalent(squash);
+		if (!(yield* git([
+			"rev-list",
+			"--merges",
+			`${base}..${head}`
+		]))) {
+			const own = yield* patchIds(yield* log(`${base}..${head}`));
+			if (own.length && own.every((id) => upstream.has(id))) return yield* patchEquivalent(own);
+		}
+		return notMerged(`not merged into ${name}`);
+	} catch (error) {
+		const timedOut = isTimeoutError(error) ? { timedOut: true } : {};
+		return {
+			merged: false,
+			unknown: true,
+			detail: `merge state unknown: ${failure(error)}`,
+			...timedOut
 		};
+	}
+}
+/**
+* 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).
+* A HEAD the default branch contains with no commit of its own on the branch is not merged and carries
+* `noOwnCommits`. 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, target, { timeoutMs = GIT_TIMEOUT_MS, maxCommits = MAX_MERGE_STATE_COMMITS } = {}) {
+	const reads = mergeStateReads(target, maxCommits);
+	let step = reads.next();
+	while (!step.done) {
+		const { args, options } = step.value;
 		try {
-			markClaimChildPending(claim);
-			return parseDuKilobytes(await exec.runFileAsync("nice", [
-				"-n",
-				DU_NICENESS,
-				"du",
-				"-sk",
-				...targets
-			], {
-				timeoutMs: DU_TIMEOUT_MS,
-				onSpawn: hold
+			step = reads.next(git$1(path, args, {
+				timeoutMs,
+				...options
 			}));
 		} catch (error) {
-			const { code, status, stdout } = error;
-			if (code === "ENOENT") duMissing = true;
-			return status === 1 && typeof stdout === "string" ? parseDuKilobytes(stdout) : null;
-		} finally {
-			clearClaimChild(claim);
-		}
-	}
-	function due(path, maxAgeMs) {
-		const failedAt = readDiskUsageFailure(path);
-		return isStale(readDiskUsage(path), maxAgeMs, now()) && (!failedAt || now() - Date.parse(failedAt) >= maxAgeMs);
-	}
-	async function measure(folders) {
-		for (const { path, maxAgeMs, nested } of folders) {
-			if (duMissing || !due(path, maxAgeMs)) continue;
-			const stamp = () => ({
-				path,
-				measuredAt: new Date(now()).toISOString()
-			});
-			if (!existsSync(path)) {
-				if (!basename(path).startsWith("node_modules")) continue;
-				writeCacheFile(diskUsageCacheFile(path), {
-					...stamp(),
-					bytes: 0
-				});
-				updated();
-				continue;
-			}
-			const claim = takeWalkClaim();
-			if (!claim) return;
-			try {
-				if (!due(path, maxAgeMs)) continue;
-				const targets = walkTargets(path, nested?.() ?? []);
-				const kb = targets.length ? await du(targets, claim) : 0;
-				if (kb === null) {
-					writeCacheFile(diskUsageFailureFile(path), {
-						path,
-						failedAt: new Date(now()).toISOString()
-					});
-					continue;
-				}
-				writeCacheFile(diskUsageCacheFile(path), {
-					...stamp(),
-					bytes: kb * 1024
-				});
-				updated();
-			} finally {
-				releaseClaim(claim);
-			}
+			step = reads.throw(error);
 		}
 	}
-	async function branchHead(repository, branch) {
+	return step.value;
+}
+/** `mergeState` without blocking the event loop during Git reads. */
+async function mergeStateAsync(path, target, { timeoutMs = GIT_TIMEOUT_MS, maxCommits = MAX_MERGE_STATE_COMMITS, ...execution } = {}) {
+	const reads = mergeStateReads(target, maxCommits);
+	let step = reads.next();
+	while (!step.done) {
+		execution.signal?.throwIfAborted();
+		const { args, options } = step.value;
 		try {
-			return (await gitAsync(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 && !cached.partial && 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];
-				recordPullRequestLookup({
-					path,
-					branch,
-					head
-				}, result.pullRequest, at);
-			});
-			if (results.some((result) => "pullRequest" in result)) updated();
+			step = reads.next(await gitAsync(path, args, {
+				...execution,
+				timeoutMs,
+				...options
+			}));
+		} catch (error) {
+			if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+			execution.signal?.throwIfAborted();
+			step = reads.throw(error);
 		}
 	}
-	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
+	execution.signal?.throwIfAborted();
+	return step.value;
+}
+/** The last fetch timestamp, or null, read without blocking on Git. */
+async function lastFetchedAtAsync(repo, execution = {}) {
+	return fetchTime(await gitQuietAsync(repo, [
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-path",
+		"FETCH_HEAD"
+	], execution));
+}
+/** The existing origin/HEAD target, or a refusal, without fetching or blocking on Git. */
+async function localDefaultBranchAsync(repo, execution = {}) {
+	return defaultBranch(repo, await gitQuietAsync(repo, [
+		"symbolic-ref",
+		"--quiet",
+		"refs/remotes/origin/HEAD"
+	], execution));
+}
+/** Refreshes origin/HEAD without credential prompts when the last fetch is at least ten minutes old. */
+async function fetchDefaultBranchAsync(repo, now = Date.now(), execution = {}) {
+	execution.signal?.throwIfAborted();
+	const target = await localDefaultBranchAsync(repo, execution);
+	if ("error" in target) return target;
+	const at = await lastFetchedAtAsync(repo, execution);
+	if (at !== null && now - at < 6e5) return target;
+	const branch = target.ref.slice(20);
+	try {
+		await gitAsync(repo, [
+			"fetch",
+			"--quiet",
+			"--no-tags",
+			"--no-recurse-submodules",
+			"origin",
+			`+refs/heads/${branch}:${target.ref}`
+		], {
+			...execution,
+			write: true,
+			timeoutMs: FETCH_TIMEOUT_MS,
+			env: {
+				...execution.env,
+				GIT_TERMINAL_PROMPT: "0"
+			},
+			omitEnv: execution.omitEnv?.filter((name) => name !== "GIT_TERMINAL_PROMPT")
 		});
-		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();
+	} catch (error) {
+		if (error instanceof WorkspaceProcessCleanupError || error instanceof Error && "reportCleanup" in error) throw error;
+		execution.signal?.throwIfAborted();
+		return { error: `git fetch origin ${branch} failed: ${failure(error)}` };
 	}
-	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)
-				]) {
-					const known = folders.get(path);
-					folders.set(path, {
-						path,
-						maxAgeMs: Math.min(known?.maxAgeMs ?? Infinity, maxAgeMs),
-						nested: known?.nested ?? (path === worktree ? () => nestedFolders(state) : void 0)
-					});
-				}
-			}
-			measuring = true;
-			measure([...folders.values()]).catch(() => {}).finally(() => {
-				measuring = false;
-			});
-		}
-		if (!checking && now() - checkedAt >= PULL_REQUEST_CHECK_MS) {
-			checking = true;
-			checkedAt = now();
-			checkPullRequests(worktrees).catch(() => {}).finally(() => {
-				checking = false;
-			});
-		}
-	} };
+	return target;
 }
 //#endregion
 //#region src/engine/warm-progress.ts
@@ -860,14 +860,18 @@ function startWarmProgress(root, step, { note, now = Date.now }) {
 		...state,
 		[WARM_KEY]: warming(step)
 	}));
+	const phases = trace.phases("worktree warm");
+	phases.enter(step);
 	return {
 		step(next) {
+			phases.enter(next);
 			write((state) => ours(state) ? {
 				...state,
 				[WARM_KEY]: warming(next)
 			} : state);
 		},
 		finish(succeeded) {
+			phases.end({ ok: succeeded });
 			write((state) => {
 				if (!ours(state)) return state;
 				const { [WARM_KEY]: _, ...rest } = state;
@@ -914,4 +918,4 @@ function workspacePhase(live, state, { now = Date.now(), survey = ownership_clai
 	};
 }
 //#endregion
-export { forgetStatusMeasures as a, FETCH_FRESH_MS as c, localDefaultBranchAsync as d, mergeState as f, createStatusMeasurer as i, fetchDefaultBranchAsync as l, workspacePhase as n, recordPullRequestLookup as o, mergeStateAsync as p, applyStatusMeasures as r, writeCacheFile as s, startWarmProgress as t, lastFetchedAtAsync as u };
+export { lastFetchedAtAsync as a, mergeStateAsync as c, forgetStatusMeasures as d, recordPullRequestLookup as f, fetchDefaultBranchAsync as i, applyStatusMeasures as l, workspacePhase as n, localDefaultBranchAsync as o, writeCacheFile as p, FETCH_FRESH_MS as r, mergeState as s, startWarmProgress as t, createStatusMeasurer as u };