prreviewbuddy 0.76.9 → 0.78.1

package/dist/server.js

@@ -1,4 +1,4 @@
-import { $ as resolveWorkspacePort, $r as explanationOf, $t as readNotification, A as parsePullRequestLink, Ai as readAgentPreference, An as MANAGED_ROOT, Ar as activityLabel, At as storeArchitecture, Bn as checkCodeFreshness, Br as queueRemove, Bt as branchOf, C as completeRun, Ci as DetachedHeadError, Cn as renderMarkdown, Ct as describeRuntimes, D as relativeTime$1, Di as resolveAgent, Dn as renderInlineText, Dr as workspaceStamps, Dt as partFiles, E as stopRun, Ei as git, En as escapeHtml$1, Er as workspaceRevision, Et as loadArchitecture, Fi as agentById, Fn as removeWorktree, Fr as offersLifecycle, Ft as REPOSITORY_SCOPE, G as stopChild, Gn as forgeResolver, Gr as isQuestionOutstanding, Gt as createPrUpdate, Hn as followedBranch, Hr as readQueue, Ht as categoryOf, I as settleQueue, Ii as agentFor$1, In as requestJobStop, Ir as parseLifecycle, It as ancestorsOf, J as writeServerRecord, Jn as endedAt, Jr as resolvedByConversation, Jt as markAllRead, Kn as fillFileUrlTemplate, Kr as issuesOutstanding, Kt as eventName, L as readIndexToken, Li as detectAgents, Lr as sectionOf, Lt as isArchitectureId, M as runBatch, Mn as holdWorktree, Mr as lifecycleChip, Mt as trackedFiles, N as activateQueued, Ni as STORE_ROOT, Nn as isWorktreeHeld, Nr as lifecycleItemLabel, Nt as ownersOf, O as batchIdentity, Oi as resolveModel, Or as LIFECYCLES, Ot as readArchitecture, P as compactQueue, Pi as AGENT_IDS, Pn as readMarker, Pr as lifecyclePill, Pt as QUOTE_LIMITS, Q as parseWorkspacePort, Qn as saveJob, Qr as explanationActionOf, Qt as pruneNotifications, Ri as AgentCancelledError, Rr as queueAdd, Rt as writeJsonAtomically, S as beginRun, Si as originRemote, Sn as GITHUB_MARKDOWN, Sr as reviewedCommit, St as RUNTIME_WORDS, T as reportRun, Ti as resolveBase, Tn as CODE_COPY_CLASS, Tr as touchWorkspace, Tt as checkArchitecture, U as serverEntryExists, Un as reviewedShaOf, Ur as doneVerb, Ut as createArchitectureNotification, V as readServerRecord, Vn as checkReview, Vr as queueStamp, Vt as subjectOf, W as spawnServer, Wn as fetchHead, Wr as isIssueOutstanding, Wt as createPrState, X as MAX_WORKSPACE_PORT, Xn as isTerminal, Xr as processDiscussion, Xt as markReadForReview, Y as DEFAULT_WORKSPACE_PORT, Yn as fail, Yr as reviewerDispositions, Yt as markRead, Z as MIN_WORKSPACE_PORT, Zn as loadJob, Zr as recommendationsOf, Zt as moveIds, _i as objectWithAnyOf, _n as EXPLAIN_SIMPLY_PROMPT, _r as mutateWorkspace, a as wasBlocked, ai as currentGradeIn, an as unreadCount$1, ar as isClaimed, at as reanalyseReview, b as track, bi as kissOutcome, bn as authorPreview, br as previousKissResult, bt as mapRuntimes, c as RefreshUnavailableError, ci as gradeScale, cn as ASK_REREAD_CEILING_MS, cr as groupByLineage, d as mergeUpdateInto, di as reassessIn, dn as saveRefresh, dr as kissDecisionRefusal, ei as isExplanationAction, en as readStateOf, er as isLiveJob, et as statedWorkspacePort, f as updateReview, fi as sourcePhrase, fn as storedConversation, fr as kissDecisionsOf, gi as extractJsonText, gn as agentEnvOf, gt as BUILD_VERSION, h as liveUpdateFor, hi as asString, hn as isUnchanged, hr as loadWorkspace, i as liveJobsFor, ii as assessmentLookup, in as unreadAround, it as settleReview, j as unsupportedReason, ji as writeAgentPreference, jn as createWorktree, jr as isLifecycle, jt as storedScopes, k as extractPullRequestLinks, ki as clearAgentPreference, kn as ReviewBeingDeletedError, kr as activityAttributes, kt as repositoryKey, l as cancelUpdate, li as isGradeFor, ln as adoptLegacyBaseline, lr as indexKeptIds, lt as readEvents, m as UpdateAlreadyRunningError, mi as followUpFindingId, mn as refreshPrContext, mr as lineagePosition, mt as telemetryUploadConsent, n as deleteReview, ni as ANALYSIS_ONLY, nn as retireNotification, nr as progressSteps, nt as failureOf$1, o as discardJob, oi as findingAssessment, on as withUsageRecorded, or as decideKissRecommendation, ot as runJob, p as askCheckout, pi as wasReassessed, pn as unforeseenFailure, pr as latestKissRun, pt as recordTelemetryUploadConsent, qn as allJobs, qr as questionsOutstanding, qt as listNotifications, r as lineageIds, ri as analysisRefOf, rn as toneOf, rr as purposeOf, rt as prepareReview, s as FETCH_TIMEOUT_MS, si as findingIn, sn as existingPaths, sr as followedRefName, t as deleteLineage, ti as withExplanation, tn as removeNotification, tr as phasesFor, tt as writePortPreference, u as cancellableHere, ui as promptGrade, un as prepareConversationWithin, ur as indexReviewGroups, ut as record, v as startKissJob, vi as describeAuthorship, vn as chatConversationSection, vt as feedbackUrl, w as endRun, wi as isCommitReview, wn as CODE_BLOCK_CLASS, wt as ARCHITECTURE_DIR, x as RUN_KINDS, xi as resolveTarget, xn as hasAuthorContent, xr as recentWorkspaces, xt as recordRuntimeBestEffort, y as isDriving, yi as WITHHELD_REASON, yn as UNESTABLISHED_MOTIVATION, yr as presentedKissRunOf, yt as waitingHistory, z as clearServerRecordOwnedBy, zi as AgentUnavailableError, zn as findExistingReview, zr as queueAddMany, zt as announceJob } from "./delete_review-BX3lu5Q7.js";
+import { $ as resolveWorkspacePort, $n as saveJob, $r as explanationActionOf, $t as pruneNotifications, A as parsePullRequestLink, Ai as git, An as ReviewBeingDeletedError, Ar as activityAttributes, At as repositoryKey, Bi as agentById, Bn as findExistingReview, Br as queueAddMany, Bt as announceJob, C as completeRun, Ci as originRemote, Cn as GITHUB_MARKDOWN, Cr as reviewedCommit, Ct as RUNTIME_WORDS, D as relativeTime$1, Di as AmbiguousRefError, Dn as escapeHtml$1, Dr as workspaceRevision, Dt as loadArchitecture, E as stopRun, Ei as resolveBase, En as CODE_COPY_CLASS, Er as touchWorkspace, Et as checkArchitecture, Fi as readAgentPreference, Fn as readMarker, Fr as lifecyclePill, Ft as QUOTE_LIMITS, G as stopChild, Gn as fetchHead, Gr as isIssueOutstanding, Gt as createPrState, Hi as detectAgents, Hn as checkReview, Hr as queueStamp, Ht as subjectOf, I as settleQueue, Ii as writeAgentPreference, In as removeWorktree, Ir as offersLifecycle, It as REPOSITORY_SCOPE, J as writeServerRecord, Jn as allJobs, Jr as questionsOutstanding, Jt as listNotifications, Kn as forgeResolver, Kr as isQuestionOutstanding, Kt as createPrUpdate, L as readIndexToken, Ln as requestJobStop, Lr as parseLifecycle, Lt as ancestorsOf, M as runBatch, Mi as resolveAgent, Mn as createWorktree, Mr as isLifecycle, Mt as storedScopes, N as activateQueued, Ni as resolveModel, Nn as holdWorktree, Nr as lifecycleChip, Nt as trackedFiles, O as batchIdentity, Oi as shortNameOf, On as renderInlineText, Or as workspaceStamps, Ot as partFiles, P as compactQueue, Pi as clearAgentPreference, Pn as isWorktreeHeld, Pr as lifecycleItemLabel, Pt as ownersOf, Q as parseWorkspacePort, Qn as loadJob, Qr as recommendationsOf, Qt as moveIds, Ri as STORE_ROOT, Rr as sectionOf, Rt as isArchitectureId, S as beginRun, Si as resolveTarget, Sn as hasAuthorContent, Sr as recentWorkspaces, St as recordRuntimeBestEffort, T as reportRun, Ti as isCommitReview, Tn as CODE_BLOCK_CLASS, Tt as ARCHITECTURE_DIR, U as serverEntryExists, Ui as AgentCancelledError, Un as followedBranch, Ur as readQueue, Ut as categoryOf, V as readServerRecord, Vi as agentFor$1, Vn as checkCodeFreshness, Vr as queueRemove, Vt as branchOf, W as spawnServer, Wi as AgentUnavailableError, Wn as reviewedShaOf, Wr as doneVerb, Wt as createArchitectureNotification, X as MAX_WORKSPACE_PORT, Xn as fail$1, Xr as reviewerDispositions, Xt as markRead, Y as DEFAULT_WORKSPACE_PORT, Yn as endedAt, Yr as resolvedByConversation, Yt as markAllRead, Z as MIN_WORKSPACE_PORT, Zn as isTerminal, Zr as processDiscussion, Zt as markReadForReview, _i as extractJsonText, _n as agentEnvOf, _t as BUILD_VERSION, a as wasBlocked, ai as assessmentLookup, an as unreadAround, at as settleReview, b as track, bi as WITHHELD_REASON, bn as UNESTABLISHED_MOTIVATION, br as presentedKissRunOf, bt as waitingHistory, c as RefreshUnavailableError, ci as findingIn, cn as existingPaths, cr as followedRefName, d as mergeUpdateInto, di as promptGrade, dn as prepareConversationWithin, dr as indexReviewGroups, dt as record, ei as explanationOf, en as readNotification, et as statedWorkspacePort, f as updateReview, fi as reassessIn, fn as saveRefresh, fr as kissDecisionRefusal, gi as asString, gn as isUnchanged, gr as loadWorkspace, h as liveUpdateFor, hi as followUpFindingId, hn as refreshPrContext, hr as lineagePosition, ht as telemetryUploadConsent, i as liveJobsFor, ii as analysisRefOf, in as toneOf, ir as purposeOf, it as prepareReview, j as unsupportedReason, ji as refExists, jn as MANAGED_ROOT, jr as activityLabel, jt as storeArchitecture, k as extractPullRequestLinks, ki as shorthandOf, kr as LIFECYCLES, kt as readArchitecture, l as cancelUpdate, li as gradeScale, ln as ASK_REREAD_CEILING_MS, lr as groupByLineage, m as UpdateAlreadyRunningError, mi as wasReassessed, mn as unforeseenFailure, mr as latestKissRun, mt as recordTelemetryUploadConsent, n as deleteReview, ni as withExplanation, nn as removeNotification, nr as phasesFor, nt as failureOf$1, o as discardJob, oi as currentGradeIn, on as unreadCount$1, or as isClaimed, ot as reanalyseReview, p as askCheckout, pi as sourcePhrase, pn as storedConversation, pr as kissDecisionsOf, qn as fillFileUrlTemplate, qr as issuesOutstanding, qt as eventName, r as lineageIds, ri as ANALYSIS_ONLY, rn as retireNotification, rr as progressSteps, rt as observeReview, s as FETCH_TIMEOUT_MS, si as findingAssessment, sn as withUsageRecorded, sr as decideKissRecommendation, st as runJob, t as deleteLineage, ti as isExplanationAction, tn as readStateOf, tr as isLiveJob, tt as writePortPreference, u as cancellableHere, ui as isGradeFor, un as adoptLegacyBaseline, ur as indexKeptIds, ut as readEvents, v as startKissJob, vi as objectWithAnyOf, vn as EXPLAIN_SIMPLY_PROMPT, vr as mutateWorkspace, w as endRun, wi as DetachedHeadError, wn as renderMarkdown, wt as describeRuntimes, x as RUN_KINDS, xi as kissOutcome, xn as authorPreview, xr as previousKissResult, xt as mapRuntimes, y as isDriving, yi as describeAuthorship, yn as chatConversationSection, yt as feedbackUrl, z as clearServerRecordOwnedBy, zi as AGENT_IDS, zr as queueAdd, zt as writeJsonAtomically } from "./delete_review-BHOzMQ0_.js";
 import { basename, isAbsolute, join, relative, resolve } from "node:path";
 import { execFile } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
