@prometheus-ai/agent 0.5.3 → 0.5.8

package/src/tools/gh.ts

@@ -11,13 +11,13 @@ import type {
 } from "@prometheus-ai/agent-core";
 
 import { getWorktreeDir, hashPath, isEnoent, prompt, untilAborted } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { Settings } from "../config/settings";
 import githubDescription from "../prompts/tools/github.md" with { type: "text" };
 import * as git from "../utils/git";
 import type { ToolSession } from ".";
 import { formatShortSha } from "./gh-format";
-import { type CacheStatus, getOrFetchView, resolveGithubCacheAuthKey } from "./github-cache";
+import { type CacheStatus, getOrFetchView, invalidateAllForNumber, resolveGithubCacheAuthKey } from "./github-cache";
 import type { OutputMeta } from "./output-meta";
 import { ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -63,6 +63,44 @@ const GH_ISSUE_FIELDS_NO_COMMENTS = [
 	"updatedAt",
 	"url",
 ];
+
+const GH_ISSUE_STATE_REASON_FIELD = "stateReason";
+
+function ghJsonErrorNamesField(err: unknown, field: string): boolean {
+	if (!(err instanceof Error) || !err.message.includes("Unknown JSON field")) return false;
+	return err.message.includes(`"${field}"`) || err.message.includes(`'${field}'`) || err.message.includes(field);
+}
+
+function dropJsonField(args: readonly string[], field: string): string[] | undefined {
+	const next = [...args];
+	const jsonIndex = next.indexOf("--json");
+	if (jsonIndex < 0) return undefined;
+	const fields = next[jsonIndex + 1];
+	if (!fields) return undefined;
+	const splitFields = fields.split(",");
+	const kept = splitFields.filter(candidate => candidate !== field);
+	if (kept.length === splitFields.length) return undefined;
+	next[jsonIndex + 1] = kept.join(",");
+	return next;
+}
+
+/** Runs `gh --json` for issue data, retrying without optional stateReason on older gh releases. */
+export async function githubIssueJsonWithStateReasonFallback<T>(
+	cwd: string,
+	args: readonly string[],
+	signal: AbortSignal | undefined,
+	options?: git.GhCommandOptions,
+): Promise<T> {
+	try {
+		return await git.github.json<T>(cwd, [...args], signal, options);
+	} catch (err) {
+		if (!ghJsonErrorNamesField(err, GH_ISSUE_STATE_REASON_FIELD)) throw err;
+		const retryArgs = dropJsonField(args, GH_ISSUE_STATE_REASON_FIELD);
+		if (!retryArgs) throw err;
+		return await git.github.json<T>(cwd, retryArgs, signal, options);
+	}
+}
+
 const GH_PR_FIELDS = [
 	"author",
 	"baseRefName",
@@ -192,6 +230,10 @@ const SEARCH_LIMIT_DEFAULT = 10;
 const SEARCH_LIMIT_MAX = 50;
 const FILE_PREVIEW_LIMIT = 50;
 const RUN_WATCH_INTERVAL_DEFAULT = 3;
+const RUN_WATCH_INTERVAL_SLOW = 15;
+const RUN_WATCH_FAST_WINDOW_MS = 60_000;
+const RUN_WATCH_NO_RUNS_GIVE_UP_MS = 90_000;
+const RUN_WATCH_MAX_POLL_FAILURES = 5;
 const RUN_WATCH_GRACE_DEFAULT = 5;
 const RUN_WATCH_TAIL_DEFAULT = 15;
 const RUN_WATCH_TAIL_MAX = 200;
@@ -716,7 +758,9 @@ export function parseSearchDateBound(raw: string, now: Date = new Date()): strin
 
 	const parsedMs = Date.parse(trimmed);
 	if (!Number.isNaN(parsedMs)) {
-		return new Date(parsedMs).toISOString();
+		// GitHub search qualifiers accept seconds precision only
+		// (`YYYY-MM-DDTHH:MM:SSZ`); strip the milliseconds toISOString emits.
+		return new Date(parsedMs).toISOString().replace(/\.\d{3}Z$/, "Z");
 	}
 
 	throw new ToolError(
@@ -1282,6 +1326,16 @@ function isFailedJob(job: GhRunJobSnapshot): boolean {
 	return job.conclusion !== undefined && JOB_FAILURE_CONCLUSIONS.has(job.conclusion);
 }
 
+const GH_RATE_LIMIT_ERROR_PATTERN = /rate limit|HTTP 429|abuse detection/i;
+
+/**
+ * Rate-limit / secondary-limit gh failures are transient; the run_watch poll
+ * loops back off and retry them instead of discarding the whole watch.
+ */
+function isRateLimitedGhError(err: unknown): boolean {
+	return err instanceof ToolError && GH_RATE_LIMIT_ERROR_PATTERN.test(err.message);
+}
+
 function formatJobState(job: GhRunJobSnapshot): string {
 	return job.conclusion ?? job.status ?? "unknown";
 }
@@ -1805,6 +1859,7 @@ async function fetchRunsForCommit(
 	repo: string,
 	headSha: string,
 	signal?: AbortSignal,
+	completedRunJobsCache?: Map<number, GhRunJobSnapshot[]>,
 ): Promise<GhRunSnapshot[]> {
 	// Filter only by `head_sha`. The SHA uniquely identifies the commit, so
 	// adding the GitHub `branch=` filter would wrongly exclude workflow runs
@@ -1831,7 +1886,19 @@ async function fetchRunsForCommit(
 		(response.workflow_runs ?? [])
 			.filter((run): run is GhActionsRunApi & { id: number } => typeof run.id === "number")
 			.map(async run => {
-				const jobs = await fetchRunJobs(cwd, repo, run.id, signal);
+				// Completed runs' job lists are stable until a re-run flips
+				// `status` off "completed"; reuse them across watch polls so a
+				// long watch does not refetch every finished run's jobs. A run
+				// observed non-completed evicts its entry — when the re-run
+				// completes, `status` flips back to "completed" and a stale
+				// entry would serve the FIRST attempt's jobs and logs forever.
+				const completed = run.status === "completed";
+				if (!completed) completedRunJobsCache?.delete(run.id);
+				let jobs = completed ? completedRunJobsCache?.get(run.id) : undefined;
+				if (!jobs) {
+					jobs = await fetchRunJobs(cwd, repo, run.id, signal);
+					if (completed) completedRunJobsCache?.set(run.id, jobs);
+				}
 				return normalizeRunSnapshot(run, jobs);
 			}),
 	);
@@ -1862,12 +1929,13 @@ async function fetchRunJobs(
 			signal,
 			{ repoProvided: true },
 		);
-		const pageJobs = (response.jobs ?? [])
-			.map(job => normalizeRunJob(job))
-			.filter((job): job is GhRunJobSnapshot => job !== null);
+		const rawPage = response.jobs ?? [];
+		const pageJobs = rawPage.map(job => normalizeRunJob(job)).filter((job): job is GhRunJobSnapshot => job !== null);
 		jobs.push(...pageJobs);
 
-		if (pageJobs.length < RUN_JOBS_PAGE_SIZE) {
+		// Compare the raw page length: normalizeRunJob drops malformed items,
+		// and a post-filter short page must not end pagination early.
+		if (rawPage.length < RUN_JOBS_PAGE_SIZE) {
 			break;
 		}
 
@@ -1912,7 +1980,9 @@ async function fetchPrReviewComments(
 			.filter((comment): comment is GhPrReviewComment => comment !== null);
 		reviewComments.push(...pageComments);
 
-		if (pageComments.length < REVIEW_COMMENTS_PAGE_SIZE) {
+		// Compare the raw page length: a dropped malformed item must not end
+		// pagination early and silently lose the remaining pages.
+		if (response.length < REVIEW_COMMENTS_PAGE_SIZE) {
 			break;
 		}
 
@@ -2387,7 +2457,7 @@ function buildTextResult(
 	text: string,
 	sourceUrl?: string,
 	details?: GhToolDetails,
-	options?: { artifactId?: string; artifactLabel?: string },
+	options?: { artifactId?: string; artifactLabel?: string; useless?: boolean },
 ): AgentToolResult<GhToolDetails> {
 	const builder = toolResult<GhToolDetails>(details).text(
 		appendArtifactReference(text, options?.artifactId, options?.artifactLabel ?? "Saved artifact"),
@@ -2395,6 +2465,9 @@ function buildTextResult(
 	if (sourceUrl) {
 		builder.sourceUrl(sourceUrl);
 	}
+	if (options?.useless) {
+		builder.useless();
+	}
 	return builder.done();
 }
 
@@ -2522,7 +2595,7 @@ async function fetchIssueViewFresh(
 	const args = ["issue", "view", identifier];
 	appendRepoFlag(args, repo, identifier);
 	args.push("--json", (includeComments ? GH_ISSUE_FIELDS : GH_ISSUE_FIELDS_NO_COMMENTS).join(","));
-	const data = await git.github.json<GhIssueViewData>(cwd, args, signal, {
+	const data = await githubIssueJsonWithStateReasonFallback<GhIssueViewData>(cwd, args, signal, {
 		repoProvided: Boolean(repo),
 	});
 	const rendered = formatIssueView(data, { issue: identifier, repo, comments: includeComments });
@@ -2553,6 +2626,9 @@ async function fetchPrViewFresh(
  */
 export async function getOrFetchIssue(options: IssueViewLookupOptions): Promise<ViewLookupResult<GhIssueViewData>> {
 	const identifier = requireNonEmpty(options.issue, "issue");
+	if (identifier.startsWith("-")) {
+		throw new ToolError(`invalid issue identifier: ${identifier}. Pass an issue number or URL.`);
+	}
 	const includeComments = options.includeComments ?? true;
 	const authKey = options.cacheAuthKey === undefined ? (resolveGithubCacheAuthKey() ?? null) : options.cacheAuthKey;
 	const urlParse = parseIssueUrl(identifier);
@@ -2890,7 +2966,10 @@ async function fetchPrDiffFresh(
 	appendRepoFlag(args, repo, String(number));
 	const text = await git.github.text(cwd, args, signal, { repoProvided: true, trimOutput: false });
 	const payload = parsePrUnifiedDiff(text);
-	return { rendered: text, sourceUrl: undefined, payload };
+	// `rendered` already carries the verbatim diff; blank the payload copy so
+	// the cache row stores a potentially huge diff once instead of twice.
+	// `getOrFetchPrDiff` rehydrates `unified` from `rendered`.
+	return { rendered: text, sourceUrl: undefined, payload: { unified: "", files: payload.files } };
 }
 
 /**
@@ -2914,7 +2993,8 @@ export async function getOrFetchPrDiff(options: PrDiffLookupOptions): Promise<Vi
 	return {
 		rendered: lookup.rendered,
 		sourceUrl: lookup.sourceUrl,
-		payload: lookup.payload,
+		// Rehydrate the unified text from `rendered` (stored once per row).
+		payload: { unified: lookup.rendered, files: lookup.payload.files },
 		status: lookup.status,
 		fetchedAt: lookup.fetchedAt,
 	};
@@ -2935,9 +3015,35 @@ async function executePrCheckout(
 	const prRefs = prList.length > 0 ? prList : [undefined];
 	const isMulti = prRefs.length > 1;
 
-	const outcomes = await Promise.all(
+	const settled = await Promise.allSettled(
 		prRefs.map(prRef => checkoutPullRequest(session, signal, { prRef, repo, force })),
 	);
+	const outcomes: PrCheckoutOutcome[] = [];
+	const failures: Array<{ prRef: string | undefined; reason: unknown }> = [];
+	for (let i = 0; i < settled.length; i++) {
+		const entry = settled[i];
+		if (entry.status === "fulfilled") outcomes.push(entry.value);
+		else failures.push({ prRef: prRefs[i], reason: entry.reason });
+	}
+	if (failures.length > 0) {
+		throwIfAborted(signal);
+		const failureLines = failures.map(
+			f => `- ${f.prRef ?? "(current branch)"}: ${f.reason instanceof Error ? f.reason.message : String(f.reason)}`,
+		);
+		if (outcomes.length === 0) {
+			if (failures.length === 1) throw failures[0].reason;
+			throw new ToolError(`all ${failures.length} PR checkouts failed:\n${failureLines.join("\n")}`);
+		}
+		// Partial success: report the worktrees that did get created alongside
+		// the failures so the agent does not lose track of them.
+		const sections = outcomes.map(formatPrCheckoutResult);
+		const header = `# ${outcomes.length}/${settled.length} Pull Request Worktrees checked out (${failures.length} failed)`;
+		const text = [header, "", ...joinSections(sections), "", "## Failed", ...failureLines].join("\n").trim();
+		return buildTextResult(text, undefined, {
+			repo,
+			checkouts: outcomes.map(outcomeToSummary),
+		});
+	}
 
 	if (!isMulti) {
 		const [outcome] = outcomes;
@@ -2988,6 +3094,9 @@ async function checkoutPullRequest(
 	options: PrCheckoutOptions,
 ): Promise<PrCheckoutOutcome> {
 	const { prRef, repo, force } = options;
+	if (prRef?.startsWith("-")) {
+		throw new ToolError(`invalid PR identifier: ${prRef}. Pass a PR number, URL, or branch name.`);
+	}
 	const args = ["pr", "view"];
 	if (prRef) args.push(prRef);
 	appendRepoFlag(args, repo, prRef);
@@ -3127,6 +3236,14 @@ async function executePrPush(
 		signal,
 	});
 
+	// A successful push changes what `pr://N` and `pr://N/diff` should show;
+	// drop the cached rows so the canonical "push → re-read diff" flow sees
+	// fresh data instead of a soft-TTL stale snapshot.
+	const pushedPr = parsePullRequestUrl(target.prUrl);
+	if (pushedPr.prNumber !== undefined) {
+		invalidateAllForNumber(pushedPr.prNumber, pushedPr.repo);
+	}
+
 	return buildTextResult(
 		formatPrPushResult({
 			localBranch,
@@ -3296,7 +3413,9 @@ async function executeSearchIssues(
 
 	const response = await git.github.json<GhApiSearchResponse<GhApiSearchIssueItem>>(session.cwd, args, signal);
 	const items = (response.items ?? []).map(apiIssueToSearchResult);
-	return buildTextResult(formatSearchResults("issues", displayQuery, repo, items));
+	return buildTextResult(formatSearchResults("issues", displayQuery, repo, items), undefined, undefined, {
+		useless: items.length === 0,
+	});
 }
 
 async function executeSearchPrs(
@@ -3314,7 +3433,9 @@ async function executeSearchPrs(
 
 	const response = await git.github.json<GhApiSearchResponse<GhApiSearchIssueItem>>(session.cwd, args, signal);
 	const items = (response.items ?? []).map(apiIssueToSearchResult);
-	return buildTextResult(formatSearchResults("pull requests", displayQuery, repo, items));
+	return buildTextResult(formatSearchResults("pull requests", displayQuery, repo, items), undefined, undefined, {
+		useless: items.length === 0,
+	});
 }
 
 async function executeSearchCode(
@@ -3333,7 +3454,9 @@ async function executeSearchCode(
 
 	const response = await git.github.json<GhApiSearchResponse<GhApiSearchCodeItem>>(session.cwd, args, signal);
 	const items = (response.items ?? []).map(apiCodeToSearchResult);
-	return buildTextResult(formatSearchCodeResults(query, repo, items));
+	return buildTextResult(formatSearchCodeResults(query, repo, items), undefined, undefined, {
+		useless: items.length === 0,
+	});
 }
 
 async function executeSearchCommits(
@@ -3351,7 +3474,9 @@ async function executeSearchCommits(
 
 	const response = await git.github.json<GhApiSearchResponse<GhApiSearchCommitItem>>(session.cwd, args, signal);
 	const items = (response.items ?? []).map(apiCommitToSearchResult);
-	return buildTextResult(formatSearchCommitsResults(displayQuery, repo, items));
+	return buildTextResult(formatSearchCommitsResults(displayQuery, repo, items), undefined, undefined, {
+		useless: items.length === 0,
+	});
 }
 
 async function executeSearchRepos(
@@ -3367,7 +3492,9 @@ async function executeSearchRepos(
 
 	const response = await git.github.json<GhApiSearchResponse<GhApiSearchRepoItem>>(session.cwd, args, signal);
 	const items = (response.items ?? []).map(apiRepoToSearchResult);
-	return buildTextResult(formatSearchReposResults(query, items));
+	return buildTextResult(formatSearchReposResults(query, items), undefined, undefined, {
+		useless: items.length === 0,
+	});
 }
 
 async function executeRunWatch(
@@ -3381,9 +3508,24 @@ async function executeRunWatch(
 	const explicitRepo = normalizeOptionalString(params.repo);
 	const runReference = parseRunReference(params.run);
 	const repo = await resolveGitHubRepo(session.cwd, explicitRepo, runReference.repo, signal);
-	const intervalSeconds = RUN_WATCH_INTERVAL_DEFAULT;
 	const graceSeconds = RUN_WATCH_GRACE_DEFAULT;
 	const tail = resolveTailLimit(params.tail);
+	const watchStartMs = Date.now();
+	// Fast polls for the first minute for snappy feedback, then back off:
+	// every commit-watch poll is one runs-list call plus one jobs call per
+	// non-completed run, and long builds must not burn the shared
+	// authenticated REST quota.
+	const currentIntervalSeconds = () =>
+		Date.now() - watchStartMs < RUN_WATCH_FAST_WINDOW_MS ? RUN_WATCH_INTERVAL_DEFAULT : RUN_WATCH_INTERVAL_SLOW;
+	let consecutivePollFailures = 0;
+	const handlePollError = async (err: unknown): Promise<void> => {
+		if (signal?.aborted) throw err;
+		consecutivePollFailures += 1;
+		if (!isRateLimitedGhError(err) || consecutivePollFailures > RUN_WATCH_MAX_POLL_FAILURES) throw err;
+		// Rate-limited: back off with the slow interval and retry instead of
+		// discarding the whole watch (and its accumulated context).
+		await scheduler.wait(RUN_WATCH_INTERVAL_SLOW * 1000, { signal });
+	};
 	if (runReference.runId !== undefined) {
 		const runId = runReference.runId;
 		let pollCount = 0;
@@ -3392,7 +3534,14 @@ async function executeRunWatch(
 			throwIfAborted(signal);
 			pollCount += 1;
 
-			let run = await fetchRunSnapshot(session.cwd, repo, runId, signal);
+			let run: GhRunSnapshot;
+			try {
+				run = await fetchRunSnapshot(session.cwd, repo, runId, signal);
+			} catch (err) {
+				await handlePollError(err);
+				continue;
+			}
+			consecutivePollFailures = 0;
 			const details = buildRunWatchDetails(repo, run, {
 				state: "watching",
 				pollCount,
@@ -3402,7 +3551,7 @@ async function executeRunWatch(
 				details,
 			});
 
-			const failedJobs = run.jobs.filter(isFailedJob);
+			let failedJobs = run.jobs.filter(isFailedJob);
 			const runCompleted = run.status === "completed";
 
 			if (failedJobs.length > 0) {
@@ -3422,13 +3571,28 @@ async function executeRunWatch(
 						}),
 					});
 					await scheduler.wait(graceSeconds * 1000, { signal });
-					run = await fetchRunSnapshot(session.cwd, repo, runId, signal);
+					try {
+						const refetched = await fetchRunSnapshot(session.cwd, repo, runId, signal);
+						const refetchedFailed = refetched.jobs.filter(isFailedJob);
+						// An auto-retry can reset job conclusions between
+						// detection and refetch; keep the originally-detected
+						// failure list (and its snapshot) when the refetch no
+						// longer shows any failures so the watch never ends
+						// with a failure result and zero logs.
+						if (refetchedFailed.length > 0) {
+							run = refetched;
+							failedJobs = refetchedFailed;
+						}
+					} catch (err) {
+						if (signal?.aborted) throw err;
+						// Refetch failure: report from the original snapshot.
+					}
 				}
 
 				const failedJobLogs = await fetchFailedJobLogs(
 					session.cwd,
 					repo,
-					run.jobs.filter(isFailedJob).map(job => ({ run, job })),
+					failedJobs.map(job => ({ run, job })),
 					tail,
 					signal,
 				);
@@ -3456,7 +3620,7 @@ async function executeRunWatch(
 				return buildTextResult(formatRunWatchResult(repo, run, [], tail), run.url, finalDetails);
 			}
 
-			await scheduler.wait(intervalSeconds * 1000, { signal });
+			await scheduler.wait(currentIntervalSeconds() * 1000, { signal });
 		}
 	}
 
@@ -3484,12 +3648,22 @@ async function executeRunWatch(
 	}
 	let pollCount = 0;
 	let settledSuccessSignature: string | undefined;
+	let everSawRuns = false;
+	const completedRunJobsCache = new Map<number, GhRunJobSnapshot[]>();
 
 	while (true) {
 		throwIfAborted(signal);
 		pollCount += 1;
 
-		let runs = await fetchRunsForCommit(session.cwd, repo, headSha, signal);
+		let runs: GhRunSnapshot[];
+		try {
+			runs = await fetchRunsForCommit(session.cwd, repo, headSha, signal, completedRunJobsCache);
+		} catch (err) {
+			await handlePollError(err);
+			continue;
+		}
+		consecutivePollFailures = 0;
+		if (runs.length > 0) everSawRuns = true;
 		const details = buildCommitRunWatchDetails(repo, headSha, branch, runs, {
 			state: "watching",
 			pollCount,
@@ -3501,6 +3675,7 @@ async function executeRunWatch(
 
 		const outcome = getRunCollectionOutcome(runs);
 		if (outcome === "failure") {
+			let failedPairs = runs.flatMap(run => run.jobs.filter(isFailedJob).map(job => ({ run, job })));
 			if (graceSeconds > 0) {
 				const note = `Failure detected. Waiting ${graceSeconds}s to capture concurrent failures before fetching logs.`;
 				onUpdate?.({
@@ -3517,16 +3692,23 @@ async function executeRunWatch(
 					}),
 				});
 				await scheduler.wait(graceSeconds * 1000, { signal });
-				runs = await fetchRunsForCommit(session.cwd, repo, headSha, signal);
+				try {
+					const refetched = await fetchRunsForCommit(session.cwd, repo, headSha, signal, completedRunJobsCache);
+					const refetchedPairs = refetched.flatMap(run => run.jobs.filter(isFailedJob).map(job => ({ run, job })));
+					// Keep the originally-detected failure list when an
+					// auto-retry reset the conclusions during the grace window
+					// (see the run-id branch above).
+					if (refetchedPairs.length > 0) {
+						runs = refetched;
+						failedPairs = refetchedPairs;
+					}
+				} catch (err) {
+					if (signal?.aborted) throw err;
+					// Refetch failure: report from the original snapshots.
+				}
 			}
 
-			const failedJobLogs = await fetchFailedJobLogs(
-				session.cwd,
-				repo,
-				runs.flatMap(run => run.jobs.filter(isFailedJob).map(job => ({ run, job }))),
-				tail,
-				signal,
-			);
+			const failedJobLogs = await fetchFailedJobLogs(session.cwd, repo, failedPairs, tail, signal);
 			const finalDetails = buildCommitRunWatchDetails(repo, headSha, branch, runs, {
 				state: "completed",
 				failedJobLogs,
@@ -3558,7 +3740,8 @@ async function executeRunWatch(
 			}
 
 			settledSuccessSignature = signature;
-			const note = `All known workflow runs completed successfully. Waiting ${intervalSeconds}s to ensure no additional runs appear for this commit.`;
+			const confirmWaitSeconds = currentIntervalSeconds();
+			const note = `All known workflow runs completed successfully. Waiting ${confirmWaitSeconds}s to ensure no additional runs appear for this commit.`;
 			onUpdate?.({
 				content: [
 					{
@@ -3572,11 +3755,23 @@ async function executeRunWatch(
 					note,
 				}),
 			});
-			await scheduler.wait(intervalSeconds * 1000, { signal });
+			await scheduler.wait(confirmWaitSeconds * 1000, { signal });
 			continue;
 		}
 
 		settledSuccessSignature = undefined;
-		await scheduler.wait(intervalSeconds * 1000, { signal });
+		if (!everSawRuns && Date.now() - watchStartMs >= RUN_WATCH_NO_RUNS_GIVE_UP_MS) {
+			// A repo with no Actions configured (or Actions disabled) never
+			// produces a run for this commit; give up with a clear message
+			// instead of polling forever.
+			const elapsedSec = Math.round((Date.now() - watchStartMs) / 1000);
+			return buildTextResult(
+				`No workflow runs found for ${repo}@${formatShortSha(headSha) ?? headSha} after ${elapsedSec}s (${pollCount} polls). The commit may not trigger any GitHub Actions workflows, or Actions may be disabled for this repository. Pass \`run\` to watch a specific run.`,
+				undefined,
+				buildCommitRunWatchDetails(repo, headSha, branch, runs, { state: "completed", pollCount }),
+				{ useless: true },
+			);
+		}
+		await scheduler.wait(currentIntervalSeconds() * 1000, { signal });
 	}
 }