prreviewbuddy 0.56.0 → 0.57.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 0.57.0
+
+**Reviews you marked reviewed now find out when their pull request merges.** Until now the
+workspace server only checked the pull requests of reviews that were queued, saved, Waiting, Done or
+not yet marked reviewed. A review you finished while its pull request was still open stopped being
+checked, so if the pull request merged later, its card kept saying nothing. The server now keeps
+checking those in the background too, for whether each pull request is open, closed or merged and
+nothing else. The checks run every hour and take a limited number of pull requests each time, so
+with many reviews, or a pull request GitHub keeps failing to answer for, it can take a few hours to
+come round to a particular one. A card that had already missed a merge picks it up the same way, and
+shows **Merged** with the time it was found, so it may read "Merged just now" for a pull request that
+merged days ago. A merged pull request is never checked again. One closed without merging keeps
+being checked, since it can be reopened. These background checks never send a notification, and
+never take a turn from the checks of reviews you are still working on.
+
+**Check for updates asks GitHub too.** Pressing **Check for updates** on a review page now also asks
+GitHub whether its pull request is open, closed or merged, and the label beside the pull request
+number updates at once. It does not wait for any background check that happens to be running. It works on any review, including one marked **Done**, and leaves the review
+where it is: still Done, not queued, not checked any more often than before. The checks the page makes
+by itself, every minute and when you come back to the tab, still never contact GitHub.
+
+**A deleted checkout no longer stops other pull requests being checked.** If a review's folder had
+been moved or deleted, the server took the failure to mean the GitHub CLI was missing, and skipped
+every other pull request on GitHub for the rest of that check. Now only that one review's check
+fails, and everything else is checked as normal.
+
+**Done reviews no longer notify when their pull request merges or closes.** A Done review is still
+checked, so its card still says **Changed since done** after a push, a merge, a close or a reopen, and
+a push still sends **PR updated**. A merge, close or reopen is now recorded without a **PR merged** or
+**PR closed** notification. Reviews that are not Done notify as before.
+
 ## 0.56.0
 
 **Work in one focused tab, with Back and Forward that know where you were.** The workspace now has

package/dist/{delete_review-C5bz0Pts.js → delete_review-B3VPeozh.js}

