prreviewbuddy 0.78.1 → 0.79.0

package/dist/server.js

@@ -1,4 +1,4 @@
-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 { $ as resolveWorkspacePort, $n as saveJob, $r as recommendationsOf, $t as pruneNotifications, A as parsePullRequestLink, Ai as shorthandOf, An as ReviewBeingDeletedError, Ar as LIFECYCLES, At as repositoryKey, Bi as AGENT_IDS, Bn as findExistingReview, Br as queueAdd, Bt as announceJob, C as completeRun, Ci as resolveTarget, Cn as GITHUB_MARKDOWN, Cr as recentWorkspaces, Ct as RUNTIME_WORDS, D as relativeTime$1, Di as resolveBase, Dn as escapeHtml$1, Dr as touchWorkspace, Dt as loadArchitecture, E as stopRun, Ei as isCommitReview, En as CODE_COPY_CLASS, Et as checkArchitecture, Fi as clearAgentPreference, Fn as readMarker, Fr as lifecycleItemLabel, Ft as QUOTE_LIMITS, G as stopChild, Gi as AgentUnavailableError, Gn as fetchHead, Gr as doneVerb, Gt as createPrState, Hi as agentFor$1, Hn as checkReview, Hr as queueRemove, Ht as subjectOf, I as settleQueue, Ii as readAgentPreference, In as removeWorktree, Ir as lifecyclePill, It as REPOSITORY_SCOPE, J as writeServerRecord, Jn as allJobs, Jr as issuesOutstanding, Jt as listNotifications, Kn as forgeResolver, Kr as isIssueOutstanding, Kt as createPrUpdate, L as readIndexToken, Li as writeAgentPreference, Ln as requestJobStop, Lr as offersLifecycle, Lt as ancestorsOf, M as runBatch, Mi as refExists, Mn as createWorktree, Mr as activityLabel, Mt as storedScopes, N as activateQueued, Ni as resolveAgent, Nn as holdWorktree, Nr as isLifecycle, Nt as trackedFiles, O as batchIdentity, Oi as AmbiguousRefError, On as renderInlineText, Or as workspaceRevision, Ot as partFiles, P as compactQueue, Pi as resolveModel, Pn as isWorktreeHeld, Pr as lifecycleChip, Pt as ownersOf, Q as parseWorkspacePort, Qn as loadJob, Qr as processDiscussion, Qt as moveIds, Rr as parseLifecycle, Rt as isArchitectureId, S as beginRun, Si as kissOutcome, Sn as hasAuthorContent, Sr as previousKissResult, St as recordRuntimeBestEffort, T as reportRun, Ti as DetachedHeadError, Tn as CODE_BLOCK_CLASS, Tt as ARCHITECTURE_DIR, U as serverEntryExists, Ui as detectAgents, Un as followedBranch, Ur as queueStamp, Ut as categoryOf, V as readServerRecord, Vi as agentById, Vn as checkCodeFreshness, Vr as queueAddMany, Vt as branchOf, W as spawnServer, Wi as AgentCancelledError, Wn as reviewedShaOf, Wr as readQueue, Wt as createArchitectureNotification, X as MAX_WORKSPACE_PORT, Xn as fail$1, Xr as resolvedByConversation, Xt as markRead, Y as DEFAULT_WORKSPACE_PORT, Yn as endedAt, Yr as questionsOutstanding, Yt as markAllRead, Z as MIN_WORKSPACE_PORT, Zn as isTerminal, Zr as reviewerDispositions, Zt as markReadForReview, _i as asString, _n as agentEnvOf, _r as loadWorkspace, _t as BUILD_VERSION, a as wasBlocked, ai as analysisRefOf, an as unreadAround, ar as purposeOf, at as settleReview, b as track, bi as describeAuthorship, bn as UNESTABLISHED_MOTIVATION, bt as waitingHistory, c as RefreshUnavailableError, ci as findingAssessment, cn as existingPaths, cr as decideKissRecommendation, d as mergeUpdateInto, di as isGradeFor, dn as prepareConversationWithin, dr as indexKeptIds, dt as record, ei as explanationActionOf, en as readNotification, et as statedWorkspacePort, f as updateReview, fi as promptGrade, fn as saveRefresh, fr as indexReviewGroups, gi as followUpFindingId, gn as isUnchanged, gr as lineagePosition, h as liveUpdateFor, hi as wasReassessed, hn as refreshPrContext, hr as latestKissRun, ht as telemetryUploadConsent, i as liveJobsFor, ii as ANALYSIS_ONLY, in as toneOf, ir as progressSteps, it as prepareReview, j as unsupportedReason, ji as git, jn as MANAGED_ROOT, jr as activityAttributes, jt as storeArchitecture, k as extractPullRequestLinks, ki as shortNameOf, kr as workspaceStamps, kt as readArchitecture, l as cancelUpdate, li as findingIn, ln as ASK_REREAD_CEILING_MS, lr as followedRefName, m as UpdateAlreadyRunningError, mi as sourcePhrase, mn as unforeseenFailure, mr as kissDecisionsOf, mt as recordTelemetryUploadConsent, n as deleteReview, ni as isExplanationAction, nn as removeNotification, nr as isTerminalJobPhase, nt as failureOf$1, o as discardJob, oi as assessmentLookup, on as unreadCount$1, ot as reanalyseReview, p as askCheckout, pi as reassessIn, pn as storedConversation, pr as kissDecisionRefusal, qn as fillFileUrlTemplate, qr as isQuestionOutstanding, qt as eventName, r as lineageIds, ri as withExplanation, rn as retireNotification, rr as phasesFor, rt as observeReview, s as FETCH_TIMEOUT_MS, si as currentGradeIn, sn as withUsageRecorded, sr as isClaimed, st as runJob, t as deleteLineage, ti as explanationOf, tn as readStateOf, tr as isLiveJob, tt as writePortPreference, u as cancellableHere, ui as gradeScale, un as adoptLegacyBaseline, ur as groupByLineage, ut as readEvents, v as startKissJob, vi as extractJsonText, vn as EXPLAIN_SIMPLY_PROMPT, w as endRun, wi as originRemote, wn as renderMarkdown, wr as reviewedCommit, wt as describeRuntimes, x as RUN_KINDS, xi as WITHHELD_REASON, xn as authorPreview, xr as presentedKissRunOf, xt as mapRuntimes, y as isDriving, yi as objectWithAnyOf, yn as chatConversationSection, yr as mutateWorkspace, yt as feedbackUrl, z as clearServerRecordOwnedBy, zi as STORE_ROOT, zr as sectionOf, zt as writeJsonAtomically } from "./delete_review-DwF1NMJ4.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";
@@ -243,12 +243,26 @@ var INDEX_SECTIONS = [
 	"done"
 ];
 /**
+* Every section the list draws, top to bottom: In progress, then the card sections.
+*
+* In progress is not in `INDEX_SECTIONS` because no card is ever placed there. It lists work, one
+* entry per running job or waiting row (`deriveOperations`), and a review being updated stays a
+* card in its own section while its update is listed here. Windows, Load more, the selection and
+* the counts are all about cards, so they keep reading `INDEX_SECTIONS`; folding, its memory and its
+* keyboard commands are about headings, so they read this.
+*/
+var LIST_SECTIONS = ["in-progress", ...INDEX_SECTIONS];
+/**
 * Each section's name, as its heading says it, and the key that folds it from the keyboard
 * (⌘K L and this key). The commands are made from this table, so a section added here is a section
 * the keyboard can fold, with no second list to remember.
 */
 var lifecycleName = (id) => LIFECYCLES.find((lifecycle) => lifecycle.id === id).name;
 var INDEX_SECTION_NAMES = {
+	"in-progress": {
+		title: "In progress",
+		key: "i"
+	},
 	pinned: {
 		title: "Pinned",
 		key: "p"
@@ -273,8 +287,9 @@ var INDEX_SECTION_NAMES = {
 function sectionOpen(section, collapsed) {
 	return !(collapsed?.[section] ?? section === "done");
 }
-function isIndexSection(value) {
-	return typeof value === "string" && INDEX_SECTIONS.includes(value);
+/** A section the list draws a heading for, and so one whose fold can be stored. */
+function isListSection(value) {
+	return typeof value === "string" && LIST_SECTIONS.includes(value);
 }
 /**
 * Which section a card is drawn in: Pinned when pinned, and otherwise where its lifecycle says.
@@ -435,7 +450,8 @@ var PR_FILTER_OPTIONS = [
 * once a second about a review that finished failing an hour ago, for as long as the tab stayed
 * open.
 */
-function anythingRunning(states) {
+function anythingRunning(states, operations = []) {
+	if (operations.length > 0) return true;
 	for (const state of states.values()) if (state.phase !== "failed") return true;
 	return false;
 }
@@ -9396,6 +9412,98 @@ async function checkPrStateNow(workspace, deps = defaultDeps()) {
 	} catch {}
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/operations.ts
+/** What a running job is, in the words the section uses. */
+function operationKind(job) {
+	if (purposeOf(job) === "update") return "updating";
+	if (job.reanalysis) return "re-running";
+	return job.phase === "preparing" ? "starting" : "analysing";
+}
+/**
+* Every operation, running first and newest first, then the queue in the order it was submitted.
+*
+* A row is dropped once its review has a job that is running, or one that ended after the row took
+* its slot. Both halves are about the hand-over, which has two windows. A row learns its review id
+* before that review's job is claimed, so "has a job" alone would leave nothing on the page for a
+* moment; and a row learns its job ended only after it has, so "has a running job" alone would
+* bring a finished review back as Starting. An ending from before the slot was taken is an earlier
+* attempt, a Retry's predecessor, and says nothing about this one.
+*
+* An ending hands over only a row that has its slot. A Retry puts a row back to waiting with the
+* review, and the job that failed, it already had; until the retry starts, that ending is the
+* attempt being retried, not this one, and treating it as the hand-over hid a queued retry for as
+* long as it waited. A running job hands over a row at any stage: the work is on the page either
+* way, and a waiting row beside it would be the same review listed twice.
+*
+* Both orders are total, ending on the key, because the result is hashed into the index token and a
+* tie left to the directory's order would reload the page for no reason a reviewer could see.
+*/
+function deriveOperations(jobs, isLive, rows) {
+	const running = [];
+	const liveOrEnded = [];
+	for (const job of jobs) {
+		if (purposeOf(job) === "ask") continue;
+		if (isTerminalJobPhase(job.phase)) {
+			liveOrEnded.push(job);
+			continue;
+		}
+		if (!isLive(job)) continue;
+		liveOrEnded.push(job);
+		running.push({
+			key: job.id,
+			kind: operationKind(job),
+			reviewId: job.workspaceId,
+			phase: job.phase,
+			purpose: purposeOf(job),
+			...job.reviewType && job.reviewType !== "standard" ? { lens: job.reviewType } : {},
+			startedAt: job.startedAt
+		});
+	}
+	const handedOver = (row) => row.reviewId !== void 0 && liveOrEnded.some((job) => job.workspaceId === row.reviewId && (!isTerminalJobPhase(job.phase) || row.status === "reviewing" && (job.finishedAt ?? job.updatedAt) >= (row.takenAt ?? Number.POSITIVE_INFINITY)));
+	const queued = [];
+	for (const row of rows) {
+		if (handedOver(row)) continue;
+		const base = {
+			key: row.key,
+			row,
+			...row.reviewId ? { reviewId: row.reviewId } : {}
+		};
+		if (row.status === "waiting") queued.push({
+			...base,
+			kind: "queued"
+		});
+		else running.push({
+			...base,
+			kind: "starting",
+			startedAt: row.takenAt ?? 0
+		});
+	}
+	const byKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+	running.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0) || byKey(a, b));
+	queued.sort((a, b) => (a.row?.order ?? 0) - (b.row?.order ?? 0) || byKey(a, b));
+	return [...running, ...queued];
+}
+var LEADS = {
+	queued: "Queued",
+	starting: "Starting",
+	analysing: "Analysing",
+	updating: "Updating review",
+	"re-running": "Re-running"
+};
+/**
+* The entry's status line: what kind of work, then the step it is on, in the words of `PHASES` /
+* `UPDATE_PHASES`, which the card, the terminal and the review page's checklist already use.
+*
+* "Analysing the change" stands alone rather than after "Analysing", which would say it twice.
+*/
+function operationLine(operation) {
+	const lead = operation.lens === "kiss" ? "KISS review" : LEADS[operation.kind];
+	if (operation.phase === void 0) return lead;
+	const step = phasesFor({ purpose: operation.purpose })[operation.phase].doing;
+	if (step.toLowerCase().startsWith(lead.toLowerCase())) return step;
+	return `${lead} · ${step}`;
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/reviews_page.ts
 function renderReviewsPage(view) {
 	const now = view.now ?? Date.now();
@@ -9412,7 +9520,9 @@ function renderReviewsPage(view) {
 	};
 	for (const group of ordered) sections[indexSectionOf(group.latest.pinned === true, group.latest.lifecycle, activityOf(group), "all")].push(group);
 	const rank = new Map(ordered.map((group, index) => [group, index]));
-	const renderCards = (groups) => groups.map((group) => renderCard(group, now, activityOf(group), rank.get(group), view.analyses?.get(group.latest.id), positions.get(group.latest.id), group.history.map((review) => view.moved?.get(review.id)).find((kind) => kind !== void 0), prStateOf(group.latest, view.prStates))).join("");
+	const operations = view.operations ?? [];
+	const inProgressOnly = new Set(ordered.filter((group) => group.history.length === 1 && !group.latest.hasStandardReview && operations.some((operation) => operation.reviewId === group.latest.id && operation.purpose !== "update")).map((group) => group.latest.id));
+	const renderCards = (groups) => groups.map((group) => renderCard(group, now, activityOf(group), rank.get(group), view.analyses?.get(group.latest.id), positions.get(group.latest.id), group.history.map((review) => view.moved?.get(review.id)).find((kind) => kind !== void 0), prStateOf(group.latest, view.prStates), inProgressOnly.has(group.latest.id))).join("");
 	const storedReviews = view.groups.reduce((total, group) => total + group.history.length, 0);
 	const queue = view.queue ?? [];
 	const positions = new Map(queue.map((id, position) => [id, position]));
@@ -9426,7 +9536,7 @@ function renderReviewsPage(view) {
 <link rel="stylesheet" href="/assets/sidebar.css">
 <link rel="stylesheet" href="/assets/shell.css">
 </head>
-<body class="prb-index-body" data-way-back="${escapeHtml$1(wayBackSentence())}" data-notifications-since="${now}"${view.revision === void 0 ? "" : ` data-index-revision="${escapeHtml$1(view.revision)}"`} data-live="${anythingRunning(view.analyses ?? /* @__PURE__ */ new Map())}">
+<body class="prb-index-body" data-way-back="${escapeHtml$1(wayBackSentence())}" data-notifications-since="${now}"${view.revision === void 0 ? "" : ` data-index-revision="${escapeHtml$1(view.revision)}"`} data-live="${anythingRunning(view.analyses ?? /* @__PURE__ */ new Map(), operations)}">
 ${renderGlobalBar({
 		current: "reviews",
 		unread: view.unreadNotifications ?? 0,
@@ -9447,7 +9557,8 @@ ${renderWorkspaceRail({
     <p class="prb-index-count" data-count>${escapeHtml$1(countLabel(storedReviews, ordered.length))}</p>
     <button type="button" class="prb-index-select" data-select-mode aria-pressed="false">Select</button>
   </div>`}
-  ${INDEX_SECTIONS.map((section) => renderSection(section, sections[section], renderCards, sectionOpen(section, view.sectionsCollapsed))).join("\n  ")}
+  ${renderInProgress(operations, ordered, positions, view.prStates, now, sectionOpen("in-progress", view.sectionsCollapsed))}
+  ${INDEX_SECTIONS.map((section) => renderSection(section, sections[section], renderCards, sectionOpen(section, view.sectionsCollapsed), sections[section].filter((group) => !inProgressOnly.has(group.latest.id)).length)).join("\n  ")}
   ${ordered.length === 0 ? `<p class="prb-index-empty">No reviews stored yet. Ask Claude Code to review a change and one will appear here.</p>` : `<p class="prb-index-none" data-no-matches hidden>Nothing matches that.</p>`}
   ${ordered.length === 0 ? "" : renderBulkBar()}
   <p class="prb-index-note">Reviews are kept for thirty days, on this machine only. Pinned reviews, Done reviews and anything in your review queue are kept for ninety days instead, counting from the last time you opened or marked them. Every review has a fixed address, so a link to one is worth keeping and still opens after a restart. Stopping the server deletes nothing; it only stops anything being served until the next review starts it again.</p>
@@ -9551,10 +9662,10 @@ function renderLoadMore$1(section) {
 * empty and hidden rather than left out, so a card the browser moves here after a mark or a pin has
 * somewhere to go, and an empty section keeps its fold for when something arrives.
 */
-function renderSection(section, groups, renderCards, open) {
+function renderSection(section, groups, renderCards, open, shown = groups.length) {
 	const title = INDEX_SECTION_NAMES[section].title;
-	return `<details class="prb-index-section" data-section="${section}"${open ? " open" : ""}${groups.length === 0 ? " hidden" : ""}>
-    <summary class="prb-index-section-head">${title} · <span data-section-count>${groups.length}</span></summary>
+	return `<details class="prb-index-section" data-section="${section}"${open ? " open" : ""}${shown === 0 ? " hidden" : ""}>
+    <summary class="prb-index-section-head">${title} · <span data-section-count>${shown}</span></summary>
     <div class="prb-cards" data-cards="${section}">
       ${renderCards(groups)}
     </div>
@@ -9562,6 +9673,87 @@ function renderSection(section, groups, renderCards, open) {
   </details>`;
 }
 /**
+* In progress: the work going on now, above everything else on the page.
+*
+* Not drawn at all when nothing is going on, rather than drawn empty and hidden like the card
+* sections: nothing ever moves into it in the browser, because every change to it is a change to the
+* index token and arrives as a reload. Its count is of work, not reviews, so a review being updated
+* counts once here and once in its own section, which is the point.
+*/
+function renderInProgress(operations, groups, positions, prStates, now, open) {
+	if (operations.length === 0) return "";
+	const reviews = new Map(groups.flatMap((group) => group.history.map((review) => [review.id, review])));
+	const entries = operations.map((operation) => renderOperation(operation, reviewOf(operation, reviews), positions, prStates, now)).join("");
+	return `<details class="prb-index-section" data-section="in-progress"${open ? " open" : ""}>
+    <summary class="prb-index-section-head">${INDEX_SECTION_NAMES["in-progress"].title} · <span data-section-count>${operations.length}</span></summary>
+    <div class="prb-cards" data-operations>
+      ${entries}
+    </div>
+  </details>`;
+}
+/**
+* The review an entry is about. Its own where it has one. A row still waiting has none yet, and
+* takes the newest review of the same pull request or branch from the same folder where there is
+* one, which is what that review's title, author and state still are: the filters then treat a
+* re-review of a known pull request as that pull request, rather than as somebody unknown.
+*/
+function reviewOf(operation, reviews) {
+	if (operation.reviewId !== void 0) return reviews.get(operation.reviewId);
+	const row = operation.row;
+	if (!row?.repoPath) return void 0;
+	let newest;
+	for (const review of reviews.values()) {
+		if (review.repoPath !== row.repoPath) continue;
+		if ((row.prNumber !== void 0 ? review.prNumber === row.prNumber : review.prNumber === void 0 && review.branch === row.branch) && (!newest || review.createdAt > newest.createdAt)) newest = review;
+	}
+	return newest;
+}
+/**
+* One piece of work, in a card's clothes and with none of a card's controls.
+*
+* It carries the same filter attributes as its review's card, so the search and the filters answer
+* the same question about both. No risk, no counts, no review state: there are no results yet, or the
+* results on show are about to be replaced, and either way they are the card's to show.
+*
+* A link to the review, whose own page shows the steps, the cancel and the Retry. A row still waiting
+* for a slot has no review to open, so it is not a link.
+*/
+function renderOperation(operation, review, positions, prStates, now) {
+	const row = operation.row;
+	const own = operation.reviewId !== void 0 && review?.id === operation.reviewId ? review : void 0;
+	const repoPath = review?.repoPath ?? row?.repoPath;
+	const prNumber = review?.prNumber ?? row?.prNumber;
+	const branch = review ? followedRefName(review.branch, review.headResolvedRef) ?? review.branch : row?.branch;
+	const prState = prNumber !== void 0 && repoPath ? prStates?.get(requestKey(repoPath, prNumber)) : void 0;
+	const queued = own ? positions.get(own.id) : void 0;
+	const status = own ? statusOf(own) : "new";
+	const search = [
+		review ? searchText(review) : "",
+		row?.label ?? "",
+		repoPath ? lastSegment(repoPath) : "",
+		prNumber === void 0 ? "" : `#${prNumber} ${prNumber}`,
+		branch ?? ""
+	].join(" ").toLowerCase();
+	const title = own?.title || review?.title || row?.label || "Review";
+	const running = operation.kind !== "queued";
+	const body = `<div class="prb-card-head">
+        <h2>${escapeHtml$1(title)}</h2>
+      </div>
+      <p class="prb-card-where">
+        ${repoPath ? `<span class="prb-card-repo">${escapeHtml$1(lastSegment(repoPath))}</span>` : ""}
+        ${prNumber === void 0 ? "" : `<span class="prb-card-pr">#${prNumber}</span>`}
+        ${branch ? `<span class="prb-card-branch">${escapeHtml$1(branch)}</span>` : ""}
+      </p>
+      <p class="prb-card-meta">
+        <span class="prb-card-analysis" data-analysis="${running ? "running" : "queued"}"><i></i>${escapeHtml$1(operationLine(operation))}</span>
+        ${operation.startedAt ? `<span class="prb-card-when"><time datetime="${new Date(operation.startedAt).toISOString()}">${escapeHtml$1(`Started ${relativeTime(operation.startedAt, now)}`)}</time></span>` : ""}
+      </p>`;
+	const href = own ? `/r/${encodeURIComponent(own.id)}?t=${encodeURIComponent(own.token)}` : void 0;
+	return `<article class="prb-card" data-operation="${escapeHtml$1(operation.kind)}" data-key="${escapeHtml$1(operation.key)}" data-id="${escapeHtml$1(operation.reviewId ?? "")}" data-status="${status}"${queued === void 0 ? "" : ` data-queue="${queued}"`}${prState === void 0 ? "" : ` data-pr-state="${prState}"`}${review?.authorHandle ? ` data-author="${escapeHtml$1(review.authorHandle)}"` : ""} data-search-text="${escapeHtml$1(search)}">
+    ${href ? `<a class="prb-card-link" href="${escapeHtml$1(href)}">${body}</a>` : `<div class="prb-card-link">${body}</div>`}
+  </article>`;
+}
+/**
 * The bulk bar, with its counts left out.
 *
 * Same division as the pager: every word is written here, where the house style tests read it, and
@@ -9618,13 +9810,13 @@ function renderBulkBar() {
 * card and is shown only in selection mode, so entering that mode is a stylesheet change rather
 * than a rebuild of the list.
 */
-function renderCard(group, now, activity, rank, analysis, queued, moved, prState) {
+function renderCard(group, now, activity, rank, analysis, queued, moved, prState, inProgressOnly = false) {
 	const review = group.latest;
 	const status = statusOf(review);
 	const chip = cardLifecycleChip(review.pinned === true, review.lifecycle, activity);
 	const href = `/r/${encodeURIComponent(review.id)}?t=${encodeURIComponent(review.token)}`;
 	const followed = review.targetType === "commit" ? `commit ${(review.commitSha ?? review.branch).slice(0, 7)}` : followedRefName(review.branch, review.headResolvedRef) ?? review.branch;
-	return `<article class="prb-card" data-card data-id="${escapeHtml$1(review.id)}" data-status="${status}" data-pinned="${review.pinned}"${queued === void 0 ? "" : ` data-queue="${queued}"`}${prState === void 0 ? "" : ` data-pr-state="${prState}"`}${review.authorHandle ? ` data-author="${escapeHtml$1(review.authorHandle)}"` : ""} data-lifecycle="${review.lifecycle?.state ?? "active"}"${review.lifecycle ? ` data-lifecycle-at="${review.lifecycle.at}"` : ""}${activityAttributes(activity)} data-rank="${rank}" data-reviews="${group.history.length}" data-lineage="${escapeHtml$1(group.history.map((entry) => entry.id).join(" "))}" data-search-text="${escapeHtml$1(groupSearchText(group))}">
+	return `<article class="prb-card" data-card data-id="${escapeHtml$1(review.id)}" data-status="${status}" data-pinned="${review.pinned}"${queued === void 0 ? "" : ` data-queue="${queued}"`}${prState === void 0 ? "" : ` data-pr-state="${prState}"`}${review.authorHandle ? ` data-author="${escapeHtml$1(review.authorHandle)}"` : ""} data-lifecycle="${review.lifecycle?.state ?? "active"}"${review.lifecycle ? ` data-lifecycle-at="${review.lifecycle.at}"` : ""}${activityAttributes(activity)} data-rank="${rank}" data-reviews="${group.history.length}" data-lineage="${escapeHtml$1(group.history.map((entry) => entry.id).join(" "))}" data-search-text="${escapeHtml$1(groupSearchText(group))}"${inProgressOnly ? " data-in-progress-only hidden" : ""}>
     <input type="checkbox" class="prb-card-select" data-select="${escapeHtml$1(review.id)}" aria-label="Select ${escapeHtml$1(followed)}">
     <button type="button" class="prb-card-pin" data-pin="${escapeHtml$1(review.id)}" aria-pressed="${review.pinned}" aria-label="${review.pinned ? "Unpin" : "Pin"} this review">${review.pinned ? "&#9733;" : "&#9734;"}</button>
     ${renderCardMenu(group, followed, queued !== void 0, status, activity)}
@@ -10039,7 +10231,7 @@ function writeChangeMapRegister(register) {
 function readReviewSections(value) {
 	if (!value || typeof value !== "object") return {};
 	const sections = {};
-	for (const section of INDEX_SECTIONS) {
+	for (const section of LIST_SECTIONS) {
 		const collapsed = value[section];
 		if (typeof collapsed === "boolean") sections[section] = collapsed;
 	}
@@ -11023,545 +11215,105 @@ function renderNotificationRow(notification, gone) {
   </li>`;
 }
 //#endregion
-//#region ../../packages/review-harness/src/workspace/reviews_revision.ts
-/**
-* Whether anything the reviews index draws has changed, as one token.
-*
-* The index reacts to a change by reloading, which is what makes an aggregate the right shape: it
-* never needs to know *which* review changed, so it asks one question whose cost is the same for
-* five reviews and five hundred. Per-card revisions would be more information than the page has any
-* use for, and a request per card to carry it.
-*
-* Opaque and **equality only**, the same contract as `workspaceRevision` in `store.ts`: compare two
-* tokens for equality, never order them, never parse one. The implementation below is a hash of
-* facts the page happens to draw today, and the whole point of saying so here is that it can be
-* replaced by a counter, a watch, or anything else without a page having to be told.
-*
-* ## What is in it, and what is deliberately not
-*
-* In: every review's id and file revision, and the phase of every analysis running right now.
-* Between them those cover everything a card shows — the summary, the risk badge, the counts, the
-* pin, the reviewed mark, the running line — because every one of those reaches disk through
-* `writeWorkspace`, and the set of ids covers a review appearing or being deleted.
-*
-* Not in: **`job.updatedAt` and `job.progress`.** This is the load-bearing omission. An agent
-* streams its progress into the job record every few seconds, so a token derived from job file
-* mtimes would differ on nearly every poll, and a page that reloads whenever the token differs
-* would then reload every few seconds for the whole length of an analysis — a page thrashing
-* itself, with the reviewer's scroll position going with it. Phase only, which changes four times
-* in a run.
-*/
+//#region ../../packages/review-harness/src/workspace/working_folders.ts
 /**
-* What is being done to each review, or was last done and stopped.
-*
-* Keyed by review, valued by the phase the card should name. Two states reach it and a third
-* deliberately does not:
-*
-* - **Running.** A job that is not terminal *and* whose driver holds a live claim. The claim is the
-*   load-bearing half: a job whose driver was killed sits in a working phase for up to half an hour
-*   before the sweep calls it stopped, and narrating one of those as "Analysing the change" would
-*   be the index confidently reporting work that nothing is doing.
-* - **`failed`.** Reported whether or not anything still holds the claim, which is the whole reason
-*   this function is not simply `runningJobs`. It was: `runningJobs` drops terminal jobs, and
-*   `isTerminal` counts `failed` as terminal, so a failed analysis could never reach the renderer
-*   and the card's "Analysis stopped" branch was unreachable in production while passing a unit
-*   test that handed it a state the product could not produce. A review whose analysis failed went
-*   back to reading "No standard review yet" the moment its driver let go.
-* - **`done`, and an unclaimed job still in a working phase.** Nothing. A finished job has its
-*   result on the card already, and an abandoned one is the sweep's to judge rather than this
-*   renderer's to pre-empt.
-*
-* **Every job a review has, not the latest one.** A review accumulates them -- a standard analysis,
-* a KISS run, a retry -- and two of them genuinely run at once: `handleKiss` refuses only a second
-* KISS run, and the review page's poll is built around one finishing while the other goes on. An
-* earlier cut picked the single newest job and then asked what it was, so a KISS run that ended
-* first spoke for a standard analysis that was still working, and the card fell silent on work that
-* was happening in front of the reviewer.
+* The local Git working folders PR Review Buddy can find right now.
 *
-* So the precedence is running, then the most recent ending, and it is stated in that order because
-* that is the property: **nothing that has ended can hide something that has not.**
+* One question and nothing more: which folders on this machine could a review run in. The answer is
+* derived each time from what is already known, the folders past reviews ran in and the other
+* worktrees of those repositories, and nothing is stored. A worktree an agent made yesterday shows
+* up because `git worktree list` names it, not because anything remembered it.
 *
-* `jobs` is injected only so a test can hand the same set in two different orders and prove the
-* answer does not move. Production always reads the directory.
+* A folder is a folder. A linked worktree is its own entry with its own path and is never folded
+* into the clone it belongs to: a review is filed under the folder it ran in, and the worktree is
+* where the branch is checked out.
 *
-* A failure is visible for as long as the job record survives, which is the sweep's retention. Once
-* that passes the card quietly returns to saying nothing, which is the same silence every review
-* had before this existed.
+* Not a registry. If one is wanted later it replaces `discoverWorkingFolders` and keeps the shape.
 */
-function analysisStates(now = Date.now(), jobs = allJobs()) {
-	const byReview = /* @__PURE__ */ new Map();
-	for (const job of jobs) {
-		if (purposeOf(job) === "ask") continue;
-		const held = byReview.get(job.workspaceId);
-		if (held) held.push(job);
-		else byReview.set(job.workspaceId, [job]);
+function canonical(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
 	}
-	/**
-	* Both comparators are **total**, and that is a requirement rather than tidiness.
-	*
-	* `allJobs` reads a directory, so a tie leaves the winner to whatever order the filesystem
-	* happened to return. This function's output is hashed into the index token, and the page reloads
-	* whenever that token changes -- so an arbitrary winner is not a cosmetic wobble, it is the page
-	* reloading itself for as long as the tie exists, with no cause a reviewer could ever see. The
-	* same hazard the sorting rule was written for, one level further down.
-	*
-	* Ties are real. Two jobs can carry the same timestamp to the millisecond, and a record written
-	* before `finishedAt` existed falls back to `updatedAt`, which two records can share. The id is
-	* the last resort because it is the only field guaranteed to differ.
-	*/
-	const byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-	const startedLast = (a, b) => b.startedAt - a.startedAt || byId(a, b);
-	const endedLast = (a, b) => endedAt(b) - endedAt(a) || b.startedAt - a.startedAt || byId(a, b);
-	const states = /* @__PURE__ */ new Map();
-	for (const [reviewId, jobs] of byReview) {
-		const running = jobs.filter((job) => !isTerminal(job) && isClaimed(job.id, now)).sort(startedLast);
-		if (running.length > 0) {
-			states.set(reviewId, {
-				phase: running[0].phase,
-				purpose: purposeOf(running[0])
+}
+/** `git worktree list --porcelain`, main worktree first, bare and prunable entries left out. */
+async function worktreesOf(repoPath) {
+	let output;
+	try {
+		output = await git(repoPath, [
+			"worktree",
+			"list",
+			"--porcelain"
+		]);
+	} catch {
+		return [];
+	}
+	const entries = [];
+	for (const block of output.split(/\n\s*\n/)) {
+		const lines = block.split("\n");
+		const path = lines.find((line) => line.startsWith("worktree "))?.slice(9);
+		if (!path || lines.includes("bare") || lines.some((line) => line.startsWith("prunable"))) continue;
+		const ref = lines.find((line) => line.startsWith("branch "))?.slice(7) ?? null;
+		entries.push({
+			path,
+			branch: ref ? ref.replace(/^refs\/heads\//, "") : null
+		});
+	}
+	return entries;
+}
+async function discoverWorkingFolders(summaries = recentWorkspaces(Number.MAX_SAFE_INTEGER)) {
+	const lastReviewed = /* @__PURE__ */ new Map();
+	for (const summary of summaries) {
+		if (!summary.repoPath) continue;
+		const key = canonical(summary.repoPath);
+		lastReviewed.set(key, Math.max(lastReviewed.get(key) ?? 0, summary.createdAt));
+	}
+	const found = /* @__PURE__ */ new Map();
+	for (const seed of lastReviewed.keys()) {
+		if (found.has(seed) || !existsSync(seed)) continue;
+		(await worktreesOf(seed)).forEach((entry, index) => {
+			const key = canonical(entry.path);
+			if (!found.has(key) && existsSync(key)) found.set(key, {
+				entry: {
+					...entry,
+					path: key
+				},
+				main: index === 0
 			});
-			continue;
-		}
-		const ended = jobs.filter((job) => isTerminal(job) && purposeOf(job) === "review").sort(endedLast);
-		if (ended[0]?.phase === "failed") states.set(reviewId, {
-			phase: "failed",
-			purpose: "review",
-			...ended[0].failure?.stopped ? { stopped: true } : {}
 		});
 	}
-	return states;
+	return (await Promise.all([...found.values()].map(async ({ entry, main }) => ({
+		path: entry.path,
+		remote: await originRemote(entry.path),
+		branch: entry.branch,
+		main,
+		lastReviewedAt: lastReviewed.get(entry.path) ?? null
+	})))).sort((a, b) => (b.lastReviewedAt ?? 0) - (a.lastReviewedAt ?? 0) || Number(b.main) - Number(a.main) || a.path.localeCompare(b.path));
+}
+/** Whether a remote is this github.com repository. GitHub names are case-insensitive. */
+function isGitHubRepository(remote, owner, repo) {
+	return Boolean(remote && remote.host === "github.com" && remote.owner.toLowerCase() === owner.toLowerCase() && remote.repo.toLowerCase() === repo.toLowerCase());
 }
 /**
-* The token.
+* The folders a pull request could be reviewed in, the suggested one first.
 *
-* Takes the live analyses rather than reading them, so that one request answers with a token and a
-* running state that describe the same instant. Computing them separately would let a phase change
-* land between the two, and the page would then be told "nothing has changed" alongside a state it
-* had not seen.
+* Every match is returned, because which one is right is the reviewer's call: an agent's worktree
+* and the main clone hold the same objects and differ in what is checked out. The order only
+* decides the default. A folder that already has a review of this pull request comes first, so
+* reviewing it again finds that review rather than starting a second one filed under another
+* folder; then the main worktree; then whichever was reviewed in most recently.
 */
-function reviewsRevision(live = analysisStates()) {
-	const hash = createHash("sha1");
-	for (const [id, revision] of workspaceStamps()) hash.update(`${id}:${revision}\n`);
-	for (const id of [...live.keys()].sort()) {
-		const state = live.get(id);
-		hash.update(`${id}@${state.purpose}:${state.phase}${state.stopped ? ":stopped" : ""}\n`);
-	}
-	hash.update(`queue:${queueStamp()}\n`);
-	for (const [id, kind] of [...movedReviews()].sort(([a], [b]) => a.localeCompare(b))) hash.update(`moved:${id}:${kind}\n`);
-	for (const [key, state] of [...prStatesByRequest()].sort(([a], [b]) => a.localeCompare(b))) hash.update(`pr:${key}:${state}\n`);
-	for (const [key, entry] of Object.entries(readWatch()).sort(([a], [b]) => a.localeCompare(b))) if (entry.changedAt !== void 0) hash.update(`head:${key}:${entry.changedAt}\n`);
-	for (const [key, entry] of Object.entries(readPrStates()).sort(([a], [b]) => a.localeCompare(b))) if (entry.changedAt !== void 0) hash.update(`pr-changed:${key}:${entry.changedAt}\n`);
-	return hash.digest("base64url");
+function candidatesFor(folders, link, summaries) {
+	const reviewedHere = new Set(summaries.filter((summary) => summary.prNumber === link.number).map((summary) => canonical(summary.repoPath)));
+	const matching = folders.filter((folder) => isGitHubRepository(folder.remote, link.owner, link.repo));
+	const rank = (folder) => reviewedHere.has(folder.path) ? 0 : folder.main ? 1 : 2;
+	return [...matching].sort((a, b) => rank(a) - rank(b) || (b.lastReviewedAt ?? 0) - (a.lastReviewedAt ?? 0));
 }
-function asKind(value) {
-	return value === "issue" || value === "question" ? value : null;
-}
-/** What the page sent, or null when it is not a request a host understands. */
-function parseReassessmentRequest(value) {
-	const body = value;
-	if (body?.op === "decide") {
-		if (typeof body.proposalId !== "string" || body.proposalId === "") return null;
-		if (body.decision !== "accepted" && body.decision !== "declined") return null;
-		return {
-			op: "decide",
-			proposalId: body.proposalId,
-			decision: body.decision
-		};
-	}
-	if (body?.op === "set") {
-		const kind = asKind(body.kind);
-		if (!kind || typeof body.id !== "string" || body.id === "") return null;
-		if (!isGradeFor(kind, body.to)) return null;
-		if (body.from !== null && !isGradeFor(kind, body.from)) return null;
-		if (body.reason !== void 0 && typeof body.reason !== "string") return null;
-		const reason = typeof body.reason === "string" ? body.reason.trim().slice(0, 500) : "";
-		return {
-			op: "set",
-			kind,
-			findingId: body.id,
-			from: body.from,
-			to: body.to,
-			...reason ? { reason } : {}
-		};
-	}
-	return null;
-}
-var BAD_REASSESSMENT_REQUEST = "A reassessment either moves a finding to a grade on its scale, or accepts or declines a suggestion.";
-var REASSESSMENT_REFUSED = {
-	"not-a-grade": "That is not a grade this finding can have.",
-	unchanged: "The finding already has that grade.",
-	stale: "The grade has changed since this page was drawn. The card now shows it as it stands.",
-	outdated: "That suggestion was made against an earlier version of this review. Reassess again to judge it as it stands.",
-	"no-reason": "A suggestion needs a reason.",
-	unknown: "This review has no suggestion with that id.",
-	decided: "That suggestion has already been answered.",
-	"no-finding": "This review has no such finding."
-};
-function gradeFragments$1(session, kind, id) {
-	const finding = findingIn(session, kind, id);
-	if (!finding) return null;
-	const assessment = findingAssessment(session.findingReassessments, kind, finding, analysisRefOf(session));
-	const options = {
-		editable: true,
-		askMore: true
-	};
-	return {
-		kind,
-		id,
-		current: assessment.current,
-		cardClass: cardGradeClass(kind, assessment.current),
-		grade: renderGradeControl(kind, assessment, options),
-		region: renderAssessmentRegion(kind, assessment, options),
-		copy: kind === "issue" ? issueMarkdown(finding, assessment) : questionMarkdown(finding, assessment)
-	};
-}
-/** The finding a request is about: named outright, or through the proposal it decides. */
-function findingOfRequest(session, request) {
-	if (request.op === "set") return {
-		kind: request.kind,
-		id: request.findingId
-	};
-	const proposal = session.findingReassessments?.find((entry) => entry.id === request.proposalId);
-	return proposal ? {
-		kind: proposal.kind,
-		id: proposal.findingId
-	} : null;
-}
-/** A refusal, with the card as the session has it so the page is brought up to date by the answer. */
-function refusedReply(session, request, refusal) {
-	const finding = findingOfRequest(session, request);
-	const card = finding ? gradeFragments$1(session, finding.kind, finding.id) : null;
-	return {
-		status: refusal === "stale" || refusal === "outdated" || refusal === "decided" ? 409 : 400,
-		body: {
-			error: REASSESSMENT_REFUSED[refusal],
-			refusal,
-			...card ? { card } : {}
-		}
-	};
-}
-//#endregion
-//#region ../../packages/review-harness/src/workspace/reassessment_state.ts
-/**
-* The reviewer's grade moves and their answers to proposals, as `/state` receives them.
-*
-* The request, its refusals and the card parts a reply carries are shared with the extension
-* (domain/ui/components/reassessment_reply.ts). What is the workspace's own is the store: checked
-* against a fresh read before writing, so a refusal leaves the file alone, and checked again inside
-* the write, where the answer is final.
-*/
-/** A stored review's card parts for one finding. */
-function gradeFragments(workspace, kind, id) {
-	return gradeFragments$1(workspace.session, kind, id);
-}
-/**
-* One write, onto the review as it is now, answered with the card as it now stands. `now` is
-* injectable so a test can name the time an entry records.
-*/
-function applyReassessmentRequest(workspaceId, value, now = Date.now) {
-	const request = parseReassessmentRequest(value);
-	if (!request) return {
-		status: 400,
-		body: { error: BAD_REASSESSMENT_REQUEST }
-	};
-	const before = loadWorkspace(workspaceId);
-	if (!before) return {
-		status: 404,
-		body: { error: "No such review" }
-	};
-	const early = reassessIn(structuredClone(before.session), request, now());
-	if (!early.ok) return refusedReply(before.session, request, early.refusal);
-	let outcome = null;
-	const saved = mutateWorkspace(workspaceId, (current) => {
-		outcome = reassessIn(current.session, request, now());
-	});
-	if (!saved || !outcome) return {
-		status: 404,
-		body: { error: "No such review" }
-	};
-	const written = outcome;
-	if (!written.ok) return refusedReply(saved.session, request, written.refusal);
-	const card = gradeFragments(saved, written.entry.kind, written.entry.findingId);
-	return {
-		status: 200,
-		body: {
-			ok: true,
-			entry: written.entry,
-			...card ? { card } : {}
-		}
-	};
-}
-//#endregion
-//#region ../../packages/review-harness/src/domain/ai_review/reassess_prompt.ts
-/** More than any real answer cites; a list longer than this is padding, not evidence. */
-var MAX_EVIDENCE = 10;
-function scaleText(kind) {
-	return gradeScale(kind).map((grade) => `"${grade}"`).join(" | ");
-}
-/** What the grade means, in the words the analysis prompt uses for it. */
-function gradeMeaning(kind) {
-	return kind === "issue" ? "Severity is how much the issue would matter if it is real. It is not how sure anyone is that it is real." : "Importance is how much of the reviewer's attention the question deserves before they can approve.";
-}
-function findingText(kind, finding) {
-	if (kind === "issue") {
-		const issue = finding;
-		const where = issue.file ? `\nLocation: ${issue.file}${issue.line ? `:${issue.line}` : ""}` : "";
-		return `Issue: ${issue.title.trim()}\n${issue.description.trim()}${where}`;
-	}
-	const question = finding;
-	const why = question.whyThisMatters?.trim() ? `\nWhy it matters: ${question.whyThisMatters.trim()}` : "";
-	return `Question: ${question.question.trim()}${why}${question.file ? `\nFile: ${question.file}` : ""}`;
-}
-function historyText(assessment) {
-	if (!assessment.history.length) return "It has not been reassessed before.";
-	return ["Earlier moves of this grade, oldest first:", ...assessment.history.map((step) => `- ${step.from ?? "ungraded"} → ${step.to}, ${sourcePhrase(step.source)}${step.reason ? `: ${step.reason}` : ""}`)].join("\n");
-}
-function threadText(thread) {
-	if (!thread) return [];
-	const comments = thread.comments.filter((comment) => !comment.authorIsBot && comment.body.trim());
-	if (!comments.length) return [];
-	return [`THE PULL REQUEST THREAD THIS FINDING WAS TIED TO (${thread.resolved ? "resolved" : "unresolved"}):`, ...comments.map((comment) => `@${comment.author}: ${comment.body.trim()}`)];
-}
-/** The block a Reassess turn adds to the ordinary Buddy prompt. */
-function buildReassessInstructions(input) {
-	const { kind, finding, assessment } = input;
-	const noun = kind === "issue" ? "severity" : "importance";
-	const current = assessment.current;
-	return [
-		"---",
-		`THE REVIEWER ASKED YOU TO REASSESS THE ${noun.toUpperCase()} OF THIS ${kind.toUpperCase()}:`,
-		findingText(kind, finding),
-		`Its ${noun} now: ${promptGrade(assessment)}.`,
-		historyText(assessment),
-		...input.explanation?.trim() ? ["An explanation of it you gave earlier:", input.explanation.trim()] : [],
-		...threadText(input.thread),
-		"---",
-		`Judge whether its ${noun} should change, using the code in the checkout and everything above, including this conversation. ${gradeMeaning(kind)} Read the code that decides it rather than reasoning from the finding's wording.`,
-		`Raising it is as legitimate as lowering it. "keep" is a good answer, and the right one whenever the evidence does not clearly move it; do not change it because you were asked.`,
-		"Reply with a single JSON object and nothing else: no prose before or after it, no Markdown fence. Exactly this shape:",
-		`{ "verdict": "keep" | "change", "to"?: ${scaleText(kind)}, "reason": string, "evidence"?: [{ "file": string, "line"?: number }] }`,
-		`"to" is the new ${noun}, given only with "change", and must differ from ${current ? `"${current}"` : "the current one"}.`,
-		"\"reason\" is one to three sentences the reviewer will read on the card: name what in the code or the conversation moves it, or what leaves it where it is.",
-		"\"evidence\" is the places in the code that settle it, as paths relative to the repository root. Omit it rather than citing a file you did not read."
-	];
-}
-var REASSESS_ANSWER = objectWithAnyOf("verdict", "reason");
-function readEvidence(value) {
-	if (!Array.isArray(value)) return [];
-	const out = [];
-	for (const item of value) {
-		const entry = item;
-		const file = typeof entry?.file === "string" ? entry.file.trim().replace(/^\.\//, "") : "";
-		if (!file) continue;
-		const line = typeof entry?.line === "number" && Number.isInteger(entry.line) && entry.line > 0 ? entry.line : void 0;
-		out.push(line === void 0 ? { file } : {
-			file,
-			line
-		});
-		if (out.length === MAX_EVIDENCE) break;
-	}
-	return out;
-}
-/**
-* The answer, or null when it cannot be read as one. Strict where it matters: a `change` must name a
-* grade on this finding's scale that differs from the current one, and every answer must give a
-* reason. A thin or confused answer is not repaired into a suggestion; the turn says it could not
-* use it, and nothing is proposed.
-*/
-function parseReassessAnswer(raw, kind, current) {
-	let parsed;
-	try {
-		parsed = JSON.parse(extractJsonText(raw, REASSESS_ANSWER));
-	} catch {
-		return null;
-	}
-	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
-	const obj = parsed;
-	const reason = typeof obj.reason === "string" ? obj.reason.trim() : "";
-	if (!reason) return null;
-	const evidence = readEvidence(obj.evidence);
-	if (obj.verdict === "keep") return {
-		verdict: "keep",
-		reason,
-		evidence
-	};
-	if (obj.verdict !== "change") return null;
-	if (!isGradeFor(kind, obj.to) || obj.to === current) return null;
-	return {
-		verdict: "change",
-		to: obj.to,
-		reason,
-		evidence
-	};
-}
-//#endregion
-//#region ../../packages/review-harness/src/workspace/reassess_turn.ts
-/**
-* The answer, with every cited place checked against the commit the review describes. A path that
-* is not there is dropped and the suggestion kept: the judgement may stand even when the model
-* misremembered where it read it, and a citation that leads nowhere is worse than none. If the check
-* itself fails, no evidence is kept rather than unchecked evidence.
-*
-* Kept, but not disguised: how many were dropped is recorded, so the card says the suggestion has
-* no verified code evidence rather than drawing it like one whose citations held. Acceptance does
-* not depend on it; a reason may be sound without a citation.
-*/
-async function readReassessTurn(raw, target, where, check = existingPaths) {
-	const answer = parseReassessAnswer(raw, target.kind, target.from);
-	if (!answer || !answer.evidence.length) return {
-		answer,
-		raw,
-		droppedEvidence: 0
-	};
-	let real;
-	try {
-		real = await check(where.repoPath, [...new Set(answer.evidence.map((place) => place.file))], where.commitSha);
-	} catch {
-		real = /* @__PURE__ */ new Set();
-	}
-	const evidence = answer.evidence.filter((place) => real.has(place.file));
-	return {
-		answer: {
-			...answer,
-			evidence
-		},
-		raw,
-		droppedEvidence: answer.evidence.length - evidence.length
-	};
-}
-/**
-* Writes the suggestion onto the session, when there is one to write. Run inside the store write on
-* the fresh copy: the grade is checked against what is on disk now, so a move the reviewer made
-* while Buddy AI was answering makes the suggestion out of date rather than letting it land on a
-* grade it never saw.
-*/
-function keepReassessTurn(session, target, turn, askedAt) {
-	if (!turn.answer) return "unreadable";
-	if (turn.answer.verdict === "keep" || !turn.answer.to) return "kept";
-	return reassessIn(session, {
-		op: "propose",
-		kind: target.kind,
-		findingId: target.id,
-		from: target.from,
-		to: turn.answer.to,
-		reason: turn.answer.reason,
-		...turn.answer.evidence.length ? { evidence: turn.answer.evidence } : {},
-		...turn.droppedEvidence ? { droppedEvidence: turn.droppedEvidence } : {},
-		source: {
-			kind: "buddy",
-			askedAt
-		}
-	}, askedAt).ok ? "proposed" : "stale";
-}
-/** What the conversation shows for the turn, in words, never the JSON. */
-function reassessTurnText(target, turn, outcome) {
-	const from = target.from ?? "ungraded";
-	const answer = turn.answer;
-	if (!answer) return `${turn.raw.trim()}\n\n*This answer was not in the form a suggestion needs, so nothing was suggested and the grade is unchanged.*`;
-	if (answer.verdict === "keep") return `**Keep ${from}.** ${answer.reason}`;
-	const move = `**Suggests ${from} → ${answer.to}.** ${answer.reason}`;
-	return outcome === "stale" ? `${move}\n\n*The grade changed while this was being answered, so the suggestion was not kept. Reassess again to judge it as it stands.*` : `${move}\n\n*Accept or keep it on the card.*`;
-}
-//#endregion
-//#region ../../packages/review-harness/src/workspace/working_folders.ts
-/**
-* The local Git working folders PR Review Buddy can find right now.
-*
-* One question and nothing more: which folders on this machine could a review run in. The answer is
-* derived each time from what is already known, the folders past reviews ran in and the other
-* worktrees of those repositories, and nothing is stored. A worktree an agent made yesterday shows
-* up because `git worktree list` names it, not because anything remembered it.
-*
-* A folder is a folder. A linked worktree is its own entry with its own path and is never folded
-* into the clone it belongs to: a review is filed under the folder it ran in, and the worktree is
-* where the branch is checked out.
-*
-* Not a registry. If one is wanted later it replaces `discoverWorkingFolders` and keeps the shape.
-*/
-function canonical(path) {
-	try {
-		return realpathSync(path);
-	} catch {
-		return path;
-	}
-}
-/** `git worktree list --porcelain`, main worktree first, bare and prunable entries left out. */
-async function worktreesOf(repoPath) {
-	let output;
-	try {
-		output = await git(repoPath, [
-			"worktree",
-			"list",
-			"--porcelain"
-		]);
-	} catch {
-		return [];
-	}
-	const entries = [];
-	for (const block of output.split(/\n\s*\n/)) {
-		const lines = block.split("\n");
-		const path = lines.find((line) => line.startsWith("worktree "))?.slice(9);
-		if (!path || lines.includes("bare") || lines.some((line) => line.startsWith("prunable"))) continue;
-		const ref = lines.find((line) => line.startsWith("branch "))?.slice(7) ?? null;
-		entries.push({
-			path,
-			branch: ref ? ref.replace(/^refs\/heads\//, "") : null
-		});
-	}
-	return entries;
-}
-async function discoverWorkingFolders(summaries = recentWorkspaces(Number.MAX_SAFE_INTEGER)) {
-	const lastReviewed = /* @__PURE__ */ new Map();
-	for (const summary of summaries) {
-		if (!summary.repoPath) continue;
-		const key = canonical(summary.repoPath);
-		lastReviewed.set(key, Math.max(lastReviewed.get(key) ?? 0, summary.createdAt));
-	}
-	const found = /* @__PURE__ */ new Map();
-	for (const seed of lastReviewed.keys()) {
-		if (found.has(seed) || !existsSync(seed)) continue;
-		(await worktreesOf(seed)).forEach((entry, index) => {
-			const key = canonical(entry.path);
-			if (!found.has(key) && existsSync(key)) found.set(key, {
-				entry: {
-					...entry,
-					path: key
-				},
-				main: index === 0
-			});
-		});
-	}
-	return (await Promise.all([...found.values()].map(async ({ entry, main }) => ({
-		path: entry.path,
-		remote: await originRemote(entry.path),
-		branch: entry.branch,
-		main,
-		lastReviewedAt: lastReviewed.get(entry.path) ?? null
-	})))).sort((a, b) => (b.lastReviewedAt ?? 0) - (a.lastReviewedAt ?? 0) || Number(b.main) - Number(a.main) || a.path.localeCompare(b.path));
-}
-/** Whether a remote is this github.com repository. GitHub names are case-insensitive. */
-function isGitHubRepository(remote, owner, repo) {
-	return Boolean(remote && remote.host === "github.com" && remote.owner.toLowerCase() === owner.toLowerCase() && remote.repo.toLowerCase() === repo.toLowerCase());
-}
-/**
-* The folders a pull request could be reviewed in, the suggested one first.
-*
-* Every match is returned, because which one is right is the reviewer's call: an agent's worktree
-* and the main clone hold the same objects and differ in what is checked out. The order only
-* decides the default. A folder that already has a review of this pull request comes first, so
-* reviewing it again finds that review rather than starting a second one filed under another
-* folder; then the main worktree; then whichever was reviewed in most recently.
-*/
-function candidatesFor(folders, link, summaries) {
-	const reviewedHere = new Set(summaries.filter((summary) => summary.prNumber === link.number).map((summary) => canonical(summary.repoPath)));
-	const matching = folders.filter((folder) => isGitHubRepository(folder.remote, link.owner, link.repo));
-	const rank = (folder) => reviewedHere.has(folder.path) ? 0 : folder.main ? 1 : 2;
-	return [...matching].sort((a, b) => rank(a) - rank(b) || (b.lastReviewedAt ?? 0) - (a.lastReviewedAt ?? 0));
-}
-/** The review of this pull request already filed under one of these folders, if there is one. */
-function reviewedIn(folders, link, summaries) {
-	const paths = new Set(folders.map((folder) => folder.path));
-	return summaries.find((summary) => summary.prNumber === link.number && paths.has(canonical(summary.repoPath))) ?? null;
+/** The review of this pull request already filed under one of these folders, if there is one. */
+function reviewedIn(folders, link, summaries) {
+	const paths = new Set(folders.map((folder) => folder.path));
+	return summaries.find((summary) => summary.prNumber === link.number && paths.has(canonical(summary.repoPath))) ?? null;
 }
 //#endregion
 //#region ../../packages/review-harness/src/workspace/choose_folder.ts
@@ -11714,625 +11466,1145 @@ function baseChoiceOf(error) {
 	};
 }
 /**
-* 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.
+* 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;
+}
+/** A path a person typed, made absolute: `~` is their home folder, and anything relative is refused. */
+function expandPath(raw, home) {
+	const trimmed = raw.trim().replace(/(.)\/+$/, "$1");
+	if (!trimmed) return null;
+	const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") ? `${home}${trimmed.slice(1)}` : trimmed;
+	return isAbsolute(expanded) ? expanded : null;
+}
+function message(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Why no agent could be used, in a sentence for the panel. The CLI's own wording names flags. */
+function unresolvedAgent(resolution) {
+	switch (resolution.kind) {
+		case "none": return "No review agent is installed on this machine. Install one of the agents PR Review Buddy supports, then try again.";
+		case "unknown-id": return `"${resolution.id}" is not an agent PR Review Buddy knows. Choose another under Review options, or change the default in Settings.`;
+		case "unavailable": return `${resolution.agent.displayName} can't be used from the workspace: ${resolution.reason}`;
+	}
+}
+/**
+* The agent a submission runs under: the one named under Review options, or else the same answer
+* the CLI reaches with no flag (the configured default, or the only one installed). Never the
+* 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.", { 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.", { 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.", { field: "model" });
+	return value.trim() || void 0;
+}
+/**
+* The tail of each target's queue of creations, by batch identity. In-process, like the fetch
+* queue in `target.ts`.
+*
+* `prepareReview` looks for an existing review and then creates one, and nothing between the two
+* stops a second start of the same target, from another tab or another paste, from looking in the
+* same gap and creating a second review of it. One at a time per target closes that gap for every
+* start this server makes; the second one finds the first one's review.
+*/
+var creations = /* @__PURE__ */ new Map();
+function oneCreationAtATime(target, work) {
+	const key = batchIdentity(target);
+	const mine = (creations.get(key) ?? Promise.resolve()).then(work, work);
+	const tail = mine.catch(() => {});
+	creations.set(key, tail);
+	tail.then(() => {
+		if (creations.get(key) === tail) creations.delete(key);
+	});
+	return mine;
+}
+var isAnswer = (value) => typeof value === "object" && value !== null && "status" in value && "body" in value;
+async function addReviewOptions(deps) {
+	const [agents, resolution] = await Promise.all([deps.agents(), deps.resolveAgent()]);
+	return {
+		status: 200,
+		body: {
+			agents,
+			agent: resolution.kind === "resolved" ? {
+				kind: "resolved",
+				id: resolution.agent.id,
+				displayName: resolution.agent.displayName
+			} : resolution.kind === "ambiguous" ? { kind: "ambiguous" } : {
+				kind: "refused",
+				error: unresolvedAgent(resolution)
+			},
+			canChooseFolder: deps.chooseFolder !== null
+		}
+	};
+}
+function reviewedRow(reviewId, deps) {
+	const kept = deps.resumeOf(reviewId);
+	return {
+		reviewId,
+		...kept ? { kept } : {}
+	};
+}
+function folderOption(folder, home) {
+	return {
+		path: folder.path,
+		display: displayPath(folder.path, home),
+		branch: folder.branch
+	};
+}
+/**
+* What a paste would start, without starting anything: rows, the folders each could run in, and
+* which already have a review. No forge is asked and nothing is fetched, so it is cheap enough to
+* run on every pause in typing.
+*
+* Every link gets a row, however many there are. Past the batch limit the panel refuses to start
+* rather than this quietly dropping the tail: a reviewer who pasted twenty-one pull requests and
+* got twenty reviews would not find out which one was missing.
+*/
+async function previewPullRequests(text, deps) {
+	if (typeof text !== "string") return refuse(400, "Paste the pull request links to review.");
+	const links = extractPullRequestLinks(text);
+	const [folders, summaries] = links.some((link) => link.kind === "github") ? [await deps.folders(), deps.summaries()] : [[], []];
+	return {
+		status: 200,
+		body: {
+			rows: links.map((link) => {
+				if (link.kind === "unsupported") return {
+					key: link.key,
+					label: `${link.provider} ${link.provider === "GitLab" ? "merge request" : "pull request"}`,
+					url: link.url,
+					ok: false,
+					reason: unsupportedReason(link.provider),
+					folders: []
+				};
+				const label = `${link.owner}/${link.repo} #${link.number}`;
+				const candidates = candidatesFor(folders, link, summaries);
+				if (candidates.length === 0) return {
+					key: link.key,
+					label,
+					url: link.url,
+					ok: false,
+					reason: "Local repository not found",
+					needsFolder: true,
+					folders: []
+				};
+				const reviewed = reviewedIn(candidates, link, summaries);
+				return {
+					key: link.key,
+					label,
+					url: link.url,
+					ok: true,
+					folders: candidates.map((folder) => folderOption(folder, deps.home)),
+					folder: candidates[0].path,
+					...reviewed ? { reviewed: reviewedRow(reviewed.id, deps) } : {}
+				};
+			}),
+			limit: MAX_BATCH
+		}
+	};
+}
+var batches = /* @__PURE__ */ new Map();
+var facts = /* @__PURE__ */ new WeakMap();
+var submitted = 0;
+function noteRow(row, known) {
+	submitted += 1;
+	facts.set(row, {
+		order: submitted,
+		...known
+	});
+}
+/** The row has its slot and is under way. When it took it is kept from the first time only. */
+function begin(row) {
+	const known = facts.get(row);
+	if (known && row.status !== "reviewing") known.takenAt = Date.now();
+	row.status = "reviewing";
+}
+/**
+* Every row still to start or under way, for the Reviews page's In progress section. Rows that
+* ended (ready, failed, already reviewed) are not here: what they made is in the list, and how they
+* failed is in the panel and on the review.
+*
+* This server's rows only, from memory: see `liveOperations` for why the queue is process-local.
+*/
+function pendingBatchRows() {
+	const pending = [];
+	for (const batch of batches.values()) batch.rows.forEach((row, index) => {
+		if (row.status !== "waiting" && row.status !== "reviewing") return;
+		const known = facts.get(row);
+		pending.push({
+			key: `${batch.id}:${index}`,
+			status: row.status,
+			label: row.label,
+			order: known?.order ?? 0,
+			...known?.takenAt === void 0 ? {} : { takenAt: known.takenAt },
+			...row.reviewId ? { reviewId: row.reviewId } : {},
+			...known?.repoPath ? { repoPath: known.repoPath } : {},
+			...known?.prNumber === void 0 ? {} : { prNumber: known.prNumber },
+			...known?.branch ? { branch: known.branch } : {}
+		});
+	});
+	return pending;
+}
+function forgetFinished(now) {
+	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: 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.
+*/
+/**
+* `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" && !prepared.existing.inProgress) row.status = "already-reviewed";
+	else begin(row);
+	if (prepared.kind === "resume") row.kept = keptOf(prepared.failure.agentId, prepared.failure.requestedModel, deps);
+	else delete row.kept;
+	return prepared;
+}
+/**
+* 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.
 */
-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;
+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);
 }
-/** A path a person typed, made absolute: `~` is their home folder, and anything relative is refused. */
-function expandPath(raw, home) {
-	const trimmed = raw.trim().replace(/(.)\/+$/, "$1");
-	if (!trimmed) return null;
-	const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") ? `${home}${trimmed.slice(1)}` : trimmed;
-	return isAbsolute(expanded) ? expanded : null;
+async function settleRow(row, settling) {
+	const settled = await settling;
+	if (settled.ok) row.status = "ready";
+	else if (settled.stopped) {
+		row.status = "failed";
+		row.reason = "Stopped";
+	} else fail(row, settled.reason);
 }
-function message(error) {
-	return error instanceof Error ? error.message : String(error);
+/**
+* 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;
 }
-/** Why no agent could be used, in a sentence for the panel. The CLI's own wording names flags. */
-function unresolvedAgent(resolution) {
-	switch (resolution.kind) {
-		case "none": return "No review agent is installed on this machine. Install one of the agents PR Review Buddy supports, then try again.";
-		case "unknown-id": return `"${resolution.id}" is not an agent PR Review Buddy knows. Choose another under Review options, or change the default in Settings.`;
-		case "unavailable": return `${resolution.agent.displayName} can't be used from the workspace: ${resolution.reason}`;
+/**
+* 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);
+	begin(row);
+	if (kept) {
+		row.kept = kept;
+		return settleRow(row, deps.settle(reviewId));
 	}
+	follow(batch, settleRow(row, deps.observe(reviewId)), deps, false);
 }
 /**
-* The agent a submission runs under: the one named under Review options, or else the same answer
-* the CLI reaches with no flag (the configured default, or the only one installed). Never the
-* harness's own fallback: an id is always passed down, so `startJob` never has to guess.
+* 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.
 */
-async function agentFor(flag, deps) {
-	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.", { field: "agent" });
-	return refuse(resolution.kind === "unknown-id" ? 400 : 409, unresolvedAgent(resolution), { field: "agent" });
+function keepFreshPending(row, replaced) {
+	if (row.status === "failed" && !replaced) row.stale = true;
 }
-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.", { field: "model" });
-	return value.trim() || void 0;
+function keptOf(agentId, model, deps) {
+	return {
+		agent: deps.agentName(agentId),
+		...model ? { model } : {}
+	};
 }
 /**
-* The tail of each target's queue of creations, by batch identity. In-process, like the fetch
-* queue in `target.ts`.
+* Start a batch and answer at once. The analyses take minutes, and the panel is not a progress
+* dialog: it may watch the batch while it stays open, and the reviews appear in the list either way.
 *
-* `prepareReview` looks for an existing review and then creates one, and nothing between the two
-* stops a second start of the same target, from another tab or another paste, from looking in the
-* same gap and creating a second review of it. One at a time per target closes that gap for every
-* start this server makes; the second one finds the first one's review.
+* Each pull request waits for one of the server's analysis slots (`deps.slots`), shared with every
+* other batch and every branch review, and is resolved and created only once it has one.
 */
-var creations = /* @__PURE__ */ new Map();
-function oneCreationAtATime(target, work) {
-	const key = batchIdentity(target);
-	const mine = (creations.get(key) ?? Promise.resolve()).then(work, work);
-	const tail = mine.catch(() => {});
-	creations.set(key, tail);
-	tail.then(() => {
-		if (creations.get(key) === tail) creations.delete(key);
-	});
-	return mine;
+async function startPullRequestBatch(body, deps) {
+	const raw = Array.isArray(body?.items) ? body.items : null;
+	if (!raw || raw.length === 0) return refuse(400, "Say which pull requests to review.");
+	if (raw.length > MAX_BATCH) return refuse(400, `At most ${MAX_BATCH} pull requests can be started at once.`);
+	const items = [];
+	for (const entry of raw) {
+		const url = typeof entry?.url === "string" ? entry.url : "";
+		const link = parsePullRequestLink(url);
+		if (!link || link.kind !== "github") return refuse(400, `${url || "That"} is not a github.com pull request link.`);
+		const folder = typeof entry?.folder === "string" ? expandPath(entry.folder, deps.home) : null;
+		if (!folder) return refuse(400, `Choose a local folder for ${link.owner}/${link.repo} #${link.number}.`);
+		items.push({
+			url: link.url,
+			owner: link.owner,
+			repo: link.repo,
+			number: link.number,
+			key: link.key,
+			folder
+		});
+	}
+	const model = modelOf(body?.model);
+	if (isAnswer(model)) return model;
+	const agent = await agentFor(body?.agent, deps);
+	if (isAnswer(agent)) return agent;
+	const batch = newBatch(items.map((item) => ({
+		key: item.key,
+		label: `${item.owner}/${item.repo} #${item.number}`,
+		status: "waiting"
+	})));
+	batch.rows.forEach((row, index) => noteRow(row, {
+		repoPath: items[index].folder,
+		prNumber: items[index].number
+	}));
+	/** Which row claimed each pull request, by what it resolved to rather than how it was spelled. */
+	const claimed = /* @__PURE__ */ new Map();
+	/** 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();
+		begin(row);
+		/** A fresh start has made its review, so the row now belongs to the new target. */
+		let replaced = false;
+		try {
+			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 identity = batchIdentity(target);
+			const first = claimed.get(identity);
+			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);
+			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) {
+			fail(row, error);
+		} finally {
+			if (fresh) keepFreshPending(row, replaced);
+			release();
+		}
+	};
+	batch.rerun = (index, fresh) => follow(batch, lane(items[index], index, fresh), deps);
+	follow(batch, runBatch(items, {
+		concurrency: deps.concurrency,
+		run: lane
+	}), deps);
+	return {
+		status: 200,
+		body: {
+			batchId: batch.id,
+			rows: rowsOf(batch)
+		}
+	};
 }
-var isAnswer = (value) => typeof value === "object" && value !== null && "status" in value && "body" in value;
-async function addReviewOptions(deps) {
-	const [agents, resolution] = await Promise.all([deps.agents(), deps.resolveAgent()]);
+/**
+* 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 lostBatch();
+	batch.seenAt = Date.now();
+	return {
+		status: 200,
+		body: {
+			rows: rowsOf(batch),
+			finished: batch.finishedAt !== null
+		}
+	};
+}
+/**
+* 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";
+	const known = facts.get(row);
+	if (known) delete known.takenAt;
+	delete row.reason;
+	delete row.detail;
+	delete row.stale;
+	batch.seenAt = Date.now();
+	batch.rerun(index, fresh === true);
 	return {
 		status: 200,
 		body: {
-			agents,
-			agent: resolution.kind === "resolved" ? {
-				kind: "resolved",
-				id: resolution.agent.id,
-				displayName: resolution.agent.displayName
-			} : resolution.kind === "ambiguous" ? { kind: "ambiguous" } : {
-				kind: "refused",
-				error: unresolvedAgent(resolution)
-			},
-			canChooseFolder: deps.chooseFolder !== null
+			rows: rowsOf(batch),
+			finished: false
 		}
 	};
 }
-function reviewedRow(reviewId, deps) {
-	const kept = deps.resumeOf(reviewId);
-	return {
-		reviewId,
-		...kept ? { kept } : {}
-	};
-}
-function folderOption(folder, home) {
+/** The recent and discoverable folders, for the Branch panel's list. */
+async function listFolders(deps) {
 	return {
-		path: folder.path,
-		display: displayPath(folder.path, home),
-		branch: folder.branch
+		status: 200,
+		body: { folders: (await deps.folders()).map((folder) => ({
+			...folderOption(folder, deps.home),
+			repo: folder.remote ? folder.remote.repo : basename(folder.path)
+		})) }
 	};
 }
 /**
-* What a paste would start, without starting anything: rows, the folders each could run in, and
-* which already have a review. No forge is asked and nothing is fetched, so it is cheap enough to
-* run on every pause in typing.
+* What reviewing this folder would review, read without changing anything: the same target a bare
+* `prreviewbuddy` here would resolve, and the review it would find.
 *
-* Every link gets a row, however many there are. Past the batch limit the panel refuses to start
-* rather than this quietly dropping the tail: a reviewer who pasted twenty-one pull requests and
-* got twenty reviews would not find out which one was missing.
+* With the base the reviewer named, when they named one, so what this checks is the comparison
+* that would be submitted. Without it, a repository whose default base is ambiguous could never be
+* reviewed from here, though naming the base is exactly what settles it.
 */
-async function previewPullRequests(text, deps) {
-	if (typeof text !== "string") return refuse(400, "Paste the pull request links to review.");
-	const links = extractPullRequestLinks(text);
-	const [folders, summaries] = links.some((link) => link.kind === "github") ? [await deps.folders(), deps.summaries()] : [[], []];
-	return {
+async function inspectFolder(rawPath, deps, rawBase) {
+	const path = typeof rawPath === "string" ? expandPath(rawPath, deps.home) : null;
+	if (!path) return {
 		status: 200,
 		body: {
-			rows: links.map((link) => {
-				if (link.kind === "unsupported") return {
-					key: link.key,
-					label: `${link.provider} ${link.provider === "GitLab" ? "merge request" : "pull request"}`,
-					url: link.url,
-					ok: false,
-					reason: unsupportedReason(link.provider),
-					folders: []
-				};
-				const label = `${link.owner}/${link.repo} #${link.number}`;
-				const candidates = candidatesFor(folders, link, summaries);
-				if (candidates.length === 0) return {
-					key: link.key,
-					label,
-					url: link.url,
-					ok: false,
-					reason: "Local repository not found",
-					needsFolder: true,
-					folders: []
-				};
-				const reviewed = reviewedIn(candidates, link, summaries);
-				return {
-					key: link.key,
-					label,
-					url: link.url,
-					ok: true,
-					folders: candidates.map((folder) => folderOption(folder, deps.home)),
-					folder: candidates[0].path,
-					...reviewed ? { reviewed: reviewedRow(reviewed.id, deps) } : {}
-				};
-			}),
-			limit: MAX_BATCH
+			ok: false,
+			error: "Enter the full path of a folder, or choose one."
 		}
 	};
-}
-var batches = /* @__PURE__ */ new Map();
-function forgetFinished(now) {
-	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: now,
-		seenAt: now,
-		running: 0,
-		rerun: () => {}
+	const named = typeof rawBase === "string" && rawBase.trim() ? rawBase.trim() : void 0;
+	let target;
+	try {
+		target = await deps.resolveBranch(path, named);
+	} catch (error) {
+		return {
+			status: 200,
+			body: {
+				ok: false,
+				...refusalOf(error)
+			}
+		};
+	}
+	const [remote, base, existing] = await Promise.all([
+		deps.remoteOf(target.originRepoPath),
+		named ? Promise.resolve(named) : deps.defaultBase(target.originRepoPath),
+		deps.findExisting(target)
+	]);
+	const kept = existing ? deps.resumeOf(existing.id) : null;
+	return {
+		status: 200,
+		body: {
+			ok: true,
+			path: target.originRepoPath,
+			display: displayPath(target.originRepoPath, deps.home),
+			repo: remote ? remote.repo : basename(target.originRepoPath),
+			branch: target.branch,
+			base,
+			...existing ? { reviewed: {
+				reviewId: existing.id,
+				inProgress: existing.inProgress,
+				...kept ? { kept } : {}
+			} } : {}
+		}
 	};
-	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.
+* Review the branch checked out in a folder: `prreviewbuddy` run there.
+*
+* 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.
 */
-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();
+async function startBranchReview(body, deps) {
+	const path = typeof body?.path === "string" ? expandPath(body.path, deps.home) : null;
+	if (!path) return refuse(400, "Choose the working folder to review.");
+	const base = typeof body?.base === "string" && body.base.trim() ? body.base.trim() : void 0;
+	const model = modelOf(body?.model);
+	if (isAnswer(model)) return model;
+	let target;
+	try {
+		target = await deps.resolveBranch(path, base);
+	} catch (error) {
+		return {
+			status: 400,
+			body: refusalOf(error)
+		};
+	}
+	const agent = await agentFor(body?.agent, deps);
+	if (isAnswer(agent)) return agent;
+	const row = {
+		key: batchIdentity(target),
+		label: target.branch,
+		status: "waiting"
+	};
+	const batch = newBatch([row]);
+	noteRow(row, {
+		repoPath: target.originRepoPath,
+		branch: target.branch
 	});
+	/**
+	* 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;
+		begin(row);
+		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)) {
+			row.reviewId = existing.id;
+			if (!existing.inProgress) {
+				row.status = "already-reviewed";
+				return answer("existing");
+			}
+			begin(row);
+			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();
+		batches.delete(batch.id);
+		return {
+			status: 409,
+			body: refusalOf(error)
+		};
+	}
+	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);
 }
-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.
-*/
-/**
-* `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 = 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 chooseFolder(deps) {
+	if (!deps.chooseFolder) return refuse(404, "Choosing a folder is not available on this system. Type its path instead.");
+	try {
+		const path = await deps.chooseFolder();
+		return {
+			status: 200,
+			body: path ? { path } : { cancelled: true }
+		};
+	} catch (error) {
+		return refuse(500, message(error));
+	}
 }
+//#endregion
+//#region ../../packages/review-harness/src/workspace/live_operations.ts
 /**
-* 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.
+* The review work going on now, as one list: the one place that gathers it.
+*
+* The Reviews page's In progress section is its first reader, and anything else that monitors
+* execution should read this rather than gathering the same facts again. The rule that turns the
+* facts into entries is `deriveOperations`; this only supplies them, with the claim test
+* `analysisStates` uses, so the list and a card's analysis line never disagree about what is running.
+*
+* **Two scopes, on purpose.**
+*
+* - **Running work is machine-wide.** Jobs live in the store on disk and are claimed by whichever
+*   process drives them, so a review started from a terminal, an MCP session or this server is
+*   listed here alike.
+* - **Queued work is this process's only.** Rows waiting for an analysis slot are held in memory by
+*   the server that accepted them (`pendingBatchRows`, from `add_review.ts`). Another process's
+*   waiting work, such as the later pull requests of a `prreviewbuddy review --pr …` batch, is not
+*   listed until it starts and has a job. A restart forgets this server's own waiting rows too.
+*
+* Nothing persists or shares the queue across processes, and nothing here should claim it does.
+*
+* `jobs` and `rows` are injected so a caller with its own snapshot, or a test, can hand them in.
 */
-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 if (settled.stopped) {
-		row.status = "failed";
-		row.reason = "Stopped";
-	} else fail(row, settled.reason);
+function liveOperations(now = Date.now(), jobs = allJobs(), rows = pendingBatchRows()) {
+	return deriveOperations(jobs, (job) => isClaimed(job.id, now), rows);
 }
+//#endregion
+//#region ../../packages/review-harness/src/workspace/reviews_revision.ts
 /**
-* 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.
+* Whether anything the reviews index draws has changed, as one token.
+*
+* The index reacts to a change by reloading, which is what makes an aggregate the right shape: it
+* never needs to know *which* review changed, so it asks one question whose cost is the same for
+* five reviews and five hundred. Per-card revisions would be more information than the page has any
+* use for, and a request per card to carry it.
+*
+* Opaque and **equality only**, the same contract as `workspaceRevision` in `store.ts`: compare two
+* tokens for equality, never order them, never parse one. The implementation below is a hash of
+* facts the page happens to draw today, and the whole point of saying so here is that it can be
+* replaced by a counter, a watch, or anything else without a page having to be told.
+*
+* ## What is in it, and what is deliberately not
+*
+* In: every review's id and file revision, and the phase of every analysis running right now.
+* Between them those cover everything a card shows — the summary, the risk badge, the counts, the
+* pin, the reviewed mark, the running line — because every one of those reaches disk through
+* `writeWorkspace`, and the set of ids covers a review appearing or being deleted.
+*
+* Not in: **`job.updatedAt` and `job.progress`.** This is the load-bearing omission. An agent
+* streams its progress into the job record every few seconds, so a token derived from job file
+* mtimes would differ on nearly every poll, and a page that reloads whenever the token differs
+* would then reload every few seconds for the whole length of an analysis — a page thrashing
+* itself, with the reviewer's scroll position going with it. Phase only, which changes four times
+* in a run.
 */
-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.
+* What is being done to each review, or was last done and stopped.
 *
-* 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.
+* Keyed by review, valued by the phase the card should name. Two states reach it and a third
+* deliberately does not:
+*
+* - **Running.** A job that is not terminal *and* whose driver holds a live claim. The claim is the
+*   load-bearing half: a job whose driver was killed sits in a working phase for up to half an hour
+*   before the sweep calls it stopped, and narrating one of those as "Analysing the change" would
+*   be the index confidently reporting work that nothing is doing.
+* - **`failed`.** Reported whether or not anything still holds the claim, which is the whole reason
+*   this function is not simply `runningJobs`. It was: `runningJobs` drops terminal jobs, and
+*   `isTerminal` counts `failed` as terminal, so a failed analysis could never reach the renderer
+*   and the card's "Analysis stopped" branch was unreachable in production while passing a unit
+*   test that handed it a state the product could not produce. A review whose analysis failed went
+*   back to reading "No standard review yet" the moment its driver let go.
+* - **`done`, and an unclaimed job still in a working phase.** Nothing. A finished job has its
+*   result on the card already, and an abandoned one is the sweep's to judge rather than this
+*   renderer's to pre-empt.
+*
+* **Every job a review has, not the latest one.** A review accumulates them -- a standard analysis,
+* a KISS run, a retry -- and two of them genuinely run at once: `handleKiss` refuses only a second
+* KISS run, and the review page's poll is built around one finishing while the other goes on. An
+* earlier cut picked the single newest job and then asked what it was, so a KISS run that ended
+* first spoke for a standard analysis that was still working, and the card fell silent on work that
+* was happening in front of the reviewer.
+*
+* So the precedence is running, then the most recent ending, and it is stated in that order because
+* that is the property: **nothing that has ended can hide something that has not.**
+*
+* `jobs` is injected only so a test can hand the same set in two different orders and prove the
+* answer does not move. Production always reads the directory.
+*
+* A failure is visible for as long as the job record survives, which is the sweep's retention. Once
+* that passes the card quietly returns to saying nothing, which is the same silence every review
+* had before this existed.
 */
-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));
+function analysisStates(now = Date.now(), jobs = allJobs()) {
+	const byReview = /* @__PURE__ */ new Map();
+	for (const job of jobs) {
+		if (purposeOf(job) === "ask") continue;
+		const held = byReview.get(job.workspaceId);
+		if (held) held.push(job);
+		else byReview.set(job.workspaceId, [job]);
 	}
-	follow(batch, settleRow(row, deps.observe(reviewId)), deps, false);
+	/**
+	* Both comparators are **total**, and that is a requirement rather than tidiness.
+	*
+	* `allJobs` reads a directory, so a tie leaves the winner to whatever order the filesystem
+	* happened to return. This function's output is hashed into the index token, and the page reloads
+	* whenever that token changes -- so an arbitrary winner is not a cosmetic wobble, it is the page
+	* reloading itself for as long as the tie exists, with no cause a reviewer could ever see. The
+	* same hazard the sorting rule was written for, one level further down.
+	*
+	* Ties are real. Two jobs can carry the same timestamp to the millisecond, and a record written
+	* before `finishedAt` existed falls back to `updatedAt`, which two records can share. The id is
+	* the last resort because it is the only field guaranteed to differ.
+	*/
+	const byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+	const startedLast = (a, b) => b.startedAt - a.startedAt || byId(a, b);
+	const endedLast = (a, b) => endedAt(b) - endedAt(a) || b.startedAt - a.startedAt || byId(a, b);
+	const states = /* @__PURE__ */ new Map();
+	for (const [reviewId, jobs] of byReview) {
+		const running = jobs.filter((job) => !isTerminal(job) && isClaimed(job.id, now)).sort(startedLast);
+		if (running.length > 0) {
+			states.set(reviewId, {
+				phase: running[0].phase,
+				purpose: purposeOf(running[0])
+			});
+			continue;
+		}
+		const ended = jobs.filter((job) => isTerminal(job) && purposeOf(job) === "review").sort(endedLast);
+		if (ended[0]?.phase === "failed") states.set(reviewId, {
+			phase: "failed",
+			purpose: "review",
+			...ended[0].failure?.stopped ? { stopped: true } : {}
+		});
+	}
+	return states;
 }
 /**
-* 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.
+* The token.
+*
+* Takes the live analyses rather than reading them, so that one request answers with a token and a
+* running state that describe the same instant. Computing them separately would let a phase change
+* land between the two, and the page would then be told "nothing has changed" alongside a state it
+* had not seen.
 */
-function keepFreshPending(row, replaced) {
-	if (row.status === "failed" && !replaced) row.stale = true;
+function reviewsRevision(live = analysisStates(), operations = liveOperations()) {
+	const hash = createHash("sha1");
+	for (const [id, revision] of workspaceStamps()) hash.update(`${id}:${revision}\n`);
+	for (const id of [...live.keys()].sort()) {
+		const state = live.get(id);
+		hash.update(`${id}@${state.purpose}:${state.phase}${state.stopped ? ":stopped" : ""}\n`);
+	}
+	for (const operation of [...operations].sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0)) hash.update(`op:${operation.key}:${operation.kind}:${operation.phase ?? ""}:${operation.reviewId ?? ""}\n`);
+	hash.update(`queue:${queueStamp()}\n`);
+	for (const [id, kind] of [...movedReviews()].sort(([a], [b]) => a.localeCompare(b))) hash.update(`moved:${id}:${kind}\n`);
+	for (const [key, state] of [...prStatesByRequest()].sort(([a], [b]) => a.localeCompare(b))) hash.update(`pr:${key}:${state}\n`);
+	for (const [key, entry] of Object.entries(readWatch()).sort(([a], [b]) => a.localeCompare(b))) if (entry.changedAt !== void 0) hash.update(`head:${key}:${entry.changedAt}\n`);
+	for (const [key, entry] of Object.entries(readPrStates()).sort(([a], [b]) => a.localeCompare(b))) if (entry.changedAt !== void 0) hash.update(`pr-changed:${key}:${entry.changedAt}\n`);
+	return hash.digest("base64url");
 }
-function keptOf(agentId, model, deps) {
-	return {
-		agent: deps.agentName(agentId),
-		...model ? { model } : {}
-	};
+function asKind(value) {
+	return value === "issue" || value === "question" ? value : null;
 }
-/**
-* Start a batch and answer at once. The analyses take minutes, and the panel is not a progress
-* dialog: it may watch the batch while it stays open, and the reviews appear in the list either way.
-*
-* Each pull request waits for one of the server's analysis slots (`deps.slots`), shared with every
-* other batch and every branch review, and is resolved and created only once it has one.
-*/
-async function startPullRequestBatch(body, deps) {
-	const raw = Array.isArray(body?.items) ? body.items : null;
-	if (!raw || raw.length === 0) return refuse(400, "Say which pull requests to review.");
-	if (raw.length > MAX_BATCH) return refuse(400, `At most ${MAX_BATCH} pull requests can be started at once.`);
-	const items = [];
-	for (const entry of raw) {
-		const url = typeof entry?.url === "string" ? entry.url : "";
-		const link = parsePullRequestLink(url);
-		if (!link || link.kind !== "github") return refuse(400, `${url || "That"} is not a github.com pull request link.`);
-		const folder = typeof entry?.folder === "string" ? expandPath(entry.folder, deps.home) : null;
-		if (!folder) return refuse(400, `Choose a local folder for ${link.owner}/${link.repo} #${link.number}.`);
-		items.push({
-			url: link.url,
-			owner: link.owner,
-			repo: link.repo,
-			number: link.number,
-			key: link.key,
-			folder
-		});
+/** What the page sent, or null when it is not a request a host understands. */
+function parseReassessmentRequest(value) {
+	const body = value;
+	if (body?.op === "decide") {
+		if (typeof body.proposalId !== "string" || body.proposalId === "") return null;
+		if (body.decision !== "accepted" && body.decision !== "declined") return null;
+		return {
+			op: "decide",
+			proposalId: body.proposalId,
+			decision: body.decision
+		};
+	}
+	if (body?.op === "set") {
+		const kind = asKind(body.kind);
+		if (!kind || typeof body.id !== "string" || body.id === "") return null;
+		if (!isGradeFor(kind, body.to)) return null;
+		if (body.from !== null && !isGradeFor(kind, body.from)) return null;
+		if (body.reason !== void 0 && typeof body.reason !== "string") return null;
+		const reason = typeof body.reason === "string" ? body.reason.trim().slice(0, 500) : "";
+		return {
+			op: "set",
+			kind,
+			findingId: body.id,
+			from: body.from,
+			to: body.to,
+			...reason ? { reason } : {}
+		};
 	}
-	const model = modelOf(body?.model);
-	if (isAnswer(model)) return model;
-	const agent = await agentFor(body?.agent, deps);
-	if (isAnswer(agent)) return agent;
-	const batch = newBatch(items.map((item) => ({
-		key: item.key,
-		label: `${item.owner}/${item.repo} #${item.number}`,
-		status: "waiting"
-	})));
-	/** Which row claimed each pull request, by what it resolved to rather than how it was spelled. */
-	const claimed = /* @__PURE__ */ new Map();
-	/** 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 {
-			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 identity = batchIdentity(target);
-			const first = claimed.get(identity);
-			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);
-			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) {
-			fail(row, error);
-		} finally {
-			if (fresh) keepFreshPending(row, replaced);
-			release();
-		}
+	return null;
+}
+var BAD_REASSESSMENT_REQUEST = "A reassessment either moves a finding to a grade on its scale, or accepts or declines a suggestion.";
+var REASSESSMENT_REFUSED = {
+	"not-a-grade": "That is not a grade this finding can have.",
+	unchanged: "The finding already has that grade.",
+	stale: "The grade has changed since this page was drawn. The card now shows it as it stands.",
+	outdated: "That suggestion was made against an earlier version of this review. Reassess again to judge it as it stands.",
+	"no-reason": "A suggestion needs a reason.",
+	unknown: "This review has no suggestion with that id.",
+	decided: "That suggestion has already been answered.",
+	"no-finding": "This review has no such finding."
+};
+function gradeFragments$1(session, kind, id) {
+	const finding = findingIn(session, kind, id);
+	if (!finding) return null;
+	const assessment = findingAssessment(session.findingReassessments, kind, finding, analysisRefOf(session));
+	const options = {
+		editable: true,
+		askMore: true
 	};
-	batch.rerun = (index, fresh) => follow(batch, lane(items[index], index, fresh), deps);
-	follow(batch, runBatch(items, {
-		concurrency: deps.concurrency,
-		run: lane
-	}), deps);
 	return {
-		status: 200,
-		body: {
-			batchId: batch.id,
-			rows: rowsOf(batch)
-		}
+		kind,
+		id,
+		current: assessment.current,
+		cardClass: cardGradeClass(kind, assessment.current),
+		grade: renderGradeControl(kind, assessment, options),
+		region: renderAssessmentRegion(kind, assessment, options),
+		copy: kind === "issue" ? issueMarkdown(finding, assessment) : questionMarkdown(finding, assessment)
 	};
 }
-/**
-* 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 lostBatch();
-	batch.seenAt = Date.now();
+/** The finding a request is about: named outright, or through the proposal it decides. */
+function findingOfRequest(session, request) {
+	if (request.op === "set") return {
+		kind: request.kind,
+		id: request.findingId
+	};
+	const proposal = session.findingReassessments?.find((entry) => entry.id === request.proposalId);
+	return proposal ? {
+		kind: proposal.kind,
+		id: proposal.findingId
+	} : null;
+}
+/** A refusal, with the card as the session has it so the page is brought up to date by the answer. */
+function refusedReply(session, request, refusal) {
+	const finding = findingOfRequest(session, request);
+	const card = finding ? gradeFragments$1(session, finding.kind, finding.id) : null;
 	return {
-		status: 200,
+		status: refusal === "stale" || refusal === "outdated" || refusal === "decided" ? 409 : 400,
 		body: {
-			rows: rowsOf(batch),
-			finished: batch.finishedAt !== null
+			error: REASSESSMENT_REFUSED[refusal],
+			refusal,
+			...card ? { card } : {}
 		}
 	};
 }
+//#endregion
+//#region ../../packages/review-harness/src/workspace/reassessment_state.ts
 /**
-* 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.
+* The reviewer's grade moves and their answers to proposals, as `/state` receives them.
+*
+* The request, its refusals and the card parts a reply carries are shared with the extension
+* (domain/ui/components/reassessment_reply.ts). What is the workspace's own is the store: checked
+* against a fresh read before writing, so a refusal leaves the file alone, and checked again inside
+* the write, where the answer is final.
 */
-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.");
+/** A stored review's card parts for one finding. */
+function gradeFragments(workspace, kind, id) {
+	return gradeFragments$1(workspace.session, kind, id);
+}
 /**
-* 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.
+* One write, onto the review as it is now, answered with the card as it now stands. `now` is
+* injectable so a test can name the time an entry records.
 */
-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);
+function applyReassessmentRequest(workspaceId, value, now = Date.now) {
+	const request = parseReassessmentRequest(value);
+	if (!request) return {
+		status: 400,
+		body: { error: BAD_REASSESSMENT_REQUEST }
+	};
+	const before = loadWorkspace(workspaceId);
+	if (!before) return {
+		status: 404,
+		body: { error: "No such review" }
+	};
+	const early = reassessIn(structuredClone(before.session), request, now());
+	if (!early.ok) return refusedReply(before.session, request, early.refusal);
+	let outcome = null;
+	const saved = mutateWorkspace(workspaceId, (current) => {
+		outcome = reassessIn(current.session, request, now());
+	});
+	if (!saved || !outcome) return {
+		status: 404,
+		body: { error: "No such review" }
+	};
+	const written = outcome;
+	if (!written.ok) return refusedReply(saved.session, request, written.refusal);
+	const card = gradeFragments(saved, written.entry.kind, written.entry.findingId);
 	return {
 		status: 200,
 		body: {
-			rows: rowsOf(batch),
-			finished: false
+			ok: true,
+			entry: written.entry,
+			...card ? { card } : {}
 		}
 	};
 }
-/** The recent and discoverable folders, for the Branch panel's list. */
-async function listFolders(deps) {
+//#endregion
+//#region ../../packages/review-harness/src/domain/ai_review/reassess_prompt.ts
+/** More than any real answer cites; a list longer than this is padding, not evidence. */
+var MAX_EVIDENCE = 10;
+function scaleText(kind) {
+	return gradeScale(kind).map((grade) => `"${grade}"`).join(" | ");
+}
+/** What the grade means, in the words the analysis prompt uses for it. */
+function gradeMeaning(kind) {
+	return kind === "issue" ? "Severity is how much the issue would matter if it is real. It is not how sure anyone is that it is real." : "Importance is how much of the reviewer's attention the question deserves before they can approve.";
+}
+function findingText(kind, finding) {
+	if (kind === "issue") {
+		const issue = finding;
+		const where = issue.file ? `\nLocation: ${issue.file}${issue.line ? `:${issue.line}` : ""}` : "";
+		return `Issue: ${issue.title.trim()}\n${issue.description.trim()}${where}`;
+	}
+	const question = finding;
+	const why = question.whyThisMatters?.trim() ? `\nWhy it matters: ${question.whyThisMatters.trim()}` : "";
+	return `Question: ${question.question.trim()}${why}${question.file ? `\nFile: ${question.file}` : ""}`;
+}
+function historyText(assessment) {
+	if (!assessment.history.length) return "It has not been reassessed before.";
+	return ["Earlier moves of this grade, oldest first:", ...assessment.history.map((step) => `- ${step.from ?? "ungraded"} → ${step.to}, ${sourcePhrase(step.source)}${step.reason ? `: ${step.reason}` : ""}`)].join("\n");
+}
+function threadText(thread) {
+	if (!thread) return [];
+	const comments = thread.comments.filter((comment) => !comment.authorIsBot && comment.body.trim());
+	if (!comments.length) return [];
+	return [`THE PULL REQUEST THREAD THIS FINDING WAS TIED TO (${thread.resolved ? "resolved" : "unresolved"}):`, ...comments.map((comment) => `@${comment.author}: ${comment.body.trim()}`)];
+}
+/** The block a Reassess turn adds to the ordinary Buddy prompt. */
+function buildReassessInstructions(input) {
+	const { kind, finding, assessment } = input;
+	const noun = kind === "issue" ? "severity" : "importance";
+	const current = assessment.current;
+	return [
+		"---",
+		`THE REVIEWER ASKED YOU TO REASSESS THE ${noun.toUpperCase()} OF THIS ${kind.toUpperCase()}:`,
+		findingText(kind, finding),
+		`Its ${noun} now: ${promptGrade(assessment)}.`,
+		historyText(assessment),
+		...input.explanation?.trim() ? ["An explanation of it you gave earlier:", input.explanation.trim()] : [],
+		...threadText(input.thread),
+		"---",
+		`Judge whether its ${noun} should change, using the code in the checkout and everything above, including this conversation. ${gradeMeaning(kind)} Read the code that decides it rather than reasoning from the finding's wording.`,
+		`Raising it is as legitimate as lowering it. "keep" is a good answer, and the right one whenever the evidence does not clearly move it; do not change it because you were asked.`,
+		"Reply with a single JSON object and nothing else: no prose before or after it, no Markdown fence. Exactly this shape:",
+		`{ "verdict": "keep" | "change", "to"?: ${scaleText(kind)}, "reason": string, "evidence"?: [{ "file": string, "line"?: number }] }`,
+		`"to" is the new ${noun}, given only with "change", and must differ from ${current ? `"${current}"` : "the current one"}.`,
+		"\"reason\" is one to three sentences the reviewer will read on the card: name what in the code or the conversation moves it, or what leaves it where it is.",
+		"\"evidence\" is the places in the code that settle it, as paths relative to the repository root. Omit it rather than citing a file you did not read."
+	];
+}
+var REASSESS_ANSWER = objectWithAnyOf("verdict", "reason");
+function readEvidence(value) {
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	for (const item of value) {
+		const entry = item;
+		const file = typeof entry?.file === "string" ? entry.file.trim().replace(/^\.\//, "") : "";
+		if (!file) continue;
+		const line = typeof entry?.line === "number" && Number.isInteger(entry.line) && entry.line > 0 ? entry.line : void 0;
+		out.push(line === void 0 ? { file } : {
+			file,
+			line
+		});
+		if (out.length === MAX_EVIDENCE) break;
+	}
+	return out;
+}
+/**
+* The answer, or null when it cannot be read as one. Strict where it matters: a `change` must name a
+* grade on this finding's scale that differs from the current one, and every answer must give a
+* reason. A thin or confused answer is not repaired into a suggestion; the turn says it could not
+* use it, and nothing is proposed.
+*/
+function parseReassessAnswer(raw, kind, current) {
+	let parsed;
+	try {
+		parsed = JSON.parse(extractJsonText(raw, REASSESS_ANSWER));
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+	const obj = parsed;
+	const reason = typeof obj.reason === "string" ? obj.reason.trim() : "";
+	if (!reason) return null;
+	const evidence = readEvidence(obj.evidence);
+	if (obj.verdict === "keep") return {
+		verdict: "keep",
+		reason,
+		evidence
+	};
+	if (obj.verdict !== "change") return null;
+	if (!isGradeFor(kind, obj.to) || obj.to === current) return null;
 	return {
-		status: 200,
-		body: { folders: (await deps.folders()).map((folder) => ({
-			...folderOption(folder, deps.home),
-			repo: folder.remote ? folder.remote.repo : basename(folder.path)
-		})) }
+		verdict: "change",
+		to: obj.to,
+		reason,
+		evidence
 	};
 }
+//#endregion
+//#region ../../packages/review-harness/src/workspace/reassess_turn.ts
 /**
-* What reviewing this folder would review, read without changing anything: the same target a bare
-* `prreviewbuddy` here would resolve, and the review it would find.
+* The answer, with every cited place checked against the commit the review describes. A path that
+* is not there is dropped and the suggestion kept: the judgement may stand even when the model
+* misremembered where it read it, and a citation that leads nowhere is worse than none. If the check
+* itself fails, no evidence is kept rather than unchecked evidence.
 *
-* With the base the reviewer named, when they named one, so what this checks is the comparison
-* that would be submitted. Without it, a repository whose default base is ambiguous could never be
-* reviewed from here, though naming the base is exactly what settles it.
+* Kept, but not disguised: how many were dropped is recorded, so the card says the suggestion has
+* no verified code evidence rather than drawing it like one whose citations held. Acceptance does
+* not depend on it; a reason may be sound without a citation.
 */
-async function inspectFolder(rawPath, deps, rawBase) {
-	const path = typeof rawPath === "string" ? expandPath(rawPath, deps.home) : null;
-	if (!path) return {
-		status: 200,
-		body: {
-			ok: false,
-			error: "Enter the full path of a folder, or choose one."
-		}
+async function readReassessTurn(raw, target, where, check = existingPaths) {
+	const answer = parseReassessAnswer(raw, target.kind, target.from);
+	if (!answer || !answer.evidence.length) return {
+		answer,
+		raw,
+		droppedEvidence: 0
 	};
-	const named = typeof rawBase === "string" && rawBase.trim() ? rawBase.trim() : void 0;
-	let target;
+	let real;
 	try {
-		target = await deps.resolveBranch(path, named);
-	} catch (error) {
-		return {
-			status: 200,
-			body: {
-				ok: false,
-				...refusalOf(error)
-			}
-		};
+		real = await check(where.repoPath, [...new Set(answer.evidence.map((place) => place.file))], where.commitSha);
+	} catch {
+		real = /* @__PURE__ */ new Set();
 	}
-	const [remote, base, existing] = await Promise.all([
-		deps.remoteOf(target.originRepoPath),
-		named ? Promise.resolve(named) : deps.defaultBase(target.originRepoPath),
-		deps.findExisting(target)
-	]);
-	const kept = existing ? deps.resumeOf(existing.id) : null;
+	const evidence = answer.evidence.filter((place) => real.has(place.file));
 	return {
-		status: 200,
-		body: {
-			ok: true,
-			path: target.originRepoPath,
-			display: displayPath(target.originRepoPath, deps.home),
-			repo: remote ? remote.repo : basename(target.originRepoPath),
-			branch: target.branch,
-			base,
-			...existing ? { reviewed: {
-				reviewId: existing.id,
-				inProgress: existing.inProgress,
-				...kept ? { kept } : {}
-			} } : {}
-		}
+		answer: {
+			...answer,
+			evidence
+		},
+		raw,
+		droppedEvidence: answer.evidence.length - evidence.length
 	};
 }
 /**
-* Review the branch checked out in a folder: `prreviewbuddy` run there.
-*
-* 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.
+* Writes the suggestion onto the session, when there is one to write. Run inside the store write on
+* the fresh copy: the grade is checked against what is on disk now, so a move the reviewer made
+* while Buddy AI was answering makes the suggestion out of date rather than letting it land on a
+* grade it never saw.
 */
-async function startBranchReview(body, deps) {
-	const path = typeof body?.path === "string" ? expandPath(body.path, deps.home) : null;
-	if (!path) return refuse(400, "Choose the working folder to review.");
-	const base = typeof body?.base === "string" && body.base.trim() ? body.base.trim() : void 0;
-	const model = modelOf(body?.model);
-	if (isAnswer(model)) return model;
-	let target;
-	try {
-		target = await deps.resolveBranch(path, base);
-	} catch (error) {
-		return {
-			status: 400,
-			body: refusalOf(error)
-		};
-	}
-	const agent = await agentFor(body?.agent, deps);
-	if (isAnswer(agent)) return agent;
-	const row = {
-		key: batchIdentity(target),
-		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)) {
-			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();
-		batches.delete(batch.id);
-		return {
-			status: 409,
-			body: refusalOf(error)
-		};
-	}
-	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();
+function keepReassessTurn(session, target, turn, askedAt) {
+	if (!turn.answer) return "unreadable";
+	if (turn.answer.verdict === "keep" || !turn.answer.to) return "kept";
+	return reassessIn(session, {
+		op: "propose",
+		kind: target.kind,
+		findingId: target.id,
+		from: target.from,
+		to: turn.answer.to,
+		reason: turn.answer.reason,
+		...turn.answer.evidence.length ? { evidence: turn.answer.evidence } : {},
+		...turn.droppedEvidence ? { droppedEvidence: turn.droppedEvidence } : {},
+		source: {
+			kind: "buddy",
+			askedAt
 		}
-	})(), deps);
-	return answer(prepared.kind);
+	}, askedAt).ok ? "proposed" : "stale";
 }
-async function chooseFolder(deps) {
-	if (!deps.chooseFolder) return refuse(404, "Choosing a folder is not available on this system. Type its path instead.");
-	try {
-		const path = await deps.chooseFolder();
-		return {
-			status: 200,
-			body: path ? { path } : { cancelled: true }
-		};
-	} catch (error) {
-		return refuse(500, message(error));
-	}
+/** What the conversation shows for the turn, in words, never the JSON. */
+function reassessTurnText(target, turn, outcome) {
+	const from = target.from ?? "ungraded";
+	const answer = turn.answer;
+	if (!answer) return `${turn.raw.trim()}\n\n*This answer was not in the form a suggestion needs, so nothing was suggested and the grade is unchanged.*`;
+	if (answer.verdict === "keep") return `**Keep ${from}.** ${answer.reason}`;
+	const move = `**Suggests ${from} → ${answer.to}.** ${answer.reason}`;
+	return outcome === "stale" ? `${move}\n\n*The grade changed while this was being answered, so the suggestion was not kept. Reassess again to judge it as it stands.*` : `${move}\n\n*Accept or keep it on the card.*`;
 }
 //#endregion
 //#region ../../packages/review-harness/src/workspace/ask.ts
@@ -13592,6 +13864,7 @@ function handleIndex(req, res, params, indexToken) {
 	const cookie = indexCookieHeader(indexToken);
 	if (onward) return redirect(res, onward, cookie);
 	const states = analysisStates();
+	const operations = liveOperations();
 	const reviews = recentWorkspaces(Number.MAX_SAFE_INTEGER);
 	const everyGroup = groupByLineage(reviews);
 	const queue = settleQueue(everyGroup);
@@ -13603,10 +13876,11 @@ function handleIndex(req, res, params, indexToken) {
 		groups,
 		queue: queue.filter((id) => rendered.has(id)),
 		analyses: states,
+		operations,
 		moved: movedReviews(),
 		prStates: prStatesByRequest(),
 		activity,
-		revision: reviewsRevision(states),
+		revision: reviewsRevision(states, operations),
 		unreadNotifications: unreadCount$1(),
 		driving: isDriving(),
 		theme: readPreferences().theme,
@@ -14099,9 +14373,10 @@ function establishBaseline(reviewIds) {
 function handleRevision(req, res, indexToken) {
 	if (!indexToken || !secretMatches(indexToken, indexCookie(req))) return send(res, 403, { error: "Not authorised." });
 	const states = analysisStates();
+	const operations = liveOperations();
 	send(res, 200, {
-		revision: reviewsRevision(states),
-		live: anythingRunning(states),
+		revision: reviewsRevision(states, operations),
+		live: anythingRunning(states, operations),
 		driving: isDriving(),
 		unread: unreadCount$1()
 	});
@@ -14206,7 +14481,7 @@ async function handleSections(req, res, indexToken) {
 	if (req.method !== "POST") return send(res, 405, { error: "Use POST." });
 	if (!indexToken || !secretMatches(indexToken, indexCookie(req))) return send(res, 403, { error: "Not authorised." });
 	const body = await readJson(req);
-	if (!isIndexSection(body?.section) || typeof body?.collapsed !== "boolean") return send(res, 400, { error: "Not a section this page can fold." });
+	if (!isListSection(body?.section) || typeof body?.collapsed !== "boolean") return send(res, 400, { error: "Not a section this page can fold." });
 	writeSectionCollapsed(body.section, body.collapsed);
 	send(res, 200, { ok: true });
 }