stim 1.20.2 → 1.22.0

package/dist/{trigger-CigAYjeL.mjs → trigger-Cbyc41d_.mjs}

@@ -1,13 +1,23 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { t as spawnEntry } from "./spawn-entry-Dcb7sDUz.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-B9C_zeQC.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
+import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-BwNEtIrP.mjs";
 import { n as stampAttempt, r as due, t as capChildLog } from "./attempt-DW-mQqM7.mjs";
+import { readClaimSet } from "@stim-cli/core/ownership-claim";
 import { closeSync, openSync } from "node:fs";
 import { maintenanceChildLogFile, maintenanceRunClaims, readMaintenanceAttempt, readMaintenanceState } from "@stim-cli/core/state";
-import { readClaimSet } from "@stim-cli/core/ownership-claim";
 //#region src/maintenance/trigger.ts
-function triggerMaintenance(trigger, { argv = process.argv.slice(2), platform = process.platform } = {}) {
+const WARNING_FRESH_MS = 6e5;
+function warnCriticalDisk() {
+	const state = readMaintenanceState();
+	const pressure = state?.pressure;
+	const measured = state?.lastAt.pressure;
+	if (pressure?.diskLevel !== 3 || measured === void 0 || Date.now() - measured > WARNING_FRESH_MS) return;
+	const disk = pressure.disk.map((volume) => `${(volume.freeMb / 1024).toFixed(1)} GB free on ${volume.volume}`);
+	const acting = resolveMaintenanceSettings().mode === "on" ? "Automatic maintenance is stopping idle workspaces and deleting regenerable build outputs" : "Automatic maintenance is not in on mode, so it deletes nothing";
+	console.error(`Stim: disk pressure level 3 (${disk.join(", ")}). ${acting}; run \`stim status\` to see its plan, and free space outside Stim.`);
+}
+function triggerMaintenance(trigger, { argv = process.argv.slice(2), platform = process.platform, warn = true } = {}) {
 	try {
 		const env = process.env;
 		if ([
@@ -20,12 +30,17 @@ function triggerMaintenance(trigger, { argv = process.argv.slice(2), platform =
 			"--version",
 			"-V"
 		].includes(arg))) return;
+		if (warn) warnCriticalDisk();
+		if (argv[0] === "gc") return;
 		if (env.STIM_MAINTENANCE_CHILD === "1" || (env.STIM_HOME || env.CI) && env.STIM_MAINTENANCE === void 0) return;
 		const settings = resolveMaintenanceSettings();
 		if (settings.mode === "off" || due(readMaintenanceState(), settings, Date.now(), readMaintenanceAttempt()).length === 0) return;
 		const claims = readClaimSet(maintenanceRunClaims());
 		if (claims.live.length || claims.unresolved.length) return;
-		stampAttempt(Date.now());
+		const now = Date.now();
+		try {
+			stampAttempt(now);
+		} catch {}
 		capChildLog();
 		const logFile = maintenanceChildLogFile();
 		const fd = openSync(logFile, "a");

package/dist/trigger-yb_nFzPF.mjs

@@ -0,0 +1,2 @@
+import { t as triggerMaintenance } from "./trigger-Cbyc41d_.mjs";
+export { triggerMaintenance };

package/dist/{warm-progress-BuY-Fvfn.mjs → warm-progress-CA3TgT3-.mjs}

@@ -1,76 +1,43 @@
-import { j as ownership_claim_exports } from "./config-BYDxlMY3.mjs";
-import { n as isTimeoutError, r as debugLog, t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { n as gitAsync, r as gitQuiet, t as git } from "./git-DDfFzkMm.mjs";
-import { gt as gitCommonDirOnDisk, xt as linkedWorktreesOnDisk } from "./settings-B717odTD.mjs";
-import { D as withDirLock, a as updateWorkspaceState, d as discoverAgentSessions, l as agentKey, p as ensureWorkspaceStorage, u as attributeAgentSessions, x as workspaceDir } from "./workspace-state-DJt_MMvf.mjs";
-import { I as ownedAvdDirectory } from "./android-Mz_Inn3w.mjs";
-import { o as pullRequestLookups } from "./pull-request-CQ8sPbZa.mjs";
+import { b as debugLog, n as isTimeoutError, r as WorkspaceProcessCleanupError, t as getExecutor, x as ownership_claim_exports } from "./exec-DEoAhcze.mjs";
+import { d as workspaceDir, n as ensureWorkspaceStorage, v as withDirLock } from "./paths-DQtTgsBf.mjs";
+import { l as gitQuietAsync, o as git$1, s as gitAsync } from "./operation-exec-BW0em61G.mjs";
+import { f as agentKey, m as discoverAgentSessions, o as updateWorkspaceState, p as attributeAgentSessions } from "./workspace-state-U08dEzhG.mjs";
+import { wt as linkedWorktreesOnDisk, yt as gitCommonDirOnDisk } from "./settings-C7O8A6ZI.mjs";
+import { V as ownedAvdDirectory } from "./android-C7sVmyI9.mjs";
+import { s as pullRequestLookups } from "./pull-request-W1IuLXDt.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 { clearClaimChild, markClaimChildPending, releaseClaim, setClaimChild, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
 import { captureProcessIdentity } from "@stim-cli/core/process-identity";
-import { randomUUID } from "node:crypto";
-import { homedir } from "node:os";
 //#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 { stderr, message } = error;
-	const text = String(stderr ?? "").trim() || String(message ?? error);
+	const { code, stderr, message } = error;
+	const text = (code === "ENOBUFS" ? "" : String(stderr ?? "").trim()) || String(message ?? error);
 	return text.split("\n")[0] ?? text;
 }
-function fetchedRecently(repo, now) {
-	const path = gitQuiet(repo, [
-		"rev-parse",
-		"--path-format=absolute",
-		"--git-path",
-		"FETCH_HEAD"
-	])?.trim();
+function fetchTime(path) {
+	path = path?.trim() ?? null;
 	try {
-		return Boolean(path) && now - statSync(path).mtimeMs < FETCH_FRESH_MS;
+		return path ? statSync(path).mtimeMs : null;
 	} catch {
-		return false;
+		return null;
 	}
 }
-/**
-* 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 ref = gitQuiet(repo, [
-		"symbolic-ref",
-		"--quiet",
-		"refs/remotes/origin/HEAD"
-	])?.trim();
+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\`` };
-	const branch = ref.slice(20);
-	if (fetchedRecently(repo, now)) return {
-		ref,
-		name: `origin/${branch}`
-	};
-	try {
-		git(repo, [
-			"fetch",
-			"--quiet",
-			"--no-tags",
-			"--no-recurse-submodules",
-			"origin",
-			`+refs/heads/${branch}:${ref}`
-		], {
-			write: true,
-			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}`
+		name: `origin/${ref.slice(20)}`
 	};
 }
 function notMerged(detail) {
@@ -80,129 +47,133 @@ function notMerged(detail) {
 		detail
 	};
 }
-function currentBranch(probe) {
-	const ref = probe([
+function* git(args, input) {
+	return yield {
+		args: ["--literal-pathspecs", ...args],
+		options: { input }
+	};
+}
+function* patch(args, input) {
+	return yield {
+		args: ["--literal-pathspecs", ...args],
+		options: {
+			input,
+			untrimmed: true
+		}
+	};
+}
+function* probe(args) {
+	try {
+		return yield { args };
+	} catch (error) {
+		if (isTimeoutError(error) || typeof error === "object" && error !== null && "code" in error && error.code === "ENOBUFS") throw error;
+		return null;
+	}
+}
+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();
+	]))?.trim();
 	return ref?.startsWith("refs/heads/") ? ref : null;
 }
-function upstreamGone(probe, branch) {
+function* upstreamGone(branch) {
 	if (!branch) return false;
-	const [upstream, state] = (probe([
+	const [upstream, state] = ((yield* probe([
 		"for-each-ref",
 		"--format=%(upstream)%00%(upstream:track)",
 		branch
-	]) ?? "").trim().split("\0");
+	])) ?? "").trim().split("\0");
 	return Boolean(upstream) && state === "[gone]";
 }
-function committedOn(probe, branch, head) {
+function* committedOn(branch, head) {
 	if (!branch) return false;
-	return (probe([
+	const entries = (yield* probe([
 		"reflog",
 		"show",
 		"--format=%H %gs",
 		branch
-	]) ?? "").split("\n").some((entry) => {
+	])) ?? "";
+	for (const entry of entries.split("\n")) {
 		const [sha = "", ...subject] = entry.split(" ");
-		return /^(commit|cherry-pick|rebase|revert)\b/.test(subject.join(" ")) && probe([
+		if (/^(commit|cherry-pick|rebase|revert)\b/.test(subject.join(" ")) && (yield* probe([
 			"merge-base",
 			"--is-ancestor",
 			sha,
 			head
-		]) !== null;
-	});
+		])) !== null) return true;
+	}
+	return false;
 }
-/**
-* 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$1 = (args, input) => git(path, ["--literal-pathspecs", ...args], {
-		timeoutMs,
-		input
-	});
-	const patch = (args, input) => git(path, ["--literal-pathspecs", ...args], {
-		timeoutMs,
-		input,
-		untrimmed: true
-	});
-	const probe = (args) => {
-		try {
-			return git(path, args, { timeoutMs });
-		} catch (error) {
-			if (isTimeoutError(error)) throw error;
-			return null;
-		}
-	};
-	const patchIdCommits = (text) => new Map(text ? git$1(["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$1([
-			"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* mergeStateReads({ ref, name }, maxCommits) {
 	const diffOptions = ["--no-color", "--no-ext-diff"];
-	const noOwnCommits = notMerged(`no commits of its own beyond ${name}`);
+	const noOwnCommits = {
+		merged: false,
+		unknown: false,
+		detail: `no commits of its own beyond ${name}`,
+		noOwnCommits: true
+	};
 	try {
-		const head = git$1([
+		const head = yield* git([
 			"rev-parse",
 			"--verify",
 			"HEAD^{commit}"
 		]);
-		const base = git$1([
+		const base = yield* git([
 			"merge-base",
 			head,
 			ref
 		]);
-		const branch = currentBranch(probe);
+		const branch = yield* currentBranch();
 		if (base === head) {
-			if (git$1(["rev-parse", ref]) === head || git$1([
+			if ((yield* git(["rev-parse", ref])) === head || (yield* git([
 				"rev-list",
 				"--first-parent",
 				"--parents",
 				`${head}..${ref}`
-			]).split("\n").some((line) => line.split(" ")[1] === head) || !committedOn(probe, branch, head)) return noOwnCommits;
-			const descendants = new Set(git$1([
+			])).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 = git$1([
+			])).split("\n"));
+			const landed = (yield* git([
 				"rev-list",
 				"--first-parent",
 				"--reverse",
 				`${head}..${ref}`
-			]).split("\n").find((commit) => descendants.has(commit));
+			])).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])
+				mergedAt: yield* committedAt([landed])
 			};
 		}
-		const aheadCount = Number(git$1([
+		const aheadCount = Number(yield* git([
 			"rev-list",
 			"--count",
 			`${base}..${head}`
@@ -212,45 +183,49 @@ function mergeState(path, { ref, name }, { timeoutMs = GIT_TIMEOUT_MS$1, maxComm
 			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$1([
+		const files = (yield* git([
 			"diff",
 			"--name-only",
 			"--no-renames",
 			"-z",
 			base,
 			head
-		]).split("\0").filter(Boolean);
+		])).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(probe, branch),
-			mergedAt: committedAt(ids.map((id) => upstream.get(id)))
-		});
-		const squash = patchIds(patch([
+		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 patchEquivalent(squash);
-		if (!git$1([
+		if (squash.length === 1 && upstream.has(squash[0])) return yield* patchEquivalent(squash);
+		if (!(yield* git([
 			"rev-list",
 			"--merges",
 			`${base}..${head}`
-		])) {
-			const own = patchIds(log(`${base}..${head}`));
-			if (own.length && own.every((id) => upstream.has(id))) return patchEquivalent(own);
+		]))) {
+			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) {
@@ -263,6 +238,109 @@ function mergeState(path, { ref, name }, { timeoutMs = GIT_TIMEOUT_MS$1, maxComm
 		};
 	}
 }
+/**
+* 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$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);
+		}
+	}
+	return step.value;
+}
+/** `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;
+		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);
+		}
+	}
+	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")
+		});
+	} 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;
@@ -361,6 +439,38 @@ function statusPullRequest(fact, checkedAt) {
 		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.
+*/
+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 canonicalPath(path) {
 	try {
 		return realpathSync(path);
@@ -612,7 +722,7 @@ function createStatusMeasurer({ updated, now = Date.now }) {
 			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) ?? [], {
+			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,
@@ -625,14 +735,11 @@ function createStatusMeasurer({ updated, now = Date.now }) {
 			results.forEach((result, i) => {
 				if (!("pullRequest" in result)) return;
 				const { path, branch, head } = queries[i];
-				const entry = {
+				recordPullRequestLookup({
 					path,
 					branch,
-					head,
-					checkedAt: at,
-					pullRequest: result.pullRequest ? statusPullRequest(result.pullRequest, at) : null
-				};
-				writeCacheFile(pullRequestCacheFile(path), entry);
+					head
+				}, result.pullRequest, at);
 			});
 			if (results.some((result) => "pullRequest" in result)) updated();
 		}
@@ -808,4 +915,4 @@ function workspacePhase(live, state, { now = Date.now(), survey = ownership_clai
 	};
 }
 //#endregion
-export { forgetStatusMeasures as a, createStatusMeasurer as i, workspacePhase as n, fetchDefaultBranch as o, applyStatusMeasures as r, mergeState as s, startWarmProgress as t };
+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 };

package/dist/web-CZ07gd77.mjs

@@ -0,0 +1,2 @@
+import { n as webCommand, t as runWeb } from "./web-DKx6yoFA.mjs";
+export { webCommand as default, runWeb };