@@ -310,9 +310,13 @@ function cardLifecycleChip(pinned, lifecycle, activity) {
 * The two numbers are different questions and only both worth asking once they differ. A page of
 * thirteen branches reviewed once each would read "13 reviews · 13 branches", which invites the
 * reader to work out what the distinction is on the one page where there isn't one.
+*
+* `of` is every review on the page, given while the search or a filter is narrowing the list:
+* "12 of 71 reviews" says the list is filtered and by how much, where "12 reviews" reads as all
+* there are.
 */
-function countLabel(reviews, branches) {
-	const label = `${reviews} review${reviews === 1 ? "" : "s"}`;
+function countLabel(reviews, branches, of) {
+	const label = of === void 0 ? `${reviews} review${reviews === 1 ? "" : "s"}` : `${reviews} of ${of} review${of === 1 ? "" : "s"}`;
 	if (reviews === branches) return label;
 	return `${label} · ${branches} branch${branches === 1 ? "" : "es"}`;
 }
@@ -9475,9 +9479,17 @@ function renderControls(queued, authors, anyRequest) {
       </select>
     </label>
     ${anyRequest ? renderPrFilter() : ""}
+    ${renderClearFilters()}
   </div>`;
 }
 /**
+* Puts the search and every filter back at once. Hidden until the browser finds one narrowing the
+* list: the hash is the browser's to read, and without script there is nothing to clear.
+*/
+function renderClearFilters() {
+	return `<button type="button" class="prb-index-clear" data-clear-filters hidden><span aria-hidden="true">×</span> Clear filters</button>`;
+}
+/**
 * The pull request's state upstream, beside Review state and not inside it, so the two combine.
 *
 * Absent when no card is of a pull request, for the author filter's reason: a select whose every
@@ -9505,11 +9517,16 @@ var GITHUB_MARK = "<svg class=\"prb-index-forge-mark\" viewBox=\"0 0 16 16\" wid
 *
 * Absent when no card carries a login, which is every page of local-branch reviews: a dropdown
 * whose only choice is Everyone is not a choice.
+*
+* The button holds the chosen name where the browser draws a select's menu itself, so a long one
+* can be cut short inside the box's fixed width (shell.css). A browser that does not parses the
+* button and its contents away and draws the select as it always has.
 */
 function renderAuthorFilter(authors) {
 	if (authors.length === 0) return "";
 	return `<label class="prb-index-status prb-index-forge">${GITHUB_MARK}Author:
       <select name="author" data-author-filter aria-label="Filter by pull request author">
+        <button><selectedcontent></selectedcontent></button>
         <option value="">Everyone</option>${authors.map((author) => `<option value="${escapeHtml$1(author.handle)}">${escapeHtml$1(authorOptionLabel(author))}</option>`).join("")}
       </select>
     </label>`;
@@ -10688,7 +10705,8 @@ var TOPICS = [
       <li><code>prreviewbuddy open</code> to list the reviews you have and open this workspace</li>
     </ul>
     <p>Or press <kbd class="prb-kbd">⌘P</kbd> (<kbd class="prb-kbd">Ctrl+P</kbd> elsewhere) to add a
-    review from here. <code>prreviewbuddy help</code> lists every command, and
+    review from here. The panel follows the reviews it started while it stays open, and closing it
+    stops nothing. <code>prreviewbuddy help</code> lists every command, and
     <code>prreviewbuddy review --help</code> every option a review takes.</p>
     <p>There is no account and no API key. PR Review Buddy uses the coding agent installed on your
     machine and that agent's existing authentication, and never asks you for a credential.</p>`
@@ -11598,16 +11616,24 @@ function createSlots(capacity) {
 }
 /** How many pull requests one submission may name. See `MAX_PULL_REQUESTS_PER_BATCH`. */
 var MAX_BATCH = 20;
-/** How long a finished batch stays answerable, for a panel that is still open on it. */
+/**
+* How long a finished batch stays answerable once nobody is asking about it. An open panel keeps
+* asking (`KEEPALIVE` in the client is well inside this), so a batch is only forgotten after its
+* panel has gone, and its Retry with it.
+*/
 var FINISHED_BATCH_TTL_MS = 6e5;
 function realAddReviewDeps() {
 	return {
 		resolveAgent: (flag) => resolveAgent(flag ? { flag } : {}),
-		agents: async () => (await detectAgents()).map((agent) => ({
-			id: agent.id,
-			displayName: agent.displayName,
-			installed: agent.state === "installed"
-		})),
+		agents: async () => (await detectAgents()).map((agent) => {
+			const modelHelp = modelHelpOf(agent.id);
+			return {
+				id: agent.id,
+				displayName: agent.displayName,
+				installed: agent.state === "installed",
+				...modelHelp ? { modelHelp } : {}
+			};
+		}),
 		folders: () => discoverWorkingFolders(),
 		summaries: () => recentWorkspaces(Number.MAX_SAFE_INTEGER),
 		remoteOf: originRemote,
@@ -11631,6 +11657,8 @@ function realAddReviewDeps() {
 		findExisting: findExistingReview,
 		prepare: prepareReview,
 		settle: (workspaceId) => settleReview(workspaceId, "standard"),
+		observe: (workspaceId) => observeReview(workspaceId),
+		commitPresent: (root, sha) => refExists(root, sha),
 		track,
 		chooseFolder: folderChooser(),
 		concurrency: 2,
@@ -11646,6 +11674,13 @@ function realAddReviewDeps() {
 		home: homedir()
 	};
 }
+function modelHelpOf(agentId) {
+	try {
+		return agentById(agentId).modelSelectionHelp;
+	} catch {
+		return;
+	}
+}
 function agentNameOf(agentId) {
 	try {
 		return agentById(agentId).displayName;
@@ -11653,10 +11688,60 @@ function agentNameOf(agentId) {
 		return agentId;
 	}
 }
-var refuse = (status, error) => ({
+var refuse = (status, error, extra = {}) => ({
 	status,
-	body: { error }
+	body: {
+		error,
+		...extra
+	}
 });
+function baseChoiceOf(error) {
+	const option = (where) => {
+		const matched = where === "remote" ? error.remote : error.local;
+		const commits = where === "remote" ? error.ranges?.remote : error.ranges?.local;
+		return {
+			base: shorthandOf(matched.ref),
+			display: where === "remote" ? shorthandOf(matched.ref) : shortNameOf(matched.ref),
+			where,
+			...commits ? { commits: commits.length } : {}
+		};
+	};
+	return {
+		name: shortNameOf(error.local.ref),
+		discovered: error.discovered,
+		...error.divergence ? { divergence: error.divergence } : {},
+		options: [option("remote"), option("local")]
+	};
+}
+/**
+* What the panel says for an error a review could not get past.
+*
+* Two errors are known by their class and said in the panel's own words. Anything else keeps its
+* message, which is already written for a person, but only its first paragraph is the sentence:
+* the rest (ref listings, commands to run) goes behind Technical details, kept whole for whoever
+* needs to diagnose it.
+*/
+function refusalOf(error) {
+	const text = message(error);
+	if (error instanceof AmbiguousRefError) {
+		const choice = baseChoiceOf(error);
+		return {
+			error: `\`${choice.name}\` is both a local and a remote branch, and they are different commits. Choose which one to compare against.`,
+			detail: text,
+			baseChoice: choice
+		};
+	}
+	if (error instanceof DetachedHeadError) return { error: "This folder is on a detached HEAD, so there is no branch to review. Check out a branch in it, or review its pull request instead." };
+	return briefly(text);
+}
+/** A message's first paragraph as the sentence, and the whole of it as the detail when there is more. */
+function briefly(text) {
+	const first = text.split(/\n\s*\n/)[0].trim();
+	return first && first !== text.trim() ? {
+		error: first,
+		detail: text
+	} : { error: text };
+}
 /** A path as a person reads it, with their home folder as `~`. */
 function displayPath(path, home) {
 	return home && (path === home || path.startsWith(`${home}/`)) ? `~${path.slice(home.length)}` : path;
@@ -11685,15 +11770,15 @@ function unresolvedAgent(resolution) {
 * harness's own fallback: an id is always passed down, so `startJob` never has to guess.
 */
 async function agentFor(flag, deps) {
-	if (flag !== void 0 && typeof flag !== "string") return refuse(400, "Say which agent by its id.");
+	if (flag !== void 0 && typeof flag !== "string") return refuse(400, "Say which agent by its id.", { field: "agent" });
 	const resolution = await deps.resolveAgent(flag || void 0);
 	if (resolution.kind === "resolved") return { agentId: resolution.agent.id };
-	if (resolution.kind === "ambiguous") return refuse(400, "More than one review agent is installed. Choose one under Review options.");
-	return refuse(resolution.kind === "unknown-id" ? 400 : 409, unresolvedAgent(resolution));
+	if (resolution.kind === "ambiguous") return refuse(400, "More than one review agent is installed. Choose one under Review options.", { field: "agent" });
+	return refuse(resolution.kind === "unknown-id" ? 400 : 409, unresolvedAgent(resolution), { field: "agent" });
 }
 function modelOf(value) {
 	if (value === void 0 || value === null || value === "") return void 0;
-	if (typeof value !== "string" || value.length > 200) return refuse(400, "The model must be a short name.");
+	if (typeof value !== "string" || value.length > 200) return refuse(400, "The model must be a short name.", { field: "model" });
 	return value.trim() || void 0;
 }
 /**
@@ -11802,38 +11887,115 @@ async function previewPullRequests(text, deps) {
 }
 var batches = /* @__PURE__ */ new Map();
 function forgetFinished(now) {
-	for (const [id, batch] of batches) if (batch.finishedAt !== null && now - batch.finishedAt > FINISHED_BATCH_TTL_MS) batches.delete(id);
+	for (const [id, batch] of batches) if (batch.finishedAt !== null && now - Math.max(batch.finishedAt, batch.seenAt) > FINISHED_BATCH_TTL_MS) batches.delete(id);
 }
 function newBatch(rows) {
 	forgetFinished(Date.now());
+	const now = Date.now();
 	const batch = {
 		id: randomUUID(),
 		rows,
-		finishedAt: null
+		finishedAt: now,
+		seenAt: now,
+		running: 0,
+		rerun: () => {}
 	};
 	batches.set(batch.id, batch);
 	return batch;
 }
+/**
+* Count work against a batch, inside the restart guard. The batch is finished only when nothing
+* counted against it is still going, so a retry reopens a batch an open panel can then follow again.
+*/
+function follow(batch, work, deps, driving = true) {
+	batch.running += 1;
+	batch.finishedAt = null;
+	(driving ? deps.track(work) : work).catch(() => {}).finally(() => {
+		batch.running -= 1;
+		if (batch.running === 0) batch.finishedAt = Date.now();
+	});
+}
+function fail(row, error) {
+	const refusal = refusalOf(error);
+	row.status = "failed";
+	row.reason = refusal.error;
+	if (refusal.detail) row.detail = refusal.detail;
+}
 var rowsOf = (batch) => batch.rows.map((row) => ({ ...row }));
 /**
 * Create the review for a row's target, or find the one it has, under the per-target lock. The
 * caller holds an analysis slot: nothing is created without one, so nothing created waits.
 */
-async function prepareRow(row, target, agentId, model, deps) {
-	const prepared = await oneCreationAtATime(target, () => deps.prepare(target, agentId, false, model));
+/**
+* `fresh` is a fresh start's: a new review of the target as it is now, keeping whatever review the
+* branch or request already has, as `--fresh` does. Without it the lookup finds the latest review of
+* the same branch or request, which for a fresh start is the very failure being started over.
+*/
+async function prepareRow(row, target, agentId, model, deps, fresh = false) {
+	const prepared = await oneCreationAtATime(target, () => deps.prepare(target, agentId, fresh, model));
 	row.reviewId = prepared.kind === "new" ? prepared.workspaceId : prepared.existing.id;
-	if (prepared.kind === "existing") row.status = "already-reviewed";
+	if (prepared.kind === "existing") row.status = prepared.existing.inProgress ? "reviewing" : "already-reviewed";
 	else row.status = "reviewing";
 	if (prepared.kind === "resume") row.kept = keptOf(prepared.failure.agentId, prepared.failure.requestedModel, deps);
+	else delete row.kept;
 	return prepared;
 }
-async function settleRow(row, deps) {
-	const settled = await deps.settle(row.reviewId);
+/**
+* Take a prepared row to its end. A new or resumed review is run here, holding the slot. One that
+* something else is already analysing is watched instead, never driven: the watch is handed to the
+* batch rather than awaited, so the caller returns, and its slot goes back, at once, while the row
+* stays Analysing until that analysis ends. Counted against the batch, not against restarts.
+*/
+async function completeRow(row, prepared, batch, deps) {
+	if (prepared.kind !== "existing") return settleRow(row, deps.settle(row.reviewId));
+	if (prepared.existing.inProgress) follow(batch, settleRow(row, deps.observe(row.reviewId)), deps, false);
+}
+async function settleRow(row, settling) {
+	const settled = await settling;
 	if (settled.ok) row.status = "ready";
-	else {
+	else if (settled.stopped) {
 		row.status = "failed";
-		row.reason = settled.stopped ? "Stopped" : settled.reason;
+		row.reason = "Stopped";
+	} else fail(row, settled.reason);
+}
+/**
+* A retry runs against the commit the row was first resolved to, never a newer one: a retry
+* resumes what was asked for, and a moved branch or pull request is a fresh review's business. When
+* that commit has gone (a force push, then a prune), there is nothing left to retry, and the row
+* says so and offers the fresh start instead of quietly reviewing something else.
+*/
+async function stillThere(row, target, what, deps) {
+	if (await deps.commitPresent(target.originRepoPath, target.sha)) return true;
+	row.status = "failed";
+	row.reason = `The commit this review was of (${target.sha.slice(0, 7)}) is no longer in this repository, so it can't be retried as it was. Start a fresh review to analyse the ${what} as it is now.`;
+	row.stale = true;
+	return false;
+}
+/**
+* Retry a row whose review exists, by that review's id. Not through the lookup a start uses, which
+* finds the latest review of the branch or request: one made since, of newer commits, would be
+* handed back in place of the one that failed, and a retry would quietly become a different review.
+*
+* Resumed when it is still a failure nothing is running, as its own page's Retry does. Otherwise
+* something has taken it up since (that Retry, a terminal), and it is watched rather than run again.
+*/
+async function retryReview(row, batch, deps) {
+	const reviewId = row.reviewId;
+	const kept = deps.resumeOf(reviewId);
+	row.status = "reviewing";
+	if (kept) {
+		row.kept = kept;
+		return settleRow(row, deps.settle(reviewId));
 	}
+	follow(batch, settleRow(row, deps.observe(reviewId)), deps, false);
+}
+/**
+* A fresh start that ended before it made its review leaves the row exactly as it was: the old
+* target, the old review, and still `stale`. So the row keeps offering the fresh start, and a plain
+* Retry finds the old commit gone again, rather than resuming the old review against it.
+*/
+function keepFreshPending(row, replaced) {
+	if (row.status === "failed" && !replaced) row.stale = true;
 }
 function keptOf(agentId, model, deps) {
 	return {
@@ -11879,40 +12041,55 @@ async function startPullRequestBatch(body, deps) {
 	})));
 	/** Which row claimed each pull request, by what it resolved to rather than how it was spelled. */
 	const claimed = /* @__PURE__ */ new Map();
-	const lane = async (item, index) => {
+	/** Each row's pull request as it was first resolved: head, base and all. What a retry runs against. */
+	const resolved = [];
+	const lane = async (item, index, fresh = false) => {
 		const row = batch.rows[index];
 		const release = await deps.slots.acquire();
 		row.status = "reviewing";
+		/** A fresh start has made its review, so the row now belongs to the new target. */
+		let replaced = false;
 		try {
-			const remote = await deps.remoteOf(item.folder);
-			if (!isGitHubRepository(remote, item.owner, item.repo)) {
-				row.status = "failed";
-				row.reason = remote ? `This folder is a clone of ${remote.owner}/${remote.repo}, not ${item.owner}/${item.repo}` : `This folder is not a clone of ${item.owner}/${item.repo}`;
-				return;
+			let target = fresh ? void 0 : resolved[index];
+			if (target) {
+				if (!await stillThere(row, target, "pull request", deps)) return;
+				if (row.reviewId) return await retryReview(row, batch, deps);
+			} else {
+				const remote = await deps.remoteOf(item.folder);
+				if (!isGitHubRepository(remote, item.owner, item.repo)) {
+					row.status = "failed";
+					row.reason = remote ? `This folder is a clone of ${remote.owner}/${remote.repo}, not ${item.owner}/${item.repo}` : `This folder is not a clone of ${item.owner}/${item.repo}`;
+					return;
+				}
+				target = await deps.resolvePullRequest(item.folder, item.url);
+				if (!fresh) resolved[index] = target;
 			}
-			const target = await deps.resolvePullRequest(item.folder, item.url);
 			const identity = batchIdentity(target);
 			const first = claimed.get(identity);
-			if (first !== void 0) {
+			if (first !== void 0 && first !== index) {
 				row.status = "already-reviewed";
 				row.reason = `Same pull request as ${batch.rows[first].label}`;
 				return;
 			}
 			claimed.set(identity, index);
-			if ((await prepareRow(row, target, agent.agentId, model, deps)).kind !== "existing") await settleRow(row, deps);
+			const prepared = await prepareRow(row, target, agent.agentId, model, deps, fresh);
+			if (fresh) {
+				resolved[index] = target;
+				replaced = true;
+			}
+			await completeRow(row, prepared, batch, deps);
 		} catch (error) {
-			row.status = "failed";
-			row.reason = message(error);
+			fail(row, error);
 		} finally {
+			if (fresh) keepFreshPending(row, replaced);
 			release();
 		}
 	};
-	deps.track(runBatch(items, {
+	batch.rerun = (index, fresh) => follow(batch, lane(items[index], index, fresh), deps);
+	follow(batch, runBatch(items, {
 		concurrency: deps.concurrency,
 		run: lane
-	})).catch(() => {}).finally(() => {
-		batch.finishedAt = Date.now();
-	});
+	}), deps);
 	return {
 		status: 200,
 		body: {
@@ -11922,13 +12099,13 @@ async function startPullRequestBatch(body, deps) {
 	};
 }
 /**
-* A batch's rows as they stand. A batch this server does not know was either finished long ago,
-* which an open panel never asks about because it stops asking once a batch finishes, or lost to a
-* restart, which is the case worth saying plainly: whatever had not started never will.
+* A batch's rows as they stand. Asking counts as watching: a batch an open panel is still asking
+* about is never forgotten, so its Retry stays good for as long as the panel is open.
 */
 function batchRows(id) {
 	const batch = batches.get(id);
-	if (!batch) return refuse(404, "The workspace server no longer knows this batch, most likely because it restarted. Reviews that had started are in your list. Any that were still waiting did not start.");
+	if (!batch) return lostBatch();
+	batch.seenAt = Date.now();
 	return {
 		status: 200,
 		body: {
@@ -11937,10 +12114,39 @@ function batchRows(id) {
 		}
 	};
 }
-/** A target refusal in the panel's words where the CLI's would name a command. */
-function targetRefusal(error) {
-	if (error instanceof DetachedHeadError) return "This folder is on a detached HEAD, so there is no branch to review. Check out a branch in it, or review its pull request instead.";
-	return message(error);
+/**
+* Said without guessing why. A restart forgets every batch, and a batch nobody has asked about for
+* a while is forgotten too; the server cannot tell which happened, so it says what follows from
+* either.
+*/
+var lostBatch = () => refuse(404, "This batch is no longer on the workspace server, so it can’t be followed or retried here. Reviews that had started are in your reviews list. Any that were still queued did not start.");
+/**
+* Run one failed row of a batch again, as it was first asked for: the same folder, agent, model
+* and base, and the same commits, never the branch or pull request as it has since moved on. A
+* review that was created and then failed resumes, as a Retry does on its own page. `fresh` is the
+* one exception, sent only when those commits have gone: it looks again at what is there now.
+* The other rows are left exactly as they are, and the batch is followed again until it ends.
+*/
+function retryBatchRow(id, key, fresh = false) {
+	const batch = batches.get(id);
+	if (!batch) return lostBatch();
+	const index = batch.rows.findIndex((row) => row.key === key);
+	const row = batch.rows[index];
+	if (!row) return refuse(404, "That review is not part of this batch.");
+	if (row.status !== "failed") return refuse(409, "Only a review that failed can be tried again.");
+	row.status = "waiting";
+	delete row.reason;
+	delete row.detail;
+	delete row.stale;
+	batch.seenAt = Date.now();
+	batch.rerun(index, fresh === true);
+	return {
+		status: 200,
+		body: {
+			rows: rowsOf(batch),
+			finished: false
+		}
+	};
 }
 /** The recent and discoverable folders, for the Branch panel's list. */
 async function listFolders(deps) {
@@ -11978,7 +12184,7 @@ async function inspectFolder(rawPath, deps, rawBase) {
 			status: 200,
 			body: {
 				ok: false,
-				error: targetRefusal(error)
+				...refusalOf(error)
 			}
 		};
 	}
@@ -12008,10 +12214,14 @@ async function inspectFolder(rawPath, deps, rawBase) {
 /**
 * Review the branch checked out in a folder: `prreviewbuddy` run there.
 *
-* With a free analysis slot it answers once the review exists, and the analysis runs on in this
-* process, counted by `track` like a Retry. With none free it answers `waiting` and a one-row batch
-* to watch, and creates nothing until a slot frees: a review created to wait is a job nobody is
-* running, which the sweep would fail. A review the branch already has needs no slot to hand back.
+* Always answers with a one-row batch, which is what the panel follows, so a branch shows its
+* progress exactly as a pull request does. With a free analysis slot it answers once the review
+* exists, and the analysis runs on in this process, counted by `track` like a Retry. With none free
+* it answers `waiting` and creates nothing until a slot frees: a review created to wait is a job
+* nobody is running, which the sweep would fail. A review the branch already has needs no slot.
+*
+* A refusal before anything exists comes back as a refusal, with the base question when that is
+* what it was, so the panel can ask it beside the folder rather than as a failed row.
 */
 async function startBranchReview(body, deps) {
 	const path = typeof body?.path === "string" ? expandPath(body.path, deps.home) : null;
@@ -12023,7 +12233,10 @@ async function startBranchReview(body, deps) {
 	try {
 		target = await deps.resolveBranch(path, base);
 	} catch (error) {
-		return refuse(400, targetRefusal(error));
+		return {
+			status: 400,
+			body: refusalOf(error)
+		};
 	}
 	const agent = await agentFor(body?.agent, deps);
 	if (isAnswer(agent)) return agent;
@@ -12032,55 +12245,82 @@ async function startBranchReview(body, deps) {
 		label: target.branch,
 		status: "waiting"
 	};
+	const batch = newBatch([row]);
+	/**
+	* The branch's run, holding a slot. A retry runs against the commit first resolved, wherever the
+	* branch has moved since, unless `fresh`, which looks at the folder again as it is now.
+	*/
+	const run = async (release, again) => {
+		const fresh = again === "fresh";
+		let replaced = false;
+		try {
+			const next = fresh ? await deps.resolveBranch(path, base) : target;
+			if (again === "retry") {
+				if (!await stillThere(row, target, "branch", deps)) return;
+				if (row.reviewId) return await retryReview(row, batch, deps);
+			}
+			const prepared = await prepareRow(row, next, agent.agentId, model, deps, fresh);
+			target = next;
+			replaced = fresh;
+			await completeRow(row, prepared, batch, deps);
+		} catch (error) {
+			fail(row, error);
+		} finally {
+			if (fresh) keepFreshPending(row, replaced);
+			release();
+		}
+	};
+	batch.rerun = (_index, fresh) => follow(batch, (async () => run(await deps.slots.acquire(), fresh ? "fresh" : "retry"))(), deps);
+	const answer = (outcome) => ({
+		status: 200,
+		body: {
+			outcome,
+			batchId: batch.id,
+			rows: rowsOf(batch),
+			...row.reviewId ? { reviewId: row.reviewId } : {},
+			...row.kept ? { kept: row.kept } : {}
+		}
+	});
 	const release = deps.slots.tryAcquire();
 	if (!release) {
 		const existing = await deps.findExisting(target);
-		if (existing && !deps.resumeOf(existing.id)) return {
-			status: 200,
-			body: {
-				outcome: "existing",
-				reviewId: existing.id
-			}
-		};
-		const batch = newBatch([row]);
-		deps.track((async () => {
-			const later = await deps.slots.acquire();
-			try {
-				if ((await prepareRow(row, target, agent.agentId, model, deps)).kind !== "existing") await settleRow(row, deps);
-			} catch (error) {
-				row.status = "failed";
-				row.reason = message(error);
-			} finally {
-				later();
-			}
-		})()).finally(() => {
-			batch.finishedAt = Date.now();
-		});
-		return {
-			status: 200,
-			body: {
-				outcome: "waiting",
-				batchId: batch.id
+		if (existing && !deps.resumeOf(existing.id)) {
+			row.reviewId = existing.id;
+			if (!existing.inProgress) {
+				row.status = "already-reviewed";
+				return answer("existing");
 			}
-		};
+			row.status = "reviewing";
+			follow(batch, settleRow(row, deps.observe(existing.id)), deps, false);
+			return answer("existing");
+		}
+		follow(batch, (async () => run(await deps.slots.acquire(), "first"))(), deps);
+		return answer("waiting");
 	}
 	let prepared;
 	try {
 		prepared = await prepareRow(row, target, agent.agentId, model, deps);
 	} catch (error) {
 		release();
-		return refuse(409, message(error));
+		batches.delete(batch.id);
+		return {
+			status: 409,
+			body: refusalOf(error)
+		};
 	}
-	if (prepared.kind === "existing") release();
-	else deps.track(deps.settle(row.reviewId)).catch(() => {}).finally(release);
-	return {
-		status: 200,
-		body: {
-			outcome: prepared.kind,
-			reviewId: row.reviewId,
-			...row.kept ? { kept: row.kept } : {}
+	if (prepared.kind === "existing") {
+		await completeRow(row, prepared, batch, deps);
+		release();
+	} else follow(batch, (async () => {
+		try {
+			await settleRow(row, deps.settle(row.reviewId));
+		} catch (error) {
+			fail(row, error);
+		} finally {
+			release();
 		}
-	};
+	})(), deps);
+	return answer(prepared.kind);
 }
 async function chooseFolder(deps) {
 	if (!deps.chooseFolder) return refuse(404, "Choosing a folder is not available on this system. Type its path instead.");
@@ -13916,6 +14156,8 @@ async function handleAddReview(req, res, pathname, options) {
 		if (route === "pull-requests") return startPullRequestBatch(body, deps);
 		if (route === "folder/inspect") return inspectFolder(body?.path, deps, body?.base);
 		if (route === "branch") return startBranchReview(body, deps);
+		const retry = /^batches\/([0-9a-f-]{36})\/retry$/.exec(route);
+		if (retry) return retryBatchRow(retry[1], body?.key, body?.fresh);
 		return null;
 	};
 	const result = await answer();
@@ -15309,7 +15551,7 @@ function markAbandoned(job, now) {
 	if (isClaimed(job.id, now)) return false;
 	const current = loadJob(job.id);
 	if (!current || current.updatedAt !== job.updatedAt) return false;
-	const abandoned = fail(current, ABANDONED_MESSAGE);
+	const abandoned = fail$1(current, ABANDONED_MESSAGE);
 	saveJob(abandoned);
 	announceJob(abandoned);
 	return true;