@@ -6471,8 +6471,17 @@ function authStatusArgs(host) {
 *
 * `host` defaults for the one caller that has no repository in hand yet. Both callers that are
 * about to make a real request pass the host they are about to make it against.
+*
+* **A directory that is not there is not a missing `gh`, and is thrown rather than answered.** Node
+* reports a spawn into a missing `cwd` as `ENOENT`, exactly as it reports a missing executable, so
+* without this check a review whose checkout had been deleted read as "`gh` is not installed". The
+* watcher takes that verdict as true of every request reached the same way, and one stale checkout
+* then silenced every other check for the rest of the pass. Neither verdict this function returns is
+* about one directory, so it says neither: the caller gets a failure that belongs to the one
+* review whose checkout it is.
 */
 async function ghAvailable(cwd, env, host = "github.com") {
+	if (!existsSync(cwd)) throw new GhError(`The checkout at ${cwd} no longer exists.`);
 	try {
 		await run(["--version"], cwd, env);
 	} catch {
@@ -6947,7 +6956,15 @@ function readHeadSha(raw) {
 	};
 }
 async function headOf(repo, number, env, cwd) {
-	const availability = await ghAvailable(cwd, env, repo.host);
+	let availability;
+	try {
+		availability = await ghAvailable(cwd, env, repo.host);
+	} catch (error) {
+		return {
+			kind: "failed",
+			detail: error.message
+		};
+	}
 	if (!availability.ok) return {
 		kind: availability.kind,
 		cli: availability.cli

package/dist/main.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $n as resolveAgent, $t as driverGone, At as statedWorkspacePort, Ct as PACKAGE_NAME, Dt as MIN_WORKSPACE_PORT, E as telemetryUploadConsent, Et as MAX_WORKSPACE_PORT, Gt as loadJob, Jn as kissOutcome, Nt as forgeResolver, Ot as parseWorkspacePort, Qn as git, Qt as clearClaim, Rt as checkReview, S as startJob, St as BUILD_VERSION, T as recordTelemetryUploadConsent, Tt as DEFAULT_WORKSPACE_PORT, Vt as allJobs, Wt as isTerminal, Xn as displayRef, Xt as progressSteps, Yn as resolveTarget, Zt as purposeOf, _n as recentWorkspaces, a as wasBlocked, ar as STORE_ROOT, at as modelHelpLines, b as reanalyseReview, bn as summarise, bt as workspaceUrl, cr as agentById, dn as loadWorkspace, dt as readIndexToken, en as isClaimed, er as resolveModel, fn as matchingWorkspaceIds, ft as bootstrapUrl, g as runningJobs, gt as reviewsUrl, h as liveUpdateFor, i as liveJobsFor, ir as CONFIG_PATH, it as removeWorktree, jt as writePortPreference, l as mergeUpdateInto, ln as lineageKeyFor, lt as queueForReview, m as UpdateAlreadyRunningError, mn as positionInLineage, mt as ensureServer, n as deleteReview$1, nn as followedRefName, nr as readAgentPreference, nt as MANAGED_ROOT, or as AGENT_IDS, ot as relativeTime, pn as mutateWorkspace, qn as WITHHELD_REASON, qt as PHASES, rn as groupByLineage, rr as writeAgentPreference, rt as readMarker, sr as DEFAULT_AGENT_ID, u as updateReview, ur as detectAgents, v as recordKissRun, w as record$1, x as runJob, yn as reviewedRepositories, yt as stopServer } from "./delete_review-C5bz0Pts.js";
+import { $n as resolveAgent, $t as driverGone, At as statedWorkspacePort, Ct as PACKAGE_NAME, Dt as MIN_WORKSPACE_PORT, E as telemetryUploadConsent, Et as MAX_WORKSPACE_PORT, Gt as loadJob, Jn as kissOutcome, Nt as forgeResolver, Ot as parseWorkspacePort, Qn as git, Qt as clearClaim, Rt as checkReview, S as startJob, St as BUILD_VERSION, T as recordTelemetryUploadConsent, Tt as DEFAULT_WORKSPACE_PORT, Vt as allJobs, Wt as isTerminal, Xn as displayRef, Xt as progressSteps, Yn as resolveTarget, Zt as purposeOf, _n as recentWorkspaces, a as wasBlocked, ar as STORE_ROOT, at as modelHelpLines, b as reanalyseReview, bn as summarise, bt as workspaceUrl, cr as agentById, dn as loadWorkspace, dt as readIndexToken, en as isClaimed, er as resolveModel, fn as matchingWorkspaceIds, ft as bootstrapUrl, g as runningJobs, gt as reviewsUrl, h as liveUpdateFor, i as liveJobsFor, ir as CONFIG_PATH, it as removeWorktree, jt as writePortPreference, l as mergeUpdateInto, ln as lineageKeyFor, lt as queueForReview, m as UpdateAlreadyRunningError, mn as positionInLineage, mt as ensureServer, n as deleteReview$1, nn as followedRefName, nr as readAgentPreference, nt as MANAGED_ROOT, or as AGENT_IDS, ot as relativeTime, pn as mutateWorkspace, qn as WITHHELD_REASON, qt as PHASES, rn as groupByLineage, rr as writeAgentPreference, rt as readMarker, sr as DEFAULT_AGENT_ID, u as updateReview, ur as detectAgents, v as recordKissRun, w as record$1, x as runJob, yn as reviewedRepositories, yt as stopServer } from "./delete_review-B3VPeozh.js";
 import { basename, dirname, join, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";

package/dist/server.js

@@ -1,4 +1,4 @@
-import { $ as asString, A as createPrState, An as offersLifecycle, At as statedWorkspacePort, B as toneOf, Bn as isQuestionOutstanding, Bt as reviewedShaOf, C as readEvents, Cn as workspaceStamps, D as announceJob, Dn as lifecycleAction, Dt as MIN_WORKSPACE_PORT, E as telemetryUploadConsent, En as isLifecycle, Et as MAX_WORKSPACE_PORT, F as markAllRead, Fn as queueRemove, Ft as remoteHost, G as authorPreview, Gn as recommendationsOf, Gt as loadJob, H as withUsageRecorded, Hn as questionsOutstanding, Ht as endedAt, I as markRead, In as queueStamp, It as fillFileUrlTemplate, J as renderMarkdown, Jn as kissOutcome, Jt as isLiveJob, K as hasAuthorContent, Kn as describeAuthorship, Kt as saveJob, L as pruneNotifications, Ln as readQueue, Lt as checkCodeFreshness, M as eventName, Mn as sectionOf, Mt as claimRequestUrl, N as headline, Nn as queueAdd, O as branchOf, On as lifecycleChip, Ot as parseWorkspacePort, P as listNotifications, Pn as queueAddMany, Pt as forgeFor, Q as renderInlineText, Qn as git, R as readNotification, Rn as doneVerb, Rt as checkReview, Sn as workspaceRevision, St as BUILD_VERSION, T as recordTelemetryUploadConsent, Tn as activityLabel, Tt as DEFAULT_WORKSPACE_PORT, U as EXPLAIN_SIMPLY_PROMPT, Un as reviewerDispositions, Ut as fail, V as unreadCount$1, Vn as issuesOutstanding, Vt as allJobs, W as UNESTABLISHED_MOTIVATION, Wn as processDiscussion, Wt as isTerminal, X as CODE_COPY_CLASS, Xt as progressSteps, Y as CODE_BLOCK_CLASS, Yt as phasesFor, Z as escapeHtml$1, Zn as isCommitReview, Zt as purposeOf, _ as agentEnvOf, _n as recentWorkspaces, _t as serverEntryExists, a as wasBlocked, an as indexReviewGroups, ar as STORE_ROOT, b as reanalyseReview, c as RefreshUnavailableError, cn as latestKissRun, ct as compactQueue, d as refreshPrContext, dn as loadWorkspace, dr as AgentCancelledError, dt as readIndexToken, en as isClaimed, er as resolveModel, et as extractJsonText, f as isUnchanged, fr as AgentUnavailableError, gn as previousKissResult, h as liveUpdateFor, hn as presentedKissRunOf, ht as readServerRecord, i as liveJobsFor, in as indexKeptIds, it as removeWorktree, j as createPrUpdate, jn as parseLifecycle, jt as writePortPreference, k as subjectOf, kn as lifecyclePill, kt as resolveWorkspacePort, l as mergeUpdateInto, lr as agentFor, m as UpdateAlreadyRunningError, n as deleteReview, nn as followedRefName, nr as readAgentPreference, nt as MANAGED_ROOT, o as discardJob, on as kissDecisionRefusal, or as AGENT_IDS, ot as relativeTime$1, p as askCheckout, pn as mutateWorkspace, pt as clearServerRecord, q as GITHUB_MARKDOWN, qn as WITHHELD_REASON, r as lineageIds, rn as groupByLineage, rr as writeAgentPreference, rt as readMarker, s as FETCH_TIMEOUT_MS, sn as kissDecisionsOf, st as activateQueued, t as deleteLineage, tn as decideKissRecommendation, tr as clearAgentPreference, tt as ReviewBeingDeletedError, u as updateReview, un as lineagePosition, ut as settleQueue, vn as reviewedCommit, vt as spawnServer, w as record, wn as LIFECYCLES, wt as feedbackUrl, x as runJob, xn as touchWorkspace, xt as writeServerRecord, y as startKissJob, z as removeNotification, zn as isIssueOutstanding, zt as followedBranch } from "./delete_review-C5bz0Pts.js";
+import { $ as asString, A as createPrState, An as offersLifecycle, At as statedWorkspacePort, B as toneOf, Bn as isQuestionOutstanding, Bt as reviewedShaOf, C as readEvents, Cn as workspaceStamps, D as announceJob, Dn as lifecycleAction, Dt as MIN_WORKSPACE_PORT, E as telemetryUploadConsent, En as isLifecycle, Et as MAX_WORKSPACE_PORT, F as markAllRead, Fn as queueRemove, Ft as remoteHost, G as authorPreview, Gn as recommendationsOf, Gt as loadJob, H as withUsageRecorded, Hn as questionsOutstanding, Ht as endedAt, I as markRead, In as queueStamp, It as fillFileUrlTemplate, J as renderMarkdown, Jn as kissOutcome, Jt as isLiveJob, K as hasAuthorContent, Kn as describeAuthorship, Kt as saveJob, L as pruneNotifications, Ln as readQueue, Lt as checkCodeFreshness, M as eventName, Mn as sectionOf, Mt as claimRequestUrl, N as headline, Nn as queueAdd, O as branchOf, On as lifecycleChip, Ot as parseWorkspacePort, P as listNotifications, Pn as queueAddMany, Pt as forgeFor, Q as renderInlineText, Qn as git, R as readNotification, Rn as doneVerb, Rt as checkReview, Sn as workspaceRevision, St as BUILD_VERSION, T as recordTelemetryUploadConsent, Tn as activityLabel, Tt as DEFAULT_WORKSPACE_PORT, U as EXPLAIN_SIMPLY_PROMPT, Un as reviewerDispositions, Ut as fail, V as unreadCount$1, Vn as issuesOutstanding, Vt as allJobs, W as UNESTABLISHED_MOTIVATION, Wn as processDiscussion, Wt as isTerminal, X as CODE_COPY_CLASS, Xt as progressSteps, Y as CODE_BLOCK_CLASS, Yt as phasesFor, Z as escapeHtml$1, Zn as isCommitReview, Zt as purposeOf, _ as agentEnvOf, _n as recentWorkspaces, _t as serverEntryExists, a as wasBlocked, an as indexReviewGroups, ar as STORE_ROOT, b as reanalyseReview, c as RefreshUnavailableError, cn as latestKissRun, ct as compactQueue, d as refreshPrContext, dn as loadWorkspace, dr as AgentCancelledError, dt as readIndexToken, en as isClaimed, er as resolveModel, et as extractJsonText, f as isUnchanged, fr as AgentUnavailableError, gn as previousKissResult, h as liveUpdateFor, hn as presentedKissRunOf, ht as readServerRecord, i as liveJobsFor, in as indexKeptIds, it as removeWorktree, j as createPrUpdate, jn as parseLifecycle, jt as writePortPreference, k as subjectOf, kn as lifecyclePill, kt as resolveWorkspacePort, l as mergeUpdateInto, lr as agentFor, m as UpdateAlreadyRunningError, n as deleteReview, nn as followedRefName, nr as readAgentPreference, nt as MANAGED_ROOT, o as discardJob, on as kissDecisionRefusal, or as AGENT_IDS, ot as relativeTime$1, p as askCheckout, pn as mutateWorkspace, pt as clearServerRecord, q as GITHUB_MARKDOWN, qn as WITHHELD_REASON, r as lineageIds, rn as groupByLineage, rr as writeAgentPreference, rt as readMarker, s as FETCH_TIMEOUT_MS, sn as kissDecisionsOf, st as activateQueued, t as deleteLineage, tn as decideKissRecommendation, tr as clearAgentPreference, tt as ReviewBeingDeletedError, u as updateReview, un as lineagePosition, ut as settleQueue, vn as reviewedCommit, vt as spawnServer, w as record, wn as LIFECYCLES, wt as feedbackUrl, x as runJob, xn as touchWorkspace, xt as writeServerRecord, y as startKissJob, z as removeNotification, zn as isIssueOutstanding, zt as followedBranch } from "./delete_review-B3VPeozh.js";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHash, timingSafeEqual } from "node:crypto";
@@ -6371,12 +6371,14 @@ function writeJsonAtomically(path, value) {
 * Keyed by request (`requestKey` in `pr_watch.ts`) for the reason `watch.json` is: Update review
 * writes a new workspace record, and the request is the thing that persists across them.
 *
-* Written only by the watcher, so single-writer, and atomically, because the read below treats
-* anything unparsable as nothing known -- and a store that forgot every state would then record the
+* Three writers, all in `pr_watch.ts`: the five-minute watcher, the hourly pass for reviews it does
+* not check, and a press of Check for updates. All three go through `persistPrStates`, which reads
+* the file, keeps the newer observation of each request and writes, with nothing awaited between,
+* so none can take back a later one's answer. Written atomically, because the read below treats anything unparsable as nothing known -- and a store that forgot every state would then record the
 * next observation of each as a first one, which is silent. Losing it costs badges, not duplicates.
 */
 var PR_STATES_PATH = join(STORE_ROOT, "pr_states.json");
-var VERSION$1 = 1;
+var VERSION$2 = 1;
 var STATES = [
 	"open",
 	"merged",
@@ -6387,7 +6389,7 @@ function readPrStates() {
 	try {
 		const parsed = JSON.parse(readFileSync(PR_STATES_PATH, "utf8"));
 		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
-		if (parsed.version !== VERSION$1) return {};
+		if (parsed.version !== VERSION$2) return {};
 		const entries = parsed.entries;
 		if (!entries || typeof entries !== "object" || Array.isArray(entries)) return {};
 		return normalise$1(entries);
@@ -6397,7 +6399,7 @@ function readPrStates() {
 }
 function writePrStates(states) {
 	return writeJsonAtomically(PR_STATES_PATH, {
-		version: VERSION$1,
+		version: VERSION$2,
 		entries: states
 	});
 }
@@ -6431,6 +6433,59 @@ function normalise$1(entries) {
 	return states;
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/pr_state_checks_store.ts
+/**
+* When the slow pull request state pass last tried each request, and how often it has failed.
+*
+* The rotation's bookkeeping for `reconcileCycle` in `pr_watch.ts`, and nothing else. In the
+* `watch.json` entry shape, using only `polledAt` and `failures`, so `orderForCycle` and
+* `isBackedOff` rotate and back off this pass by exactly the rules the five-minute watcher uses.
+*
+* **Its own file**, because neither existing one can hold it. `watch.json` is pruned to the reviews
+* the five-minute watcher checks, which are exactly the ones this pass does not. `pr_states.json`
+* says when the forge last *answered* (`observedAt`), and ordering by success would park a request
+* whose checks keep failing at the front for ever, starving everything behind it. Last attempted
+* and last succeeded are different questions, so they live in different places.
+*
+* Losing it costs nothing worse than one pass asking in a different order. Best-effort read,
+* atomic write, like its neighbours.
+*/
+var PR_STATE_CHECKS_PATH = join(STORE_ROOT, "pr_state_checks.json");
+var VERSION$1 = 1;
+/** Keyed by `requestKey`. Only `polledAt` and `failures` are ever written. */
+function readPrStateChecks() {
+	try {
+		const parsed = JSON.parse(readFileSync(PR_STATE_CHECKS_PATH, "utf8"));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		if (parsed.version !== VERSION$1) return {};
+		const entries = parsed.entries;
+		if (!entries || typeof entries !== "object" || Array.isArray(entries)) return {};
+		const checks = {};
+		for (const [key, value] of Object.entries(entries)) {
+			if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+			const raw = value;
+			checks[key] = {
+				...typeof raw.polledAt === "number" ? { polledAt: raw.polledAt } : {},
+				...typeof raw.failures === "number" ? { failures: raw.failures } : {}
+			};
+		}
+		return checks;
+	} catch {
+		return {};
+	}
+}
+function writePrStateChecks(checks) {
+	const entries = {};
+	for (const [key, entry] of Object.entries(checks)) entries[key] = {
+		...entry.polledAt === void 0 ? {} : { polledAt: entry.polledAt },
+		...entry.failures === void 0 ? {} : { failures: entry.failures }
+	};
+	return writeJsonAtomically(PR_STATE_CHECKS_PATH, {
+		version: VERSION$1,
+		entries
+	});
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/watch_store.ts
 /**
 * What the PR watcher has already seen, and already said.
@@ -6594,6 +6649,14 @@ function normalise(entries) {
 * feel real-time about an event that is not urgent.
 */
 var WATCH_INTERVAL_MS = 3e5;
+/**
+* How often the slow pull request state pass runs. See `reconcileCycle`.
+*
+* Chosen by what being late costs, the way `WATCH_INTERVAL_MS` is. This pass covers reviews the
+* reviewer has finished with, so the only cost of lateness is a card saying "open" for up to an hour
+* after a merge. An hour is short enough that nobody tidying their list finds it stale.
+*/
+var RECONCILE_INTERVAL_MS = 36e5;
 function isBranchCandidate(candidate) {
 	return candidate.request === void 0;
 }
@@ -6846,6 +6909,7 @@ async function watchCycle(deps = defaultDeps(), options = {}) {
 	const state = migrated(deps);
 	if (state === null) return;
 	const prStates = readPrStates();
+	const observedStates = {};
 	const byKey = new Map(dedupeByKey(candidates).map((candidate) => [watchKey(candidate), candidate]));
 	const inScope = [...byKey.keys()].filter((key) => (options.scope?.(byKey.get(key)) ?? true) && prStates[key]?.state !== "merged");
 	const budget = options.budget ?? {
@@ -6879,7 +6943,10 @@ async function watchCycle(deps = defaultDeps(), options = {}) {
 			continue;
 		}
 		if (observed.kind === "unresolved") continue;
-		if (observed.prState !== void 0 && !isBranchCandidate(candidate)) recordPrState(candidate, key, observed.sha, observed.prState, prStates, now);
+		if (observed.prState !== void 0 && !isBranchCandidate(candidate)) {
+			recordPrState(candidate, key, observed.sha, observed.prState, prStates, seenAt, candidate.done);
+			if (prStates[key]) observedStates[key] = prStates[key];
+		}
 		const lastSeen = state[key]?.observedSha;
 		state[key] = {
 			...state[key],
@@ -6900,7 +6967,45 @@ async function watchCycle(deps = defaultDeps(), options = {}) {
 	if (deps.cancelled?.() === true) return;
 	writeWatch(state);
 	pruneWatch([...byKey.keys()]);
-	writePrStates(prunedPrStates(prStates, deps));
+	persistPrStates(observedStates, deps);
+}
+/**
+* Put what a pass or a press observed into `pr_states.json`, keeping whichever observation of each
+* request is newer.
+*
+* **Merged with what is on disk now, never written over it.** A pass reads the file when it starts
+* and can run for minutes; a press of Check for updates writes the moment its answer arrives,
+* without waiting for any pass. Writing a pass's whole snapshot back at the end would take back
+* whatever a press wrote meanwhile, and queueing the press behind the pass instead would make a
+* press wait out up to twenty slow requests and then write an answer older than the pass's.
+*
+* So each writer contributes only the requests it asked about, and per request **the later
+* `observedAt` wins**. That is the only ordering that means anything: whatever GitHub said last is
+* true. A merge cannot be taken back by an older "open", because nothing can be observed open after
+* it merged.
+*
+* Synchronous from the read to the write, so in this process no other writer can come between
+* them. `changedAt` is worked out against what is on disk, not against the writer's snapshot, since
+* that is the state this observation actually follows.
+*/
+function persistPrStates(observed, prune) {
+	const onDisk = readPrStates();
+	for (const [key, mine] of Object.entries(observed)) {
+		const theirs = onDisk[key];
+		if (theirs === void 0) onDisk[key] = mine;
+		else if (theirs.observedAt > mine.observedAt) continue;
+		else if (theirs.state === mine.state) {
+			const { changedAt: _ours, ...rest } = mine;
+			onDisk[key] = {
+				...rest,
+				...theirs.changedAt === void 0 ? {} : { changedAt: theirs.changedAt }
+			};
+		} else onDisk[key] = {
+			...mine,
+			changedAt: mine.observedAt
+		};
+	}
+	writePrStates(prune ? prunedPrStates(onDisk, prune) : onDisk);
 }
 /**
 * The facts to keep: every request a stored review still refers to. If the store cannot be listed
@@ -6925,13 +7030,19 @@ function prunedPrStates(prStates, deps) {
 * `null` -- the forge answered but did not say -- leaves the stored state alone. An unreadable
 * answer never erases a fact.
 *
+* **`quiet` records the same fact and says nothing.** For a Done review, for the slow pass and for
+* an explicit Check for updates: the reviewer is either finished with the review or looking at it.
+* `changedAt` still moves, deliberately. It is what dates the card and what raises "Changed since
+* done" on a Done one, and "the pull request merged since you marked it done" is a true and useful
+* thing for that card to say. It is only not worth an interruption.
+*
 * Nothing about the review changes. `completedAt` is the reviewer's decision and only Mark reviewed
 * writes it; this module does not load or save a workspace record at all.
 */
-function recordPrState(candidate, key, headSha, observed, prStates, now) {
+function recordPrState(candidate, key, headSha, observed, prStates, now, quiet) {
 	if (observed === null) return;
 	const previous = prStates[key]?.state;
-	if (previous === "open" && observed !== "open") {
+	if (!quiet && previous === "open" && observed !== "open") {
 		const id = `pr-${observed}-${candidate.reviewId}-${headSha}`;
 		if (createPrState({
 			id,
@@ -7106,7 +7217,12 @@ async function announce(candidate, key, observed, state, deps, now) {
 	};
 }
 /**
-* Which reviews are worth watching, from state the product already keeps.
+* Which reviews the five-minute watcher checks for new commits, from state the product already keeps.
+*
+* **One of two eligibility rules, and not the one that decides whether a pull request's state is
+* kept accurate.** That is `needsPrStateTracking`. This one is about the head moving: whether a push
+* is something the reviewer wants to hear about. The two used to be one rule, and a review marked
+* reviewed while its request was open fell out of both, so its merge was never seen.
 *
 * No `watched` flag, because the reviewer has already said what they are working on three times
 * over: the queue is the set they are working through, Saved is the set they mean to come back to,
@@ -7124,10 +7240,35 @@ async function announce(candidate, key, observed, state, deps, now) {
 * no pull request used to be excluded too, having nothing to ask a forge about. It is watched
 * through its branch instead, locally; see `BranchCandidate`.
 */
-function isWatchable(workspace, queued) {
+function needsChangeWatching(workspace, queued) {
 	if (isCommitReview(workspace.changeSet)) return false;
 	return queued.has(workspace.id) || workspace.pinned === true || workspace.completedAt === void 0 || parseLifecycle(workspace.lifecycle) !== void 0;
 }
+/**
+* Whether this review's pull request state should still be kept accurate: whether it is open, closed
+* or merged.
+*
+* **Lifecycle eligibility, not membership of any one pass.** Who actually asks is decided elsewhere:
+*
+*     needsChangeWatching   yes                 -> five-minute watcher (head moves, and state with them)
+*     needsPrStateTracking  yes, not the above  -> hourly pass (`reconcileCycle`, state only)
+*
+* Most reviews this says yes to are already covered by the first row, which records the state from
+* the same request it makes for the head. `prStateCandidates` is the second row.
+*
+* Nothing about the review's workflow enters into it: reviewed, queued, saved, Waiting and Done all
+* leave it unchanged. Whether a review is finished is the reviewer's business; whether its pull
+* request merged is a fact about the world, and the card shows it either way.
+*
+* Merged is the end. A merged request cannot move or reopen, so asking again would only spend
+* somebody's rate limit. Closed is not the end, because a closed request can be reopened.
+*/
+function needsPrStateTracking(workspace, prStates) {
+	if (isCommitReview(workspace.changeSet)) return false;
+	const request = requestOf(workspace);
+	if (!request) return false;
+	return prStates[requestKey(workspace.repoPath, request.number)]?.state !== "merged";
+}
 /** The request a review is attached to, by URL where there is one and by number otherwise. */
 function requestOf(workspace) {
 	const pr = workspace.prContext?.pullRequest;
@@ -7148,7 +7289,8 @@ function candidateOf(workspace) {
 		...branch ? { branch } : {},
 		repo: basename(workspace.repoPath),
 		createdAt: workspace.createdAt,
-		env: agentEnvOf(workspace)
+		env: agentEnvOf(workspace),
+		done: parseLifecycle(workspace.lifecycle)?.state === "done"
 	};
 	if (request) return {
 		...base,
@@ -7193,12 +7335,36 @@ function watchedCandidates() {
 	const found = [];
 	for (const [id] of workspaceStamps()) {
 		const workspace = loadWorkspace(id);
-		if (!workspace || !isWatchable(workspace, queued)) continue;
+		if (!workspace || !needsChangeWatching(workspace, queued)) continue;
 		const candidate = candidateOf(workspace);
 		if (candidate) found.push(candidate);
 	}
 	return found;
 }
+/**
+* The requests the hourly pass asks about: those whose state needs keeping accurate
+* (`needsPrStateTracking`) and that the five-minute watcher does not already cover.
+*
+* The subtraction is by request, not by review. If any analysis of a request is change-watched, the
+* watcher's request for the head carries the state too, and asking again here would double the
+* calls for nothing. In practice what is left is the reviews marked reviewed and left Active,
+* unqueued and unsaved, which is the set nothing used to ask about at all.
+*/
+function prStateCandidates() {
+	const queued = new Set(readQueue());
+	const prStates = readPrStates();
+	const changeWatched = /* @__PURE__ */ new Set();
+	const tracked = [];
+	for (const [id] of workspaceStamps()) {
+		const workspace = loadWorkspace(id);
+		if (!workspace) continue;
+		const candidate = candidateOf(workspace);
+		if (!candidate || isBranchCandidate(candidate)) continue;
+		if (needsChangeWatching(workspace, queued)) changeWatched.add(watchKey(candidate));
+		else if (needsPrStateTracking(workspace, prStates)) tracked.push(candidate);
+	}
+	return dedupeByKey(tracked).filter((candidate) => !isBranchCandidate(candidate) && !changeWatched.has(watchKey(candidate)));
+}
 /** Every stored review's request, watched or not. See `WatchDeps.requestKeys`. */
 function storedRequestKeys() {
 	const keys = /* @__PURE__ */ new Set();
@@ -7262,8 +7428,8 @@ function reviewActivity(groups, watch = readWatch(), prStates = readPrStates())
 }
 /**
 * One review's pull request state, for its page, filed under the same key the list looks up. Null
-* for a review with no request or one never observed: unknown, not open. Only ever what the watcher
-* last saw; nothing here reaches the forge.
+* for a review with no request or one never observed: unknown, not open. Only ever what was last
+* stored; nothing here reaches the forge.
 */
 function prStateOf$1(workspace, states = readPrStates()) {
 	const request = requestOf(workspace);
@@ -7372,6 +7538,133 @@ function startWatching(makeDeps = defaultDeps) {
 		clearInterval(timer);
 	};
 }
+function defaultReconcileDeps() {
+	const { fetchHead, requestKeys, now } = defaultDeps();
+	return {
+		candidates: prStateCandidates,
+		fetchHead,
+		requestKeys,
+		now
+	};
+}
+/**
+* One slow pass: keep pull request state accurate for the reviews the five-minute watcher does not
+* check. See `needsPrStateTracking` for who those are and why.
+*
+* **State only, and always quiet.** It reads no head, writes nothing to `watch.json`, counts no
+* commits and creates no notification of any kind. What it finds is bookkeeping for reviews the
+* reviewer has finished with: the card's badge and its time change, nothing interrupts.
+*
+* Rotated and backed off by `orderForCycle` and `isBackedOff`, the five-minute watcher's own rules,
+* over its own bookkeeping (`pr_state_checks.json`). A failed attempt still moves its request to the
+* back, so requests that keep failing cannot hold the front and starve the rest.
+*
+* Never throws. Cancellation is checked before each request, so a stood-down pass stops asking, and
+* before the writes, so it changes nothing. Unlike `watchCycle` there is no check between the two:
+* nothing in the loop reaches outside memory, because nothing here notifies.
+*/
+async function reconcileCycle(deps = defaultReconcileDeps(), budget = 20) {
+	let candidates;
+	try {
+		candidates = deps.candidates();
+	} catch {
+		return;
+	}
+	const byKey = new Map(dedupeByKey(candidates).map((candidate) => [watchKey(candidate), candidate]));
+	const checks = readPrStateChecks();
+	const prStates = readPrStates();
+	const observedStates = {};
+	const now = deps.now();
+	const unreachable = /* @__PURE__ */ new Set();
+	for (const key of orderForCycle([...byKey.keys()], checks, budget, now, RECONCILE_INTERVAL_MS)) {
+		if (deps.cancelled?.() === true) return;
+		const candidate = byKey.get(key);
+		if (unreachable.has(reachKey(candidate))) continue;
+		const observed = await observeRequest(candidate, deps, unreachable);
+		if (observed.kind !== "head") {
+			checks[key] = {
+				polledAt: now,
+				failures: (checks[key]?.failures ?? 0) + 1
+			};
+			continue;
+		}
+		checks[key] = {
+			polledAt: now,
+			failures: 0
+		};
+		if (observed.prState !== void 0) {
+			recordPrState(candidate, key, observed.sha, observed.prState, prStates, deps.now(), true);
+			if (prStates[key]) observedStates[key] = prStates[key];
+		}
+	}
+	if (deps.cancelled?.() === true) return;
+	persistPrStates(observedStates, deps);
+	writePrStateChecks(Object.fromEntries(Object.entries(checks).filter(([key]) => byKey.has(key))));
+}
+/**
+* Run the slow pass on a timer, and return the stop. The shape of `startWatching`.
+*
+* **Once immediately**, and not only because a server that has been down missed things. The server
+* restarts itself whenever it is rebuilt or upgraded, often more than once an hour, and a pass that
+* waited a full interval after each start could go days without running at all.
+*
+* Through `exclusive`, so it never runs beside `watchCycle` and the two never ask the forge at the
+* same time. `pr_states.json` does not depend on it: see `persistPrStates`.
+*/
+function startReconciling(makeDeps = defaultReconcileDeps) {
+	let running = false;
+	let stopped = false;
+	const run = () => {
+		if (running || stopped) return;
+		running = true;
+		exclusive(() => reconcileCycle({
+			...makeDeps(),
+			cancelled: () => stopped
+		})).catch(() => {}).finally(() => {
+			running = false;
+		});
+	};
+	run();
+	const timer = setInterval(run, RECONCILE_INTERVAL_MS);
+	timer.unref();
+	return () => {
+		stopped = true;
+		clearInterval(timer);
+	};
+}
+/**
+* Ask the forge for one review's pull request state now, because the reviewer pressed Check for
+* updates.
+*
+* **Whatever the review's workflow state.** Done, reviewed, unqueued: an explicit question gets an
+* answer, and still gets one when the stored state is merged. Workflow decides what happens in the
+* background, never what the reviewer may ask.
+*
+* **It changes nothing but the stored state.** No lifecycle, no queue, no `watch.json` and no
+* rotation bookkeeping, so it neither starts nor stops anything watching the review. It is quiet:
+* the reviewer is looking at the answer.
+*
+* **Never behind a pass.** Not through `exclusive`: a press waits for one answer from the forge and
+* nothing else, however slow the pass running beside it. That is safe because of
+* `persistPrStates`, which writes this one answer the moment it arrives and keeps whichever
+* observation of the request is newer, so a pass that finishes afterwards cannot take it back, and
+* this cannot take back anything a pass saw later. Never throws.
+*/
+async function checkPrStateNow(workspace, deps = defaultDeps()) {
+	try {
+		if (isCommitReview(workspace.changeSet)) return;
+		const candidate = candidateOf(workspace);
+		if (!candidate || isBranchCandidate(candidate)) return;
+		const observed = await observeRequest(candidate, deps, /* @__PURE__ */ new Set());
+		if (observed.kind !== "head" || observed.prState === void 0) return;
+		if ((deps.cancelled ?? standingDown)() === true) return;
+		const seenAt = deps.now();
+		const key = watchKey(candidate);
+		const prStates = readPrStates();
+		recordPrState(candidate, key, observed.sha, observed.prState, prStates, seenAt, true);
+		if (prStates[key]) persistPrStates({ [key]: prStates[key] });
+	} catch {}
+}
 //#endregion
 //#region ../../packages/review-harness/src/workspace/reviews_page.ts
 function renderReviewsPage(view) {
@@ -9972,7 +10265,7 @@ async function handle(req, res, options) {
 	if (action === "/job") return send(res, 200, jobReport(workspace));
 	if (action === "/retry") return handleRetry(res, workspace);
 	if (action === "/reanalyse") return handleReanalyse(req, res, workspace);
-	if (action === "/freshness") return handleFreshness(res, workspace, url.searchParams.get("quiet") === "1");
+	if (action === "/freshness") return handleFreshness(res, workspace, url.searchParams.get("quiet") === "1", options.checkPrState ?? checkPrStateNow);
 	if (action === "/fetch") return handleFetchOwn(req, res, workspace);
 	if (action === "/refresh") return handleRefreshPr(res, workspace);
 	if (action === "/update") return handleUpdate(res, workspace);
@@ -10515,9 +10808,10 @@ async function handleFetchUpdates(req, res, indexToken) {
 * Fetch remote updates, from one review's own page, on its own token.
 *
 * The list's fetch scoped to this review: `GET` says whether it applies (the page draws the item
-* only if so, asked after load so rendering never waits on git), `POST` runs it. The review page's
-* Check for updates stays read-only; this is the one explicit act on that page that reaches the
-* network, and it writes remote-tracking refs and nothing else.
+* only if so, asked after load so rendering never waits on git), `POST` runs it. It writes
+* remote-tracking refs and nothing else. The page's other network act is a press of Check for
+* updates, which asks the forge one question, whether the pull request is still open, and writes
+* only the answer.
 */
 async function handleFetchOwn(req, res, workspace) {
 	if (req.method === "GET") return send(res, 200, { fetchable: await isFetchTarget(workspace.id) });
@@ -10959,15 +11253,19 @@ function jobReport(workspace) {
 * The three comparisons, on demand.
 *
 * Separate from the page render so a tab that has been open for an hour can ask again without
-* losing its place — which is the case the button exists for. Read-only and cheap: four git
-* plumbing commands against the local object store, no network anywhere in it.
-*/
-/**
+* losing its place — which is the case the button exists for. The comparisons are read-only and
+* cheap: four git plumbing commands against the local object store.
+*
 * `quiet` is the page checking on its own, on tab return and on a slow timer. It answers exactly as a
-* press does and records nothing: `freshness_checked` says the reviewer asked, and a page left open
-* all afternoon has not asked sixty times.
+* press does, records nothing and **reaches no network**: `freshness_checked` says the reviewer
+* asked, and a page left open all afternoon has not asked sixty times.
+*
+* A press is the reviewer asking, so it is allowed one call to the forge: `checkPrState`, for
+* whether the pull request is open, closed or merged. That is the one network question here, and
+* it is asked before the answer is assembled so the answer carries it.
 */
-async function handleFreshness(res, workspace, quiet) {
+async function handleFreshness(res, workspace, quiet, checkPrState) {
+	if (!quiet) await checkPrState(workspace);
 	const kiss = await kissFreshnessOrNull(workspace);
 	const standing = await standingOrNull(workspace);
 	const report = standing?.freshness ?? null;
@@ -11831,6 +12129,7 @@ function beginRestart() {
 function handOver() {
 	stopSweeping();
 	stopWatching();
+	stopReconciling();
 	clearServerRecord();
 	server.close(() => void replaceThisProcess());
 	server.closeAllConnections();
@@ -11848,6 +12147,7 @@ async function replaceThisProcess() {
 	});
 	stopSweeping = startSweeping();
 	stopWatching = startWatching();
+	stopReconciling = startReconciling();
 }
 /**
 * The replacement is a different process, so a different `startedAt` is what proves it is there.
@@ -11890,9 +12190,11 @@ server.listen(resolveWorkspacePort(), "127.0.0.1", () => {
 server.on("error", () => process.exit(1));
 var stopSweeping = startSweeping();
 var stopWatching = startWatching();
+var stopReconciling = startReconciling();
 for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => {
 	stopSweeping();
 	stopWatching();
+	stopReconciling();
 	clearServerRecord();
 	server.close(() => process.exit(0));
 	server.closeAllConnections();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prreviewbuddy",
-  "version": "0.56.0",
+  "version": "0.57.0",
   "description": "Review a branch or pull request in an isolated checkout, from your terminal, with the coding agent you already have installed.",
   "license": "UNLICENSED",
   "homepage": "https://prreviewbuddy.com",