prreviewbuddy 0.78.1 → 0.80.2

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, $i as AgentUnavailableError, $n as attemptIdOf, $r as isIssueOutstanding, $t as moveIds, A as parsePullRequestLink, Ai as resolveTarget, Ar as recentWorkspaces, At as readArchitecture, Bi as resolveAgent, Bn as requestJobStop, Br as isLifecycle, Bt as writeJsonAtomically, C as completeRun, Ci as followUpFindingId, Cn as hasAuthorContent, Cr as lineagePosition, Ct as RUNTIME_WORDS, D as relativeTime$1, Di as describeAuthorship, Dn as CODE_COPY_CLASS, Dt as checkArchitecture, E as stopRun, Ei as objectWithAnyOf, En as CODE_BLOCK_CLASS, Er as mutateWorkspace, Et as ARCHITECTURE_DIR, Fi as AmbiguousRefError, Fn as createWorktree, Fr as workspaceRevision, Ft as ownersOf, G as stopChild, Gn as checkReview, Gr as parseLifecycle, Gt as createArchitectureNotification, Hi as clearAgentPreference, Hr as lifecycleItemLabel, Ht as branchOf, I as settleQueue, Ii as shortNameOf, In as holdWorktree, Ir as workspaceStamps, It as QUOTE_LIMITS, J as writeServerRecord, Ji as agentById, Jn as fetchHead, Jr as queueAddMany, Jt as eventName, Ki as STORE_ROOT, Kn as followedBranch, Kr as sectionOf, Kt as createPrState, L as readIndexToken, Li as shorthandOf, Ln as isWorktreeHeld, Lr as LIFECYCLES, Lt as REPOSITORY_SCOPE, M as runBatch, Mi as DetachedHeadError, Mn as isBusy, Mt as storeArchitecture, N as activateQueued, Ni as isCommitReview, Nn as withReviewLock, Nt as storedScopes, O as batchIdentity, Oi as WITHHELD_REASON, On as escapeHtml$1, Or as presentedKissRunOf, Ot as loadArchitecture, P as compactQueue, Pi as resolveBase, Pn as MANAGED_ROOT, Pr as touchWorkspace, Pt as trackedFiles, Q as parseWorkspacePort, Qi as AgentCancelledError, Qn as allJobs, Qr as doneVerb, Qt as markReadForReview, Ri as git, Rn as readMarker, Rr as activityAttributes, Rt as ancestorsOf, S as beginRun, Si as wasReassessed, Sn as authorPreview, Sr as latestKissRun, St as recordRuntimeBestEffort, T as reportRun, Ti as extractJsonText, Tn as renderMarkdown, Tt as formatDuration, U as serverEntryExists, Ui as readAgentPreference, Un as findExistingReview, Ur as lifecyclePill, Ut as subjectOf, V as readServerRecord, Vi as resolveModel, Vr as lifecycleChip, Vt as announceJob, W as spawnServer, Wi as writeAgentPreference, Wn as checkCodeFreshness, Wr as offersLifecycle, Wt as categoryOf, X as MAX_WORKSPACE_PORT, Xi as detectAgents, Xn as fillFileUrlTemplate, Xr as queueStamp, Xt as markAllRead, Y as DEFAULT_WORKSPACE_PORT, Yi as agentFor$1, Yn as forgeResolver, Yr as queueRemove, Yt as listNotifications, Z as MIN_WORKSPACE_PORT, Zi as isAgentId, Zn as RUN_RECORD_RETENTION_MS, Zr as readQueue, Zt as markRead, _i as gradeScale, _n as isUnchanged, _r as groupByLineage, _t as BUILD_VERSION, a as wasBlocked, ai as processDiscussion, an as toneOf, ar as saveJob, at as settleReview, b as track, bi as reassessIn, bn as chatConversationSection, br as kissDecisionRefusal, bt as waitingHistory, c as RefreshUnavailableError, ci as explanationOf, cn as withUsageRecorded, cr as isTerminalJobPhase, d as mergeUpdateInto, di as ANALYSIS_ONLY, dn as adoptLegacyBaseline, dr as purposeOf, dt as record, ei as isQuestionOutstanding, en as pruneNotifications, er as endedAt, et as statedWorkspacePort, f as updateReview, fi as analysisRefOf, fn as prepareConversationWithin, gi as findingIn, gn as refreshPrContext, gr as followedRefName, h as liveUpdateFor, hi as findingAssessment, hn as unforeseenFailure, hr as decideKissRecommendation, ht as telemetryUploadConsent, i as liveJobsFor, ii as reviewerDispositions, in as retireNotification, ir as pruneJobResidue, it as prepareReview, j as unsupportedReason, ji as originRemote, jn as ReviewBeingDeletedError, jr as reviewedCommit, jt as repositoryKey, k as extractPullRequestLinks, ki as kissOutcome, kn as renderInlineText, kr as previousKissResult, kt as partFiles, l as cancelUpdate, li as isExplanationAction, ln as existingPaths, lr as phasesFor, m as UpdateAlreadyRunningError, mi as currentGradeIn, mn as storedConversation, mt as recordTelemetryUploadConsent, n as deleteReview, ni as questionsOutstanding, nn as readStateOf, nr as isTerminal, nt as failureOf$1, o as discardJob, oi as recommendationsOf, on as unreadAround, ot as reanalyseReview, p as askCheckout, pi as assessmentLookup, pn as saveRefresh, pr as isClaimed, qi as AGENT_IDS, qn as reviewedShaOf, qr as queueAdd, qt as createPrUpdate, r as lineageIds, ri as resolvedByConversation, rn as removeNotification, rr as loadJob, rt as observeReview, s as FETCH_TIMEOUT_MS, si as explanationActionOf, sn as unreadCount$1, sr as isLiveJob, st as runJob, t as deleteLineage, ti as issuesOutstanding, tn as readNotification, tr as fail$1, tt as writePortPreference, u as cancellableHere, ui as withExplanation, un as ASK_REREAD_CEILING_MS, ur as progressSteps, ut as readEvents, v as startKissJob, vi as isGradeFor, vn as agentEnvOf, vr as indexKeptIds, w as endRun, wi as asString, wn as GITHUB_MARKDOWN, wr as loadWorkspace, wt as describeRuntimes, x as RUN_KINDS, xi as sourcePhrase, xn as UNESTABLISHED_MOTIVATION, xr as kissDecisionsOf, xt as mapRuntimes, y as isDriving, yi as promptGrade, yn as EXPLAIN_SIMPLY_PROMPT, yr as indexReviewGroups, yt as feedbackUrl, z as clearServerRecordOwnedBy, zi as refExists, zn as removeWorktree, zr as activityLabel, zt as isArchitectureId } from "./delete_review-BXfGCvQ1.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;
 }
@@ -688,6 +704,7 @@ var PATHS = {
 	prcontext: "<path d=\"M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z\"/>",
 	recommendations: "<path d=\"M9 18h6M10 22h4\"/><path d=\"M12 2a7 7 0 0 0-4 12.7c.6.5 1 1.2 1 2V17h6v-.3c0-.8.4-1.5 1-2A7 7 0 0 0 12 2z\"/>",
 	reviews: "<path d=\"M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01\"/>",
+	runs: "<path d=\"M22 12h-4l-3 9L9 3l-3 9H2\"/>",
 	notifications: "<path d=\"M18 8a6 6 0 0 0-12 0c0 7-3 9-3 9h18s-3-2-3-9\"/><path d=\"M13.7 21a2 2 0 0 1-3.4 0\"/>",
 	settings: "<circle cx=\"12\" cy=\"12\" r=\"3\"/><path d=\"M19.4 15a1.7 1.7 0 0 0 .3 1.8l.1.1a2 2 0 1 1-2.8 2.8l-.1-.1a1.7 1.7 0 0 0-1.8-.3 1.7 1.7 0 0 0-1 1.5V21a2 2 0 1 1-4 0v-.1a1.7 1.7 0 0 0-1.1-1.5 1.7 1.7 0 0 0-1.8.3l-.1.1a2 2 0 1 1-2.8-2.8l.1-.1a1.7 1.7 0 0 0 .3-1.8 1.7 1.7 0 0 0-1.5-1H3a2 2 0 1 1 0-4h.1a1.7 1.7 0 0 0 1.5-1.1 1.7 1.7 0 0 0-.3-1.8l-.1-.1a2 2 0 1 1 2.8-2.8l.1.1a1.7 1.7 0 0 0 1.8.3H9a1.7 1.7 0 0 0 1-1.5V3a2 2 0 1 1 4 0v.1a1.7 1.7 0 0 0 1 1.5 1.7 1.7 0 0 0 1.8-.3l.1-.1a2 2 0 1 1 2.8 2.8l-.1.1a1.7 1.7 0 0 0-.3 1.8V9a1.7 1.7 0 0 0 1.5 1H21a2 2 0 1 1 0 4h-.1a1.7 1.7 0 0 0-1.5 1z\"/>",
 	help: "<circle cx=\"12\" cy=\"12\" r=\"10\"/><path d=\"M9.1 9a3 3 0 0 1 5.8 1c0 2-3 3-3 3\"/><path d=\"M12 17h.01\"/>",
@@ -777,6 +794,12 @@ var WORKSPACE_PLACES = [
 		icon: "reviews",
 		label: "Reviews"
 	},
+	{
+		place: "runs",
+		href: "/runs",
+		icon: "runs",
+		label: "Runs"
+	},
 	{
 		place: "notifications",
 		href: "/notifications",
@@ -829,6 +852,7 @@ function renderGlobalBar(options) {
   ${live ? renderHeaderNav(options) : ""}
   ${live ? renderHistoryControls() : ""}
   ${live ? renderStripReviews(options) : ""}
+  ${live ? renderStripRuns(options) : ""}
   ${live ? renderNotificationsBell(options) : ""}
   ${live ? renderStripSettings(options) : ""}
   ${live ? renderStripRestart(options) : ""}
@@ -897,6 +921,10 @@ function renderHistoryControls() {
 function renderStripReviews(options) {
 	return `<a class="prb-strip-action" href="/"${options.current === "reviews" ? " aria-current=\"true\"" : ""} aria-label="Reviews" data-strip-reviews>${iconSvg("reviews")}</a>`;
 }
+/** Runs, beside Reviews, in the rail's order. Its own `aria-label`, for the reason Settings has one. */
+function renderStripRuns(options) {
+	return `<a class="prb-strip-action" href="/runs"${options.current === "runs" ? " aria-current=\"true\"" : ""} aria-label="Runs" data-strip-runs>${iconSvg("runs")}</a>`;
+}
 /**
 * Settings, as an icon, beside the bell.
 *
@@ -6059,7 +6087,7 @@ function showsProgress(view) {
 */
 function renderReviewBody(view, sections) {
 	const result = view.session.result;
-	return `<div class="prb-body"${result ? "" : ` data-ask="closed"`}${view.askWidth ? ` style="--ask-width: ${Math.round(view.askWidth)}px"` : ""}>
+	return `<div class="prb-body"${result ? view.reviewLayout?.ask ? ` data-ask="${view.reviewLayout.ask}"` : "" : ` data-ask="closed"`} data-review-layout="${escapeHtml$1(JSON.stringify(view.reviewLayout ?? {}))}"${view.askWidth ? ` style="--ask-width: ${Math.round(view.askWidth)}px"` : ""}>
   ${renderRail(view, sections, updating(view))}
   <main class="prb-doc">
     ${updating(view) ? renderUpdatingDoc(view) : renderReviewDoc(view, sections)}
@@ -6620,11 +6648,12 @@ function renderRail(view, sections, stale = false) {
 		current: true,
 		badge: null,
 		collapses: "the review",
-		body: `<button type="button" class="prb-rail-subhead" data-rail-toggle="the review path" aria-expanded="true" aria-controls="prb-rail-path" aria-label="Collapse the review path">
+		open: railFoldOpen(view, "prb-rail-review"),
+		body: `<button type="button" class="prb-rail-subhead" data-rail-toggle="the review path" ${foldAttributes(railFoldOpen(view, "prb-rail-path"), "the review path")} aria-controls="prb-rail-path">
       <span class="prb-rail-heading">Review path</span>
       <span class="prb-rail-twisty" aria-hidden="true">${TWISTY}</span>
     </button>
-    <div class="prb-rail-path" id="prb-rail-path">
+    <div class="prb-rail-path" id="prb-rail-path"${railFoldOpen(view, "prb-rail-path") ? "" : " hidden"}>
       ${themes || "<p class=\"prb-rail-heading\">No themes</p>"}
     </div>
     ${railLink("map", "diagrams", "Diagrams", diagramsBadge(diagramCount(view)), void 0, "diagram architecture")}
@@ -6664,6 +6693,7 @@ function renderRunningRail(view) {
 		current: true,
 		badge: null,
 		collapses: "the review",
+		open: railFoldOpen(view, "prb-rail-review"),
 		body: view.job && changeIsRead(view.job) ? railLink("files", "files", "Files", totalBadge(files, "files")) : ""
 	});
 }
@@ -6692,9 +6722,18 @@ function renderKissRail(view) {
 		current: view.session.result === null && !showsProgress(view),
 		badge: counts ? recommendationsBadge(counts) : null,
 		collapses: "the KISS review",
+		open: railFoldOpen(view, "prb-rail-kiss"),
 		body: counts ? railLink("kissrecs", "recommendations", "Recommendations", recommendationsBadge(counts)) : ""
 	});
 }
+/** Open unless the reviewer last left this fold shut, on this review or the one before. */
+function railFoldOpen(view, fold) {
+	return view.reviewLayout?.rail?.[fold] !== false;
+}
+/** A fold control's state and the name that says what pressing it does, as `setRailExpanded` writes them. */
+function foldAttributes(open, noun) {
+	return `aria-expanded="${open}" aria-label="${open ? "Collapse" : "Expand"} ${escapeHtml$1(noun)}"`;
+}
 /** The one chevron both twisties draw. Rotated by CSS off `aria-expanded`, never by markup. */
 var TWISTY = "<svg viewBox=\"0 0 12 12\" aria-hidden=\"true\" focusable=\"false\"><path d=\"M3 4.5 6 8l3-3.5\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>";
 /**
@@ -6709,6 +6748,7 @@ var TWISTY = "<svg viewBox=\"0 0 12 12\" aria-hidden=\"true\" focusable=\"false\
 * `hidden` container rather than a list the client repopulates.
 */
 function railGroup(group) {
+	const open = group.open !== false;
 	return `<div class="prb-rail-group">
     <div class="prb-rail-row">
       <a class="prb-rail-item prb-rail-group-title" href="${escapeHtml$1(hashForView(group.view))}" data-view-nav="${escapeHtml$1(group.view)}"${group.current ? " aria-current=\"true\"" : ""}>
@@ -6716,9 +6756,9 @@ function railGroup(group) {
         <span class="prb-rail-label"><span class="prb-rail-title">${escapeHtml$1(group.title)}</span></span>
         ${renderBadge(group.badge)}
       </a>
-      ${group.body.trim() === "" ? "" : `<button type="button" class="prb-rail-twisty" data-rail-toggle="${escapeHtml$1(group.collapses)}" aria-expanded="true" aria-controls="${escapeHtml$1(group.id)}" aria-label="Collapse ${escapeHtml$1(group.collapses)}">${TWISTY}</button>`}
+      ${group.body.trim() === "" ? "" : `<button type="button" class="prb-rail-twisty" data-rail-toggle="${escapeHtml$1(group.collapses)}" ${foldAttributes(open, group.collapses)} aria-controls="${escapeHtml$1(group.id)}">${TWISTY}</button>`}
     </div>
-    <div class="prb-rail-body" id="${escapeHtml$1(group.id)}">${group.body}</div>
+    <div class="prb-rail-body" id="${escapeHtml$1(group.id)}"${open || group.body.trim() === "" ? "" : " hidden"}>${group.body}</div>
   </div>`;
 }
 /**
@@ -9396,6 +9436,100 @@ 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,
+			...job.source ? { source: job.source } : {},
+			...job.env.agentId ? { agentId: job.env.agentId } : {}
+		});
+	}
+	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 +9546,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,13 +9562,13 @@ 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,
 		driving: view.driving
 	})}
-${renderContextBar("Reviews", ordered.length === 0 ? "" : renderControls(queue.length, authorOptions(ordered.map(({ latest }) => ({
+${renderContextBar("Reviews", ordered.length === 0 ? "" : renderControls$1(queue.length, authorOptions(ordered.map(({ latest }) => ({
 		handle: latest.authorHandle,
 		name: latest.authorName,
 		createdAt: latest.createdAt
@@ -9447,7 +9583,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$1(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>
@@ -9466,7 +9603,7 @@ ${renderWorkspaceRail({
 * per risk level would be four more controls for a question ("show me only the risky ones") that
 * sorting by recency already answers badly and that scanning answers well.
 */
-function renderControls(queued, authors, anyRequest) {
+function renderControls$1(queued, authors, anyRequest) {
 	return `<div class="prb-index-controls">
     <input type="search" class="prb-index-search" data-search placeholder="Search repo, branch, title, summary or file…" aria-label="Search reviews" spellcheck="false">
     ${renderAuthorFilter(authors)}
@@ -9551,10 +9688,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 +9699,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$1(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 +9836,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)}
@@ -9926,6 +10144,96 @@ function relativeTime(at, now) {
 	return `${days} day${days === 1 ? "" : "s"} ago`;
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/runs_sections.ts
+/**
+* The Runs page's two sections, as `LIST_SECTIONS` is the Reviews page's: what can be folded, what
+* its heading says, and its key for folding it from the keyboard (⌘K L and this key). Their own,
+* not the Reviews page's: In progress folded on one page is not a reason to fold it on the other.
+*
+* No DOM and no filesystem, so the page's script, the server and the command registry read one list.
+*/
+var RUNS_SECTIONS = ["in-progress", "recent"];
+var RUNS_SECTION_NAMES = {
+	"in-progress": {
+		title: "In progress",
+		key: "i"
+	},
+	recent: {
+		title: "Recent runs and issues",
+		key: "r"
+	}
+};
+function runsSectionOpen(section, collapsed) {
+	return !(collapsed?.[section] ?? false);
+}
+function isRunsSection(value) {
+	return typeof value === "string" && RUNS_SECTIONS.includes(value);
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/review_layout.ts
+/**
+* How the reviewer last laid out a review page, kept so the next review opens the same way.
+*
+* Three things, each the layout as it last stood rather than a log of what was pressed: whether
+* Buddy AI was open or closed, whether a surface was expanded (Buddy AI itself, or the document,
+* whichever pane that is on the next review), and which parts of the rail were folded. A field
+* nobody has changed has no key, so the page's own defaults still decide for a new reviewer.
+*
+* Pure, so the page and the server read it with the same rules. Stored in `ui.json`; see
+* `preferences.ts`.
+*/
+/** The rail's folds, by the id of the body each one hides. Every review renders the same ids. */
+var RAIL_FOLDS = [
+	"prb-rail-review",
+	"prb-rail-path",
+	"prb-rail-kiss"
+];
+function readRail(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const rail = {};
+	for (const fold of RAIL_FOLDS) {
+		const open = value[fold];
+		if (typeof open === "boolean") rail[fold] = open;
+	}
+	return Object.keys(rail).length > 0 ? rail : void 0;
+}
+/** A stored layout, keeping only what this page knows how to draw. Anything else reads as unset. */
+function readReviewLayout(value) {
+	if (!value || typeof value !== "object") return {};
+	const { ask, expanded, rail } = value;
+	const folds = readRail(rail);
+	return {
+		...ask === "open" || ask === "closed" ? { ask } : {},
+		...expanded === "buddy" || expanded === "document" ? { expanded } : {},
+		...folds ? { rail: folds } : {}
+	};
+}
+/** A patch from the page, or null when it holds nothing this page could have sent. */
+function readReviewLayoutPatch(value) {
+	if (!value || typeof value !== "object") return null;
+	const { ask, expanded, rail } = value;
+	const folds = readRail(rail);
+	const patch = {
+		...ask === "open" || ask === "closed" ? { ask } : {},
+		...expanded === "buddy" || expanded === "document" || expanded === null ? { expanded } : {},
+		...folds ? { rail: folds } : {}
+	};
+	return Object.keys(patch).length > 0 ? patch : null;
+}
+function applyReviewLayoutPatch(layout, patch) {
+	const { expanded: _old, ...rest } = layout;
+	const expanded = patch.expanded === void 0 ? layout.expanded : patch.expanded;
+	return {
+		...rest,
+		...patch.ask ? { ask: patch.ask } : {},
+		...expanded ? { expanded } : {},
+		...patch.rail ? { rail: {
+			...layout.rail,
+			...patch.rail
+		} } : {}
+	};
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/plain_page.ts
 function commandList(way) {
 	return `<ul class="prb-commands">${way.commands.map(({ command, where }) => `<li><code>${escapeHtml(command)}</code> in ${escapeHtml(where)}</li>`).join("")}</ul>`;
@@ -9991,14 +10299,16 @@ function readPreferences() {
 	try {
 		const parsed = JSON.parse(readFileSync(PREFERENCES_PATH, "utf8"));
 		if (!parsed || typeof parsed !== "object") return {};
-		const { askWidth, dismissedNotices, promptsCollapsed, changeMapRegister, theme, reviewSections } = parsed;
+		const { askWidth, dismissedNotices, promptsCollapsed, changeMapRegister, theme, reviewSections, runsSections, reviewLayout } = parsed;
 		return {
 			...typeof askWidth === "number" && Number.isFinite(askWidth) ? { askWidth: clampAskWidth(askWidth) } : {},
 			...Array.isArray(dismissedNotices) ? { dismissedNotices: dismissedNotices.filter((key) => typeof key === "string" && NOTICE_KEY.test(key)) } : {},
 			...typeof promptsCollapsed === "boolean" ? { promptsCollapsed } : {},
 			...changeMapRegister === "simple" || changeMapRegister === "technical" ? { changeMapRegister } : {},
 			...isTheme(theme) ? { theme } : {},
-			...readReviewSections(reviewSections)
+			...readReviewSections(reviewSections),
+			...readRunsSections(runsSections),
+			...readLayout(reviewLayout)
 		};
 	} catch {
 		return {};
@@ -10015,6 +10325,22 @@ function writeAskWidth(width) {
 		writeFileSync(PREFERENCES_PATH, `${JSON.stringify(next, null, 2)}\n`);
 	} catch {}
 }
+function readLayout(value) {
+	const layout = readReviewLayout(value);
+	return Object.keys(layout).length > 0 ? { reviewLayout: layout } : {};
+}
+/** Remember a change to the review page's layout. Read-modify-write, like every other field here. */
+function writeReviewLayout(patch) {
+	try {
+		mkdirSync(STORE_ROOT, { recursive: true });
+		const current = readPreferences();
+		const next = {
+			...current,
+			reviewLayout: applyReviewLayoutPatch(current.reviewLayout ?? {}, patch)
+		};
+		writeFileSync(PREFERENCES_PATH, `${JSON.stringify(next, null, 2)}\n`);
+	} catch {}
+}
 /** Remember whether "Your prompts" is folded. Read-modify-write, like every other field here. */
 function writePromptsCollapsed(collapsed) {
 	try {
@@ -10039,7 +10365,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;
 	}
@@ -10064,6 +10390,31 @@ function writeSectionCollapsed(section, collapsed) {
 		}, null, 2)}\n`);
 	} catch {}
 }
+/** As `readReviewSections`, for the Runs page. */
+function readRunsSections(value) {
+	if (!value || typeof value !== "object") return {};
+	const sections = {};
+	for (const section of RUNS_SECTIONS) {
+		const collapsed = value[section];
+		if (typeof collapsed === "boolean") sections[section] = collapsed;
+	}
+	return Object.keys(sections).length === 0 ? {} : { runsSections: sections };
+}
+/** As `writeSectionCollapsed`, for the Runs page's sections. */
+function writeRunsSectionCollapsed(section, collapsed) {
+	try {
+		const current = readPreferences();
+		mkdirSync(STORE_ROOT, { recursive: true });
+		const runsSections = {
+			...current.runsSections,
+			[section]: collapsed
+		};
+		writeFileSync(PREFERENCES_PATH, `${JSON.stringify({
+			...current,
+			runsSections
+		}, null, 2)}\n`);
+	} catch {}
+}
 /** Remember which palette the workspace is drawn in. Read-modify-write, like every other field here. */
 function writeTheme(theme) {
 	try {
@@ -10212,10 +10563,12 @@ ${renderWorkspaceRail({
 		unread: view.unreadNotifications ?? 0
 	})}
 <main class="prb-index prb-settings">
+  <div class="prb-page-panel">
   ${renderAppearanceSection(settings)}
   ${renderWorkspaceSection(settings, address)}
   ${renderReviewsSection(settings)}
   ${renderPrivacySection(settings)}
+  </div>
 
   <div class="prb-settings-actions">
     <button type="button" class="prb-dialog-primary" data-settings-save>Save changes</button>
@@ -10261,13 +10614,13 @@ function renderBack() {
 * The dialog it opens is rendered once on this page. See `renderShutdownDialog`.
 */
 function renderServerSection() {
-	return `<section class="prb-settings-section">
+	return `<div class="prb-page-panel"><section class="prb-settings-section">
     <h2>Server</h2>
     <button type="button" class="prb-settings-danger" data-shutdown>Stop server</button>
     <p class="prb-settings-help">Stops the local PR Review Buddy workspace. Nothing is deleted and
     every review keeps its address. Start it again with <code>prreviewbuddy open</code>, from any
     directory. Restarting instead needs no terminal: the button in the bar above does it.</p>
-  </section>`;
+  </section></div>`;
 }
 /**
 * The port, and the two answers to "which port" that a save creates.
@@ -10856,7 +11209,12 @@ feature:                   E</pre>
       days instead.</li>
       <li><b>Isolated checkouts</b> are removed six hours after their work finishes. See
       <a href="#isolated-checkouts">Isolated checkouts</a>.</li>
+      <li><b>Runs</b>, the record on the Runs page of what ran and how it ended, are kept for seven
+      days. Deleting a review keeps that record of its runs, with none of their output, until the
+      seven days are up.</li>
     </ul>
+    <p>Clearing up is done by the workspace server, when it starts and every ten minutes while it
+    runs. While it is stopped nothing is removed, though nothing past its time is ever shown.</p>
     <p><code>prreviewbuddy uninstall</code> removes all of it at once.</p>`
 	},
 	{
@@ -10902,11 +11260,13 @@ ${renderWorkspaceRail({
 		unread: view.unreadNotifications ?? 0
 	})}
 <main class="prb-index prb-help">
+  <div class="prb-page-panel">
   ${renderContents()}
   ${TOPICS.map((topic) => `<section class="prb-help-topic" id="${topic.id}">
     <h2>${escapeHtml$1(topic.title)}</h2>
     ${topic.body}
   </section>`).join("")}
+  </div>
   <p class="prb-help-version">PR Review Buddy v${escapeHtml$1(BUILD_VERSION)}</p>
 </main>
 </div>
@@ -11023,1316 +11383,2058 @@ 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])
-			});
-			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 } : {}
+}
+/** `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 states;
+	return entries;
 }
-/**
-* 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 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`);
+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));
 	}
-	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 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 } : {}
-		};
+	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 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;
+	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));
 }
-/** 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 } : {}
-		}
-	};
+/** 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());
 }
-//#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 folders a pull request could be reviewed in, the suggested one first.
 *
-* 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.
+* 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.
 */
-/** A stored review's card parts for one finding. */
-function gradeFragments(workspace, kind, id) {
-	return gradeFragments$1(workspace.session, kind, id);
+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;
 }
+//#endregion
+//#region ../../packages/review-harness/src/workspace/choose_folder.ts
 /**
-* 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.
+* Ask the person at this machine to pick a folder, with the operating system's own picker.
+*
+* The workspace is a page served by a local daemon, and a page cannot learn a folder's path from
+* the browser's directory picker, so the daemon asks instead. The operation is "choose a working
+* folder"; how a platform does it stays in this file, so neither the routes nor the page know.
+*
+* Only macOS has an implementation, through `osascript`. Elsewhere there is no chooser, and the
+* Add review panel falls back to the path field and the Recent list, which is all v1 needs.
 */
-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());
+/** Long enough for somebody to browse; short enough that a forgotten dialog does not hold a request for ever. */
+var CHOOSER_TIMEOUT_MS = 3e5;
+function folderChooser(platform = process.platform) {
+	if (platform !== "darwin") return null;
+	return () => new Promise((resolve, reject) => {
+		execFile("osascript", ["-e", "POSIX path of (choose folder with prompt \"Choose the working folder to review\")"], { timeout: CHOOSER_TIMEOUT_MS }, (error, stdout, stderr) => {
+			if (error) return /-128/.test(String(stderr)) ? resolve(null) : reject(/* @__PURE__ */ new Error("The folder picker could not be opened."));
+			resolve(stdout.trim().replace(/\/$/, "") || null);
+		});
 	});
-	if (!saved || !outcome) return {
-		status: 404,
-		body: { error: "No such review" }
+}
+function createSlots(capacity) {
+	let free = capacity;
+	const waiting = [];
+	const releaser = () => {
+		let given = false;
+		return () => {
+			if (given) return;
+			given = true;
+			const next = waiting.shift();
+			if (next) next(releaser());
+			else free += 1;
+		};
 	};
-	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 } : {}
+		acquire: () => {
+			if (free > 0) {
+				free -= 1;
+				return Promise.resolve(releaser());
+			}
+			return new Promise((resolve) => waiting.push(resolve));
+		},
+		tryAcquire: () => {
+			if (free === 0 || waiting.length > 0) return null;
+			free -= 1;
+			return releaser();
 		}
 	};
 }
-//#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."
-	];
+/** How many pull requests one submission may name. See `MAX_PULL_REQUESTS_PER_BATCH`. */
+var MAX_BATCH = 20;
+/**
+* How long a finished batch stays answerable once nobody is asking about it. An open panel keeps
+* asking (`KEEPALIVE` in the client is well inside this), so a batch is only forgotten after its
+* panel has gone, and its Retry with it.
+*/
+var FINISHED_BATCH_TTL_MS = 6e5;
+function realAddReviewDeps() {
+	return {
+		resolveAgent: (flag) => resolveAgent(flag ? { flag } : {}),
+		agents: async () => (await detectAgents()).map((agent) => {
+			const modelHelp = modelHelpOf(agent.id);
+			return {
+				id: agent.id,
+				displayName: agent.displayName,
+				installed: agent.state === "installed",
+				...modelHelp ? { modelHelp } : {}
+			};
+		}),
+		folders: () => discoverWorkingFolders(),
+		summaries: () => recentWorkspaces(Number.MAX_SAFE_INTEGER),
+		remoteOf: originRemote,
+		resolvePullRequest: (folder, url) => resolveTarget({
+			repoPath: folder,
+			prUrl: url,
+			resolveRequest: forgeResolver
+		}),
+		resolveBranch: (folder, base) => resolveTarget({
+			repoPath: folder,
+			...base ? { base } : {}
+		}),
+		defaultBase: async (root) => {
+			try {
+				const base = await resolveBase(root, void 0);
+				return (base.followRef ?? base.display).replace(/^refs\/(?:heads|remotes)\//, "");
+			} catch {
+				return null;
+			}
+		},
+		findExisting: findExistingReview,
+		prepare: (target, agentId, fresh, requestedModel) => prepareReview(target, agentId, fresh, requestedModel, "workspace"),
+		settle: (workspaceId) => settleReview(workspaceId, "standard", void 0, "workspace"),
+		observe: (workspaceId) => observeReview(workspaceId),
+		commitPresent: (root, sha) => refExists(root, sha),
+		track,
+		chooseFolder: folderChooser(),
+		concurrency: 2,
+		slots: createSlots(2),
+		resumeOf: (reviewId) => {
+			const failure = failureOf$1(reviewId);
+			return failure ? {
+				agent: agentNameOf(failure.agentId),
+				...failure.requestedModel ? { model: failure.requestedModel } : {}
+			} : null;
+		},
+		agentName: agentNameOf,
+		home: homedir()
+	};
+}
+function modelHelpOf(agentId) {
+	try {
+		return agentById(agentId).modelSelectionHelp;
+	} catch {
+		return;
+	}
+}
+function agentNameOf(agentId) {
+	try {
+		return agentById(agentId).displayName;
+	} catch {
+		return agentId;
+	}
+}
+var refuse = (status, error, extra = {}) => ({
+	status,
+	body: {
+		error,
+		...extra
+	}
+});
+function baseChoiceOf(error) {
+	const option = (where) => {
+		const matched = where === "remote" ? error.remote : error.local;
+		const commits = where === "remote" ? error.ranges?.remote : error.ranges?.local;
+		return {
+			base: shorthandOf(matched.ref),
+			display: where === "remote" ? shorthandOf(matched.ref) : shortNameOf(matched.ref),
+			where,
+			...commits ? { commits: commits.length } : {}
+		};
+	};
+	return {
+		name: shortNameOf(error.local.ref),
+		discovered: error.discovered,
+		...error.divergence ? { divergence: error.divergence } : {},
+		options: [option("remote"), option("local")]
+	};
+}
+/**
+* What the panel says for an error a review could not get past.
+*
+* Two errors are known by their class and said in the panel's own words. Anything else keeps its
+* message, which is already written for a person, but only its first paragraph is the sentence:
+* the rest (ref listings, commands to run) goes behind Technical details, kept whole for whoever
+* needs to diagnose it.
+*/
+function refusalOf(error) {
+	const text = message(error);
+	if (error instanceof AmbiguousRefError) {
+		const choice = baseChoiceOf(error);
+		return {
+			error: `\`${choice.name}\` is both a local and a remote branch, and they are different commits. Choose which one to compare against.`,
+			detail: text,
+			baseChoice: choice
+		};
+	}
+	if (error instanceof DetachedHeadError) return { error: "This folder is on a detached HEAD, so there is no branch to review. Check out a branch in it, or review its pull request instead." };
+	return briefly(text);
+}
+/** A message's first paragraph as the sentence, and the whole of it as the detail when there is more. */
+function briefly(text) {
+	const first = text.split(/\n\s*\n/)[0].trim();
+	return first && first !== text.trim() ? {
+		error: first,
+		detail: text
+	} : { error: text };
+}
+/** A path as a person reads it, with their home folder as `~`. */
+function displayPath(path, home) {
+	return home && (path === home || path.startsWith(`${home}/`)) ? `~${path.slice(home.length)}` : path;
+}
+/** 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 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
+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 } : {}
 		});
-		if (out.length === MAX_EVIDENCE) break;
+	});
+	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.
+*/
+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);
+}
+/**
+* A retry runs against the commit the row was first resolved to, never a newer one: a retry
+* resumes what was asked for, and a moved branch or pull request is a fresh review's business. When
+* that commit has gone (a force push, then a prune), there is nothing left to retry, and the row
+* says so and offers the fresh start instead of quietly reviewing something else.
+*/
+async function stillThere(row, target, what, deps) {
+	if (await deps.commitPresent(target.originRepoPath, target.sha)) return true;
+	row.status = "failed";
+	row.reason = `The commit this review was of (${target.sha.slice(0, 7)}) is no longer in this repository, so it can't be retried as it was. Start a fresh review to analyse the ${what} as it is now.`;
+	row.stale = true;
+	return false;
+}
+/**
+* Retry a row whose review exists, by that review's id. Not through the lookup a start uses, which
+* finds the latest review of the branch or request: one made since, of newer commits, would be
+* handed back in place of the one that failed, and a retry would quietly become a different review.
+*
+* Resumed when it is still a failure nothing is running, as its own page's Retry does. Otherwise
+* something has taken it up since (that Retry, a terminal), and it is watched rather than run again.
+*/
+async function retryReview(row, batch, deps) {
+	const reviewId = row.reviewId;
+	const kept = deps.resumeOf(reviewId);
+	begin(row);
+	if (kept) {
+		row.kept = kept;
+		return settleRow(row, deps.settle(reviewId));
 	}
-	return out;
+	follow(batch, settleRow(row, deps.observe(reviewId)), deps, false);
 }
 /**
-* 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.
+* A fresh start that ended before it made its review leaves the row exactly as it was: the old
+* target, the old review, and still `stale`. So the row keeps offering the fresh start, and a plain
+* Retry finds the old commit gone again, rather than resuming the old review against it.
 */
-function parseReassessAnswer(raw, kind, current) {
-	let parsed;
-	try {
-		parsed = JSON.parse(extractJsonText(raw, REASSESS_ANSWER));
-	} catch {
-		return null;
+function keepFreshPending(row, replaced) {
+	if (row.status === "failed" && !replaced) row.stale = true;
+}
+function keptOf(agentId, model, deps) {
+	return {
+		agent: deps.agentName(agentId),
+		...model ? { model } : {}
+	};
+}
+/**
+* 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
+		});
 	}
-	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
+	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();
+		}
 	};
-	if (obj.verdict !== "change") return null;
-	if (!isGradeFor(kind, obj.to) || obj.to === current) return null;
+	batch.rerun = (index, fresh) => follow(batch, lane(items[index], index, fresh), deps);
+	follow(batch, runBatch(items, {
+		concurrency: deps.concurrency,
+		run: lane
+	}), deps);
 	return {
-		verdict: "change",
-		to: obj.to,
-		reason,
-		evidence
+		status: 200,
+		body: {
+			batchId: batch.id,
+			rows: rowsOf(batch)
+		}
 	};
 }
-//#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.
+* 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.
 */
-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));
+function batchRows(id) {
+	const batch = batches.get(id);
+	if (!batch) return lostBatch();
+	batch.seenAt = Date.now();
 	return {
-		answer: {
-			...answer,
-			evidence
-		},
-		raw,
-		droppedEvidence: answer.evidence.length - evidence.length
+		status: 200,
+		body: {
+			rows: rowsOf(batch),
+			finished: batch.finishedAt !== null
+		}
 	};
 }
 /**
-* 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.
+* 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.
 */
-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
+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: {
+			rows: rowsOf(batch),
+			finished: false
 		}
-	}, 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.*`;
+/** The recent and discoverable folders, for the Branch panel's list. */
+async function listFolders(deps) {
+	return {
+		status: 200,
+		body: { folders: (await deps.folders()).map((folder) => ({
+			...folderOption(folder, deps.home),
+			repo: folder.remote ? folder.remote.repo : basename(folder.path)
+		})) }
+	};
 }
-//#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.
+* 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.
 *
-* Not a registry. If one is wanted later it replaces `discoverWorkingFolders` and keeps the shape.
+* 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.
 */
-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;
+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."
+		}
+	};
+	const named = typeof rawBase === "string" && rawBase.trim() ? rawBase.trim() : void 0;
+	let target;
 	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
-			});
-		});
+		target = await deps.resolveBranch(path, named);
+	} catch (error) {
+		return {
+			status: 200,
+			body: {
+				ok: false,
+				...refusalOf(error)
+			}
+		};
 	}
-	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;
+	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 } : {}
+			} } : {}
+		}
+	};
 }
-//#endregion
-//#region ../../packages/review-harness/src/workspace/choose_folder.ts
 /**
-* Ask the person at this machine to pick a folder, with the operating system's own picker.
+* Review the branch checked out in a folder: `prreviewbuddy` run there.
 *
-* The workspace is a page served by a local daemon, and a page cannot learn a folder's path from
-* the browser's directory picker, so the daemon asks instead. The operation is "choose a working
-* folder"; how a platform does it stays in this file, so neither the routes nor the page know.
+* 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.
 *
-* Only macOS has an implementation, through `osascript`. Elsewhere there is no chooser, and the
-* Add review panel falls back to the path field and the Recent list, which is all v1 needs.
+* 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.
 */
-/** Long enough for somebody to browse; short enough that a forgotten dialog does not hold a request for ever. */
-var CHOOSER_TIMEOUT_MS = 3e5;
-function folderChooser(platform = process.platform) {
-	if (platform !== "darwin") return null;
-	return () => new Promise((resolve, reject) => {
-		execFile("osascript", ["-e", "POSIX path of (choose folder with prompt \"Choose the working folder to review\")"], { timeout: CHOOSER_TIMEOUT_MS }, (error, stdout, stderr) => {
-			if (error) return /-128/.test(String(stderr)) ? resolve(null) : reject(/* @__PURE__ */ new Error("The folder picker could not be opened."));
-			resolve(stdout.trim().replace(/\/$/, "") || null);
-		});
-	});
-}
-function createSlots(capacity) {
-	let free = capacity;
-	const waiting = [];
-	const releaser = () => {
-		let given = false;
-		return () => {
-			if (given) return;
-			given = true;
-			const next = waiting.shift();
-			if (next) next(releaser());
-			else free += 1;
+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"
 	};
-	return {
-		acquire: () => {
-			if (free > 0) {
-				free -= 1;
-				return Promise.resolve(releaser());
+	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);
 			}
-			return new Promise((resolve) => waiting.push(resolve));
-		},
-		tryAcquire: () => {
-			if (free === 0 || waiting.length > 0) return null;
-			free -= 1;
-			return releaser();
+			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();
 		}
 	};
-}
-/** How many pull requests one submission may name. See `MAX_PULL_REQUESTS_PER_BATCH`. */
-var MAX_BATCH = 20;
-/**
-* How long a finished batch stays answerable once nobody is asking about it. An open panel keeps
-* asking (`KEEPALIVE` in the client is well inside this), so a batch is only forgotten after its
-* panel has gone, and its Retry with it.
-*/
-var FINISHED_BATCH_TTL_MS = 6e5;
-function realAddReviewDeps() {
-	return {
-		resolveAgent: (flag) => resolveAgent(flag ? { flag } : {}),
-		agents: async () => (await detectAgents()).map((agent) => {
-			const modelHelp = modelHelpOf(agent.id);
-			return {
-				id: agent.id,
-				displayName: agent.displayName,
-				installed: agent.state === "installed",
-				...modelHelp ? { modelHelp } : {}
-			};
-		}),
-		folders: () => discoverWorkingFolders(),
-		summaries: () => recentWorkspaces(Number.MAX_SAFE_INTEGER),
-		remoteOf: originRemote,
-		resolvePullRequest: (folder, url) => resolveTarget({
-			repoPath: folder,
-			prUrl: url,
-			resolveRequest: forgeResolver
-		}),
-		resolveBranch: (folder, base) => resolveTarget({
-			repoPath: folder,
-			...base ? { base } : {}
-		}),
-		defaultBase: async (root) => {
-			try {
-				const base = await resolveBase(root, void 0);
-				return (base.followRef ?? base.display).replace(/^refs\/(?:heads|remotes)\//, "");
-			} catch {
-				return null;
+	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");
 			}
-		},
-		findExisting: findExistingReview,
-		prepare: prepareReview,
-		settle: (workspaceId) => settleReview(workspaceId, "standard"),
-		observe: (workspaceId) => observeReview(workspaceId),
-		commitPresent: (root, sha) => refExists(root, sha),
-		track,
-		chooseFolder: folderChooser(),
-		concurrency: 2,
-		slots: createSlots(2),
-		resumeOf: (reviewId) => {
-			const failure = failureOf$1(reviewId);
-			return failure ? {
-				agent: agentNameOf(failure.agentId),
-				...failure.requestedModel ? { model: failure.requestedModel } : {}
-			} : null;
-		},
-		agentName: agentNameOf,
-		home: homedir()
-	};
-}
-function modelHelpOf(agentId) {
-	try {
-		return agentById(agentId).modelSelectionHelp;
-	} catch {
-		return;
+			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");
 	}
-}
-function agentNameOf(agentId) {
+	let prepared;
 	try {
-		return agentById(agentId).displayName;
-	} catch {
-		return agentId;
+		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);
 }
-var refuse = (status, error, extra = {}) => ({
-	status,
-	body: {
-		error,
-		...extra
-	}
-});
-function baseChoiceOf(error) {
-	const option = (where) => {
-		const matched = where === "remote" ? error.remote : error.local;
-		const commits = where === "remote" ? error.ranges?.remote : error.ranges?.local;
+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 {
-			base: shorthandOf(matched.ref),
-			display: where === "remote" ? shorthandOf(matched.ref) : shortNameOf(matched.ref),
-			where,
-			...commits ? { commits: commits.length } : {}
+			status: 200,
+			body: path ? { path } : { cancelled: true }
 		};
-	};
-	return {
-		name: shortNameOf(error.local.ref),
-		discovered: error.discovered,
-		...error.divergence ? { divergence: error.divergence } : {},
-		options: [option("remote"), option("local")]
-	};
+	} catch (error) {
+		return refuse(500, message(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.
-*/
-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
+//#endregion
+//#region ../../packages/review-harness/src/workspace/runs.ts
+function runKindOf(job) {
+	if (purposeOf(job) === "update") return "update";
+	if (job.reviewType === "kiss") return "kiss";
+	if (job.reanalysis) return "re-run";
+	return "review";
+}
+/** The filter an entry in progress belongs to. A waiting Add review row is a review waiting to start. */
+function operationRunKind(operation) {
+	if (operation.purpose === "update") return "update";
+	if (operation.lens === "kiss") return "kiss";
+	if (operation.kind === "re-running") return "re-run";
+	return "review";
+}
+/**
+* Everything the page lists, in the order it lists it.
+*
+* **Not responding** is a job in a working phase that no live driver holds and that has not moved
+* for a whole claim lease. The lease is the existing bound on how long a dead driver's claim keeps
+* counting as live, so by the time this says a job is not responding, the claim test had already
+* stopped calling it running; and a job between being made and being claimed, which is
+* milliseconds, is never caught by it. It is not counted as running, and not as failed: the sweep
+* decides that, half an hour after the job last moved, and the entry then reads Failed by itself.
+*
+* The history is ordered newest ending first, then by key, a total order, because it is hashed into
+* the page's revision and a tie left to the directory would reload the page for nothing.
+*/
+function deriveRuns(jobs, isLive, rows, now) {
+	const inProgress = deriveOperations(jobs, isLive, rows);
+	const recent = [];
+	for (const job of jobs) {
+		if (purposeOf(job) === "ask") continue;
+		const removed = new Set(job.removedFromRuns ?? []);
+		const driven = isLive(job);
+		const listed = (endedAt) => now - endedAt < RUN_RECORD_RETENTION_MS;
+		const earlier = job.previousAttempts ?? [];
+		const attempts = earlier.length + 1;
+		const shared = {
+			jobId: job.id,
+			reviewId: job.workspaceId,
+			kind: runKindOf(job),
+			attempts,
+			target: job.target,
+			...job.reviewDeleted ? { reviewDeleted: true } : {}
+		};
+		earlier.forEach((attempt, index) => {
+			if (!removed.has(attempt.attemptId) && listed(attempt.finishedAt)) recent.push({
+				...shared,
+				...fromAttempt(attempt),
+				attempt: index + 1,
+				removable: !driven
+			});
+		});
+		const key = attemptIdOf(job);
+		if (removed.has(key)) continue;
+		const current = {
+			...shared,
+			key,
+			attempt: attempts,
+			startedAt: job.startedAt,
+			...job.source ? { source: job.source } : {},
+			...job.env.agentId ? { agentId: job.env.agentId } : {}
 		};
+		if (isTerminal(job)) {
+			if (!listed(job.finishedAt ?? job.updatedAt)) continue;
+			recent.push({
+				removable: !driven,
+				...current,
+				status: job.phase === "done" ? "completed" : job.failure?.stopped ? "cancelled" : "failed",
+				endedAt: job.finishedAt ?? job.updatedAt,
+				...job.finishedAt !== void 0 ? { durationMs: job.finishedAt - job.startedAt } : {},
+				...job.phase === "failed" && job.failure && !job.failure.stopped ? { failure: {
+					message: job.failure.message,
+					...job.failure.kind ? { kind: job.failure.kind } : {}
+				} } : {},
+				...job.phase === "done" && purposeOf(job) === "update" && job.progress ? { outcome: job.progress } : {}
+			});
+		} else if (!driven && now - job.updatedAt >= 18e4 && listed(job.updatedAt)) recent.push({
+			...current,
+			status: "not-responding",
+			endedAt: job.updatedAt,
+			removable: false
+		});
 	}
-	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 };
+	recent.sort((a, b) => b.endedAt - a.endedAt || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+	return {
+		inProgress,
+		recent
+	};
 }
-/** 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;
+function fromAttempt(attempt) {
+	return {
+		key: attempt.attemptId,
+		status: attempt.phase === "done" ? "completed" : attempt.failure?.stopped ? "cancelled" : "failed",
+		startedAt: attempt.startedAt,
+		endedAt: attempt.finishedAt,
+		durationMs: attempt.finishedAt - attempt.startedAt,
+		...attempt.phase === "failed" && attempt.failure && !attempt.failure.stopped ? { failure: {
+			message: attempt.failure.message,
+			...attempt.failure.kind ? { kind: attempt.failure.kind } : {}
+		} } : {},
+		...attempt.source ? { source: attempt.source } : {},
+		...attempt.agentId ? { agentId: attempt.agentId } : {}
+	};
 }
-/** 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;
+/**
+* The three numbers above the lists. Failed counts every failed attempt the page can list, earlier
+* attempts included and removed ones not: the same population as the history, so the count and the
+* list cannot disagree. Not responding and cancelled are neither.
+*/
+function runCounts(runs) {
+	return {
+		running: runs.inProgress.filter((operation) => operation.kind !== "queued").length,
+		queued: runs.inProgress.filter((operation) => operation.kind === "queued").length,
+		failed: runs.recent.filter((entry) => entry.status === "failed").length
+	};
 }
-function message(error) {
-	return error instanceof Error ? error.message : String(error);
+/**
+* Has anything the Runs page draws changed. The page reloads when this differs from the one it was
+* rendered with, as the Reviews page does with `reviewsRevision`.
+*
+* Built from what the entries say, never from a time or a progress line, so it moves when a run
+* starts, moves to its next step, ends, is removed, or loses its review, and never on a clock.
+* Elapsed times are the page's to repaint (`client/runs.ts`). Also from the last cleanup's
+* trouble, which the page shows beside the runs.
+*/
+function runsRevision(runs, cleanup) {
+	const hash = createHash("sha1");
+	if (cleanup && (cleanup.refusals.length > 0 || cleanup.error)) hash.update(`cleanup:${cleanup.at}:${cleanup.error ?? ""}:${cleanup.refusals.join("\0")}\n`);
+	const byKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+	for (const operation of [...runs.inProgress].sort(byKey)) hash.update(`op:${operation.key}:${operation.kind}:${operation.phase ?? ""}:${operation.reviewId ?? ""}\n`);
+	for (const entry of [...runs.recent].sort(byKey)) hash.update(`run:${entry.key}:${entry.status}:${entry.reviewDeleted ? "deleted" : ""}\n`);
+	return hash.digest("hex").slice(0, 16);
 }
-/** 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}`;
-	}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/live_operations.ts
+/**
+* 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.
+*/
+function liveOperations(now = Date.now(), jobs = allJobs(), rows = pendingBatchRows()) {
+	return deriveOperations(jobs, (job) => isClaimed(job.id, now), rows);
 }
 /**
-* 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.
+* Everything the Runs page lists, from one reading of the jobs directory: the same in-progress list
+* as `liveOperations`, with the week of finished runs beside it. The two scopes above apply here
+* unchanged.
 */
-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 liveRuns(now = Date.now(), jobs = allJobs(), rows = pendingBatchRows()) {
+	return deriveRuns(jobs, (job) => isClaimed(job.id, now), rows, now);
 }
-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;
+//#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.
+*/
+/**
+* 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.
+*
+* 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.
+*/
+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]);
+	}
+	/**
+	* 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;
 }
 /**
-* The tail of each target's queue of creations, by batch identity. In-process, like the fetch
-* queue in `target.ts`.
+* The token.
 *
-* `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.
+* 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.
 */
-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;
+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");
 }
-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
-		}
-	};
+//#endregion
+//#region ../../packages/review-harness/src/workspace/runs_page.ts
+/**
+* The most finished runs a page carries. The whole week goes to the browser, so a filter is
+* answered over everything kept rather than over the page that happens to be drawn; seven days of
+* runs is bounded by itself, and this bounds it again. Past it the page says it is showing the
+* newest of them, so a filter that finds nothing is never read as "nothing ran".
+*/
+var MAX_RUNS_SENT = 1e3;
+var RUN_KIND_LABELS = {
+	review: "Initial review",
+	update: "Update",
+	"re-run": "Re-run",
+	kiss: "KISS review"
+};
+var STATUS_LABELS = {
+	completed: "Completed",
+	failed: "Failed",
+	cancelled: "Cancelled",
+	"not-responding": "Not responding"
+};
+var SOURCE_LABELS = {
+	workspace: "Workspace",
+	cli: "CLI",
+	mcp: "MCP"
+};
+function renderRunsPage(view) {
+	const now = view.now ?? Date.now();
+	const { inProgress, recent } = view.runs;
+	const counts = runCounts(view.runs);
+	const shown = recent.slice(0, MAX_RUNS_SENT);
+	const nothing = inProgress.length === 0 && recent.length === 0;
+	const notResponding = recent.some((entry) => entry.status === "not-responding");
+	return `<!doctype html>
+<html lang="en"${themeAttribute(view.theme)}>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Runs · PR Review Buddy</title>
+<link rel="icon" type="image/png" href="/assets/icon128.png">
+<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())}"${view.revision === void 0 ? "" : ` data-runs-revision="${escapeHtml$1(view.revision)}"`} data-live="${inProgress.length > 0}">
+${renderGlobalBar({
+		current: "runs",
+		unread: view.unreadNotifications ?? 0,
+		driving: view.driving
+	})}
+${renderContextBar("Runs", nothing ? "" : renderControls(notResponding))}
+<div class="prb-shell">
+${renderWorkspaceRail({
+		current: "runs",
+		unread: view.unreadNotifications ?? 0
+	})}
+<main class="prb-index prb-runs">
+  <p class="prb-runs-lede">Monitor review executions and recent activity.</p>
+  ${renderSummary(counts)}
+  ${nothing ? `<p class="prb-index-empty" data-runs-empty>Nothing has run in the last seven days. Reviews, updates and re-runs appear here as soon as they start, whether from this workspace, a terminal or an MCP client.</p>` : `${renderInProgress(inProgress, view.reviews, now, runsSectionOpen("in-progress", view.sectionsCollapsed))}
+  ${renderRecent(shown, recent.length, view, now, runsSectionOpen("recent", view.sectionsCollapsed))}
+  <p class="prb-index-none" data-no-matches hidden>No runs match these filters. <button type="button" class="prb-index-clear" data-clear-filters-inline>Clear filters</button></p>`}
+  ${renderCleanup(view.cleanup, now)}
+  <p class="prb-index-note">Runs are kept for seven days, on this machine only. Older ones are never shown, and their records are deleted by the workspace server, which checks every ten minutes while it is running and once when it starts. Removing a run takes it off this page and changes nothing about its review.</p>
+</main>
+</div>
+<script src="/assets/runs.js" type="module"><\/script>
+</body>
+</html>`;
+}
+/**
+* A cleanup that could not finish, said where retention is said. Nothing when the last pass did
+* everything it set out to: a working sweep is not news. The first refusal is quoted, because it
+* names the directory and the reason, which is what a person needs to act on it.
+*/
+function renderCleanup(cleanup, now) {
+	if (!cleanup || cleanup.refusals.length === 0 && !cleanup.error) return "";
+	const when = relativeTime(cleanup.at, now);
+	const what = cleanup.error ? `The last cleanup, ${when}, stopped with an error: ${cleanup.error}` : `The last cleanup, ${when}, could not remove ${cleanup.refusals.length === 1 ? "one item" : `${cleanup.refusals.length} items`}. ${cleanup.refusals[0]}`;
+	return `<p class="prb-runs-scope" data-runs-cleanup role="status">${escapeHtml$1(`${what} It tries again every ten minutes while the workspace server is running.`)}</p>`;
 }
-function reviewedRow(reviewId, deps) {
-	const kept = deps.resumeOf(reviewId);
-	return {
-		reviewId,
-		...kept ? { kept } : {}
-	};
+/**
+* Three numbers, quietly. Running is work a live driver holds; Queued is this server's waiting Add
+* review requests; Failed is over the same week the history covers, and says so rather than reading
+* as a total for all time.
+*/
+function renderSummary(counts) {
+	const item = (name, label, value) => `<div class="prb-runs-count" data-runs-count="${name}"><dt>${escapeHtml$1(label)}</dt><dd>${value}</dd></div>`;
+	return `<dl class="prb-runs-summary">
+    ${item("running", "Running", counts.running)}
+    ${item("queued", "Queued", counts.queued)}
+    ${item("failed", "Failed · last 7 days", counts.failed)}
+  </dl>`;
 }
-function folderOption(folder, home) {
-	return {
-		path: folder.path,
-		display: displayPath(folder.path, home),
-		branch: folder.branch
-	};
+/**
+* Search and two filters, about execution only. The Reviews page's review-state filter is the
+* reviewer's own say on a review and means nothing about a run, so it is not here.
+*/
+function renderControls(notResponding) {
+	return `<div class="prb-index-controls">
+    <input type="search" class="prb-index-search" data-search placeholder="Search repo, pull request, branch or title…" aria-label="Search runs" spellcheck="false">
+    <label class="prb-index-status">Run status:
+      <select data-run-status-filter aria-label="Filter by run status">
+        <option value="all">All statuses</option>
+        <option value="in-progress">In progress</option>
+        <option value="completed">Completed</option>
+        <option value="failed">Failed</option>
+        <option value="cancelled">Cancelled</option>
+        ${notResponding ? "<option value=\"not-responding\">Not responding</option>" : ""}
+      </select>
+    </label>
+    <label class="prb-index-status">Run type:
+      <select data-run-kind-filter aria-label="Filter by run type">
+        <option value="all">All types</option>
+        ${Object.keys(RUN_KIND_LABELS).map((kind) => `<option value="${kind}">${escapeHtml$1(RUN_KIND_LABELS[kind])}</option>`).join("")}
+      </select>
+    </label>
+    <button type="button" class="prb-index-clear" data-clear-filters hidden><span aria-hidden="true">×</span> Clear filters</button>
+  </div>`;
 }
 /**
-* 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 is going on now, from the same list as the Reviews page's In progress section. The note is
+* the scope that list has on purpose: work that is running is seen machine-wide, while a request
+* still waiting for a slot is held by the server that accepted it and nowhere else.
+*/
+function renderInProgress(operations, reviews, now, open) {
+	return `<details class="prb-index-section prb-runs-section" data-runs-section="in-progress"${open ? " open" : ""}>
+    <summary class="prb-index-section-head">${RUNS_SECTION_NAMES["in-progress"].title} · <span data-section-count>${operations.length}</span></summary>
+    ${operations.length === 0 ? "<p class=\"prb-runs-idle\" data-runs-idle>Nothing is running.</p>" : ""}
+    <div class="prb-cards" data-run-list>
+      ${operations.map((operation) => renderOperationRun(operation, reviewOf(operation, reviews), now)).join("")}
+    </div>
+    <p class="prb-runs-scope">Queued shows the reviews added from this workspace. Pull requests waiting in a terminal batch appear once they start.</p>
+  </details>`;
+}
+/**
+* The week's finished runs, every one carried and the page shown by the browser: it filters first and
+* only then shows the newest matches a page at a time, so the run a filter is looking for is found
+* however far back it is. Without script every entry is shown, and Show older runs never appears.
+*/
+function renderRecent(shown, total, view, now, open) {
+	return `<details class="prb-index-section prb-runs-section" data-runs-section="recent"${open ? " open" : ""}>
+    <summary class="prb-index-section-head">${RUNS_SECTION_NAMES.recent.title} · Last 7 days · <span data-section-count>${shown.length}</span></summary>
+    ${shown.length === 0 ? "<p class=\"prb-runs-idle\">Nothing has finished in the last seven days.</p>" : ""}
+    <div class="prb-cards" data-run-list>
+      ${shown.map((entry) => renderRecentRun(entry, view.reviews.get(entry.reviewId), now)).join("")}
+    </div>
+    <p class="prb-runs-more" data-runs-more-row hidden><button type="button" class="prb-index-more" data-runs-more>Show older runs</button> <span data-runs-more-note></span></p>
+    ${total > shown.length ? `<p class="prb-runs-scope" data-runs-truncated>${escapeHtml$1(`This page carries the newest ${shown.length} of the ${total} runs kept from the last seven days; filters search those.`)}</p>` : ""}
+  </details>`;
+}
+/**
+* Whether this run's results have been replaced, answered by the review rather than by the clock.
 *
-* 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.
+* The review names the job whose analysis it presents, and the job behind its KISS result. A
+* completed run that is not that job no longer has its results on show: a re-run took them over.
+* Nothing else counts. An update changes an analysis in place and an update that found nothing
+* changes nothing, so neither replaces a run nor is replaced; a failure or a stop produced no
+* results to replace. An earlier attempt of a job is never labelled either, because the review
+* records jobs, not attempts, and so cannot say.
 */
-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
-		}
-	};
+function replaced(entry, review) {
+	if (!review || entry.status !== "completed" || entry.kind === "update" || entry.attempt !== entry.attempts) return false;
+	const presented = entry.kind === "kiss" ? review.presentedKissJobId : review.analysisJobId;
+	return presented !== void 0 && presented !== entry.jobId;
 }
-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 renderWhere(where) {
+	return `<p class="prb-card-where">
+        ${where.repo ? `<span class="prb-card-repo">${escapeHtml$1(where.repo)}</span>` : ""}
+        ${where.pr === void 0 ? "" : `<span class="prb-card-pr">#${where.pr}</span>`}
+        ${where.branch ? `<span class="prb-card-branch">${escapeHtml$1(where.branch)}</span>` : ""}
+      </p>`;
 }
-function newBatch(rows) {
-	forgetFinished(Date.now());
-	const now = Date.now();
-	const batch = {
-		id: randomUUID(),
-		rows,
-		finishedAt: now,
-		seenAt: now,
-		running: 0,
-		rerun: () => {}
+function searchOf(title, where) {
+	return [
+		title,
+		where.repo ?? "",
+		where.pr === void 0 ? "" : `#${where.pr} ${where.pr}`,
+		where.branch ?? ""
+	].join(" ").toLowerCase();
+}
+function reviewHref(review) {
+	return `/r/${encodeURIComponent(review.id)}?t=${encodeURIComponent(review.token)}`;
+}
+/** The agent's name, only where the record names one this build knows. */
+function agentName(agentId) {
+	return agentId && isAgentId(agentId) ? agentById(agentId).displayName : void 0;
+}
+/** Who asked and who ran it, each only when known. Two facts, never one guessed from the other. */
+function provenance(source, agentId) {
+	const parts = [source ? SOURCE_LABELS[source] : void 0, agentName(agentId)].filter((part) => part !== void 0);
+	return parts.length === 0 ? "" : `<span class="prb-run-provenance">${escapeHtml$1(parts.join(" · "))}</span>`;
+}
+/** A relative time the browser keeps current. `data-since` is what `client/runs.ts` repaints. */
+function since(prefix, at, now) {
+	return `<span class="prb-card-when"><time datetime="${new Date(at).toISOString()}" data-since="${at}" data-since-prefix="${escapeHtml$1(prefix)}">${escapeHtml$1(`${prefix} ${relativeTime(at, now)}`)}</time></span>`;
+}
+/**
+* Work going on now. A link to its review where there is one, whose page shows the steps and holds
+* the Cancel; a request still waiting for its slot has no review yet and is not a link.
+*/
+function renderOperationRun(operation, review, now) {
+	const row = operation.row;
+	const own = operation.reviewId !== void 0 && review?.id === operation.reviewId ? review : void 0;
+	const where = {
+		repo: review ? lastSegment(review.repoPath) : row?.repoPath ? lastSegment(row.repoPath) : void 0,
+		pr: review?.prNumber ?? row?.prNumber,
+		branch: review ? followedRefName(review.branch, review.headResolvedRef) ?? review.branch : row?.branch
 	};
-	batches.set(batch.id, batch);
-	return batch;
+	const title = own?.title || review?.title || row?.label || "Review";
+	const queued = operation.kind === "queued";
+	const kind = operationRunKind(operation);
+	const body = `<div class="prb-card-head"><h3>${escapeHtml$1(title)}</h3></div>
+      ${renderWhere(where)}
+      <p class="prb-card-meta">
+        <span class="prb-card-analysis" data-analysis="${queued ? "queued" : "running"}" role="status"><i aria-hidden="true"></i><span class="prb-visually-hidden">${queued ? "" : "Running: "}</span>${escapeHtml$1(queued ? "Queued · Waiting for an analysis slot" : operationLine(operation))}</span>
+        ${!queued && kind === "review" ? `<span>${escapeHtml$1(RUN_KIND_LABELS[kind])}</span>` : ""}
+        ${queued ? "<span class=\"prb-run-provenance\">Workspace</span>" : provenance(operation.source, operation.agentId)}
+        ${operation.startedAt ? since("Started", operation.startedAt, now) : ""}
+      </p>`;
+	return `<article class="prb-card prb-run" data-run data-run-status="in-progress" data-run-kind="${kind}" data-key="${escapeHtml$1(operation.key)}" data-search-text="${escapeHtml$1(searchOf(title, where))}">
+    ${own ? `<a class="prb-card-link" href="${escapeHtml$1(reviewHref(own))}">${body}</a>` : `<div class="prb-card-link">${body}</div>`}
+  </article>`;
 }
 /**
-* 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.
+* A run that has ended, or stopped answering.
+*
+* The whole entry opens its review, as a Reviews card does, and opens it as it is now. That is not
+* always what this run produced, so where the review says another run's results are the ones it
+* now presents, the entry says so in words; where nothing says, it says nothing. A run whose review
+* was deleted, or is no longer kept, says that instead and links nowhere.
+*
+* Remove, in the card's menu, only on an ended run: work running or waiting is not history yet, and
+* one not responding may still be. It hides the entry and nothing else; the server refuses anything
+* else.
 */
-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 renderRecentRun(entry, stored, now) {
+	const review = entry.reviewDeleted ? void 0 : stored;
+	const request = entry.target.pullRequest;
+	const where = {
+		repo: review ? lastSegment(review.repoPath) : request?.source ? `${request.source.repo.owner}/${request.source.repo.repo}` : lastSegment(entry.target.originRepoPath),
+		pr: review?.prNumber ?? request?.number,
+		branch: review ? followedRefName(review.branch, review.headResolvedRef) ?? review.branch : request?.headRef ?? entry.target.branch
+	};
+	const live = review;
+	const title = live?.title || (where.pr !== void 0 ? `${where.repo ?? "Pull request"} #${where.pr}` : where.branch || "Review");
+	const ended = entry.status !== "not-responding";
+	const detail = entry.status === "not-responding" ? "Nothing has heard from it for a while, so whatever was running it has probably stopped. It is marked Failed half an hour after it last moved." : entry.failure?.message ? entry.failure.message : entry.outcome ? entry.outcome : replaced(entry, live) ? "The review now shows the results of a later run, not this one." : "";
+	const attempt = entry.attempts > 1 ? ` · attempt ${entry.attempt} of ${entry.attempts}` : "";
+	const body = `<div class="prb-card-head"><h3>${escapeHtml$1(title)}</h3></div>
+      ${renderWhere(where)}
+      <p class="prb-card-meta">
+        <span class="prb-run-status" data-run-mark="${entry.status}"><i aria-hidden="true"></i>${escapeHtml$1(STATUS_LABELS[entry.status])}</span>
+        <span>${escapeHtml$1(`${RUN_KIND_LABELS[entry.kind]}${attempt}`)}</span>
+        ${provenance(entry.source, entry.agentId)}
+        ${since(ended ? "Ended" : "Last heard from", entry.endedAt, now)}
+        ${ended && entry.durationMs !== void 0 ? `<span>${escapeHtml$1(`Took ${formatDuration(entry.durationMs)}`)}</span>` : ""}
+      </p>
+      ${detail ? `<p class="prb-run-detail">${escapeHtml$1(detail)}</p>` : ""}
+      ${live ? "" : `<p class="prb-run-gone">${entry.reviewDeleted ? "Review deleted" : "Review no longer kept"}</p>`}`;
+	return `<article class="prb-card prb-run" data-run data-run-status="${entry.status}" data-run-kind="${entry.kind}" data-key="${escapeHtml$1(entry.key)}" data-search-text="${escapeHtml$1(searchOf(title, where))}">
+    ${entry.removable ? renderRunMenu(entry.key) : ""}
+    ${live ? `<a class="prb-card-link" href="${escapeHtml$1(reviewHref(live))}">${body}</a>` : `<div class="prb-card-link">${body}</div>`}
+  </article>`;
 }
-function fail(row, error) {
-	const refusal = refusalOf(error);
-	row.status = "failed";
-	row.reason = refusal.error;
-	if (refusal.detail) row.detail = refusal.detail;
+/**
+* The card's `…` menu, built as the Reviews page's is so the shared menus open, close and key it.
+* Remove is its one item for now: a hide, not a deletion, so it asks nothing first.
+*/
+function renderRunMenu(key) {
+	return `<div class="prb-menu" data-menu>
+    <button type="button" class="prb-menu-trigger" data-menu-trigger aria-expanded="false" aria-haspopup="true" aria-label="Run actions">&#8943;</button>
+    <div class="prb-menu-panel" data-menu-panel hidden>
+      <div data-menu-items>
+        <button type="button" class="prb-menu-item" data-run-remove="${escapeHtml$1(key)}">Remove from Runs</button>
+      </div>
+    </div>
+  </div>`;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/run_removal.ts
+async function removeRun(attemptId, jobs = allJobs()) {
+	const holder = jobs.find((job) => attemptIdOf(job) === attemptId || job.previousAttempts?.some((attempt) => attempt.attemptId === attemptId));
+	if (!holder) return "not-found";
+	const outcome = await withReviewLock(holder.workspaceId, () => {
+		const job = loadJob(holder.id);
+		if (!job) return "not-found";
+		if (isClaimed(job.id)) return "not-ended";
+		const earlier = job.previousAttempts ?? [];
+		if (earlier.some((attempt) => attempt.attemptId === attemptId)) {
+			saveJob({
+				...job,
+				previousAttempts: earlier.filter((attempt) => attempt.attemptId !== attemptId)
+			});
+			return "removed";
+		}
+		if (attemptIdOf(job) !== attemptId) return "not-found";
+		if (!isTerminal(job)) return "not-ended";
+		const removed = job.removedFromRuns ?? [];
+		if (!removed.includes(attemptId)) saveJob({
+			...job,
+			removedFromRuns: [...removed, attemptId]
+		});
+		return "removed";
+	});
+	return isBusy(outcome) ? "busy" : outcome;
 }
-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.
+* How long a working job may go without anything changing before it is called stopped.
+*
+* This has to clear the longest a healthy job can legitimately sit silent, and that bound is
+* knowable rather than guessed. `updatedAt` moves when a phase changes and on every progress line
+* the agent streams; the phases that stream nothing are bounded by their own ceilings, and the
+* largest of those is the twenty minute analysis timeout. Thirty minutes is that bound with half
+* again on top, which is why it is not fifteen: a slow review on a large repository would be
+* declared dead while it was still working.
+*
+* The write is conditional on `updatedAt` not having moved since it was read, so a job that is
+* merely slow and then speaks up cannot be overwritten by a sweep that had already decided.
 */
+var ABANDONED_AFTER_MS = 18e5;
 /**
-* `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.
+* The reviewer-facing half of that. A job whose driver was killed did not fail: it stopped
+* updating, which the page had no way to tell from working. This is the sentence that makes the
+* difference visible, and marking the job failed is what puts Retry on the page.
 */
-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;
+var ABANDONED_MESSAGE = "Nothing has updated it for over half an hour, so whatever was making it is no longer running.";
+async function sweep(now = Date.now()) {
+	const report = {
+		abandoned: 0,
+		retired: 0,
+		checkoutsRemoved: 0,
+		orphansRemoved: 0,
+		refusals: []
+	};
+	const jobs = allJobs();
+	for (const job of jobs) {
+		if (!isTerminal(job)) {
+			if (markAbandoned(job, now)) report.abandoned += 1;
+			continue;
+		}
+		if (now - endedAt(job) >= 6048e5) {
+			if (await retire(job, report)) report.retired += 1;
+			continue;
+		}
+		await keepRecord(job, now, report);
+	}
+	await removeOrphans(jobs, report);
+	pruneJobResidue(now, ABANDONED_AFTER_MS);
+	pruneNotifications(now);
+	return report;
 }
 /**
-* 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.
+* Record that a job stopped, unless it has moved since this pass read it.
+*
+* The reload is the whole of the safety here. Between `allJobs` and this line a driver in another
+* process can have written a progress line, and saving a failure over that would take a review
+* that is being made and tell its reviewer it stopped.
 */
-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);
+function markAbandoned(job, now) {
+	if (now - job.updatedAt < 18e5) return false;
+	if (isClaimed(job.id, now)) return false;
+	const current = loadJob(job.id);
+	if (!current || current.updatedAt !== job.updatedAt) return false;
+	const abandoned = fail$1(current, ABANDONED_MESSAGE);
+	saveJob(abandoned);
+	announceJob(abandoned);
+	return true;
 }
-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);
+/**
+* A finished record within its week: the checkout goes after six hours, and each earlier attempt
+* goes when its own week is up. One conditional write for both.
+*
+* **Under the review's lock, from the first question to the last write.** A Retry claims its job
+* under that same lock (`runJob`), so holding it here means no retry can begin while the checkout is
+* being removed: one asked for meanwhile is refused as busy and can be asked again, rather than
+* starting in a directory this is deleting. The claim is asked again inside the lock, since one
+* taken just before it was is a retry already under way, whose checkout and record are its own.
+* A review the lock cannot be had for is left to the next pass.
+*
+* The checkout before the record, as `job_cleanup.ts` orders it: the record names the directory
+* until the directory is gone. A directory already gone names nothing, which is how a crash between
+* the two is recovered on the next pass instead of refused on every one.
+*/
+async function keepRecord(job, now, report) {
+	const attempts = job.previousAttempts ?? [];
+	const keptAttempts = attempts.filter((attempt) => now - attempt.finishedAt < RUN_RECORD_RETENTION_MS);
+	const checkoutDue = job.worktreePath !== void 0 && now - endedAt(job) >= 216e5;
+	if (!checkoutDue && keptAttempts.length === attempts.length) return;
+	await withReviewLock(job.workspaceId, async () => {
+		if (isClaimed(job.id, now)) return;
+		const before = loadJob(job.id);
+		if (!before || before.updatedAt !== job.updatedAt) return;
+		let releaseCheckout = false;
+		if (checkoutDue && job.worktreePath) {
+			if (existsSync(job.worktreePath)) {
+				const outcome = await removeWorktree({
+					originRepoPath: job.target.originRepoPath,
+					worktreePath: job.worktreePath
+				});
+				if (outcome.removed) releaseCheckout = true;
+				else report.refusals.push(outcome.message);
+			} else releaseCheckout = true;
+		}
+		if (!releaseCheckout && keptAttempts.length === attempts.length) return;
+		const current = loadJob(job.id);
+		if (!current || current.updatedAt !== job.updatedAt) return;
+		const { worktreePath: _removed, ...withoutCheckout } = current;
+		const next = releaseCheckout ? withoutCheckout : current;
+		const present = /* @__PURE__ */ new Set([attemptIdOf(next), ...keptAttempts.map((attempt) => attempt.attemptId)]);
+		saveJob({
+			...next,
+			...attempts.length > 0 ? { previousAttempts: keptAttempts } : {},
+			...next.removedFromRuns ? { removedFromRuns: next.removedFromRuns.filter((id) => present.has(id)) } : {}
+		});
+		if (releaseCheckout) report.checkoutsRemoved += 1;
+	});
+}
+/** A finished job, discarded on the shared sequence. See `job_cleanup.ts` for why it is an order. */
+async function retire(job, report) {
+	const outcome = await discardJob(job);
+	if (outcome.refusal) report.refusals.push(outcome.refusal);
+	return outcome.removed;
 }
 /**
-* 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.
+* Directories under the managed root that no job record names.
+*
+* A crash between creating a worktree and saving the record that points at it leaves exactly this.
+* The origin repository comes from the directory's own marker, because there is nothing else left
+* to ask, and that does make `removeWorktree`'s marker check tautological on this path. It is not
+* the guard here and was never meant to be: git is asked first and answers about a real repository,
+* and where git has disowned the path what remains is the managed root and `ORPHAN_MIN_AGE_MS`,
+* which is the ordering the removal guard has always had.
 */
-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;
+async function removeOrphans(jobs, report) {
+	const claimed = new Set(jobs.map((job) => job.worktreePath).filter((path) => !!path));
+	let names;
+	try {
+		names = readdirSync(MANAGED_ROOT);
+	} catch {
+		return;
+	}
+	for (const name of names) {
+		const path = join(MANAGED_ROOT, name);
+		if (claimed.has(path) || isWorktreeHeld(path)) continue;
+		try {
+			if (!statSync(path).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const marker = readMarker(path);
+		if (!marker) continue;
+		const outcome = await removeWorktree({
+			originRepoPath: marker.originRepoPath,
+			worktreePath: path
+		});
+		if (outcome.removed) report.orphansRemoved += 1;
+		else if (outcome.reason !== "too-young") report.refusals.push(outcome.message);
+	}
 }
 /**
-* 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.
+* How often the pass runs.
 *
-* 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.
+* Chosen from what it costs to be late rather than what it costs to run. A sweep is a directory
+* listing and a `git worktree list` per finished job, so ten minutes is nothing; being an hour
+* late telling a reviewer their review stopped is not. Ten minutes puts that answer between thirty
+* and forty minutes after the last sign of life.
 */
-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));
+var SWEEP_INTERVAL_MS = 6e5;
+/** Where the last pass says how it went. */
+var SWEEP_STATUS_PATH = join(STORE_ROOT, "sweep.json");
+/** One pass, with its outcome written down whatever it was. Never throws. */
+async function runSweep(now = Date.now()) {
+	let status;
+	try {
+		status = {
+			at: now,
+			refusals: (await sweep(now)).refusals
+		};
+	} catch (error) {
+		status = {
+			at: now,
+			refusals: [],
+			error: error instanceof Error ? error.message : String(error)
+		};
 	}
-	follow(batch, settleRow(row, deps.observe(reviewId)), deps, false);
-}
-/**
-* A fresh start that ended before it made its review leaves the row exactly as it was: the old
-* target, the old review, and still `stale`. So the row keeps offering the fresh start, and a plain
-* Retry finds the old commit gone again, rather than resuming the old review against it.
-*/
-function keepFreshPending(row, replaced) {
-	if (row.status === "failed" && !replaced) row.stale = true;
+	writeJsonAtomically(SWEEP_STATUS_PATH, status);
+	return status;
 }
-function keptOf(agentId, model, deps) {
-	return {
-		agent: deps.agentName(agentId),
-		...model ? { model } : {}
-	};
+function lastSweep() {
+	try {
+		const parsed = JSON.parse(readFileSync(SWEEP_STATUS_PATH, "utf8"));
+		if (typeof parsed.at !== "number" || !Array.isArray(parsed.refusals)) return null;
+		return {
+			at: parsed.at,
+			refusals: parsed.refusals.filter((line) => typeof line === "string"),
+			...typeof parsed.error === "string" ? { error: parsed.error } : {}
+		};
+	} catch {
+		return 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.
+* Run the pass on a timer, and return the stop.
 *
-* 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.
+* Once immediately, because a server that has just started is very often one that restarted after
+* whatever killed the last one, and the jobs that died with it are exactly what this finds.
+*
+* Nothing here throws outward. A sweep that fails is disk it did not reclaim, and the server it
+* runs inside is serving reviews, which matters more.
 */
-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
-		});
+function startSweeping() {
+	const run = () => {
+		runSweep();
+	};
+	run();
+	const timer = setInterval(run, SWEEP_INTERVAL_MS);
+	timer.unref();
+	return () => clearInterval(timer);
+}
+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
+		};
 	}
-	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();
-		}
+	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
 	};
-	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();
-	return {
-		status: 200,
-		body: {
-			rows: rowsOf(batch),
-			finished: batch.finishedAt !== null
-		}
+/** 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;
 }
-/**
-* Said without guessing why. A restart forgets every batch, and a batch nobody has asked about for
-* a while is forgotten too; the server cannot tell which happened, so it says what follows from
-* either.
-*/
-var lostBatch = () => refuse(404, "This batch is no longer on the workspace server, so it can’t be followed or retried here. Reviews that had started are in your reviews list. Any that were still queued did not start.");
-/**
-* Run one failed row of a batch again, as it was first asked for: the same folder, agent, model
-* and base, and the same commits, never the branch or pull request as it has since moved on. A
-* review that was created and then failed resumes, as a Retry does on its own page. `fresh` is the
-* one exception, sent only when those commits have gone: it looks again at what is there now.
-* The other rows are left exactly as they are, and the batch is followed again until it ends.
-*/
-function retryBatchRow(id, key, fresh = false) {
-	const batch = batches.get(id);
-	if (!batch) return lostBatch();
-	const index = batch.rows.findIndex((row) => row.key === key);
-	const row = batch.rows[index];
-	if (!row) return refuse(404, "That review is not part of this batch.");
-	if (row.status !== "failed") return refuse(409, "Only a review that failed can be tried again.");
-	row.status = "waiting";
-	delete row.reason;
-	delete row.detail;
-	delete row.stale;
-	batch.seenAt = Date.now();
-	batch.rerun(index, fresh === true);
+/** 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: false
+			error: REASSESSMENT_REFUSED[refusal],
+			refusal,
+			...card ? { card } : {}
 		}
 	};
 }
-/** The recent and discoverable folders, for the Branch panel's list. */
-async function listFolders(deps) {
-	return {
-		status: 200,
-		body: { folders: (await deps.folders()).map((folder) => ({
-			...folderOption(folder, deps.home),
-			repo: folder.remote ? folder.remote.repo : basename(folder.path)
-		})) }
-	};
-}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/reassessment_state.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 reviewer's grade moves and their answers to proposals, as `/state` receives them.
 *
-* 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.
+* 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.
 */
-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."
-		}
+/** 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 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;
+	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,
-			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 } : {}
-			} } : {}
+			entry: written.entry,
+			...card ? { card } : {}
 		}
 	};
 }
-/**
-* 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.
-*/
-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)
-		};
+//#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 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");
+	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;
 	}
-	let prepared;
+	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 {
-		prepared = await prepareRow(row, target, agent.agentId, model, deps);
-	} catch (error) {
-		release();
-		batches.delete(batch.id);
-		return {
-			status: 409,
-			body: refusalOf(error)
-		};
+		parsed = JSON.parse(extractJsonText(raw, REASSESS_ANSWER));
+	} catch {
+		return null;
 	}
-	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);
+	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
+	};
 }
-async function chooseFolder(deps) {
-	if (!deps.chooseFolder) return refuse(404, "Choosing a folder is not available on this system. Type its path instead.");
+//#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 {
-		const path = await deps.chooseFolder();
-		return {
-			status: 200,
-			body: path ? { path } : { cancelled: true }
-		};
-	} catch (error) {
-		return refuse(500, message(error));
+		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/ask.ts
@@ -13485,6 +14587,10 @@ async function handle(req, res, options) {
 	if (url.pathname === "/open") return handleOpen(req, res, url.searchParams, options.indexToken);
 	if (url.pathname === "/settings") return void handleSettings(req, res, url.searchParams, options.indexToken);
 	if (url.pathname === "/notifications") return void handleNotifications(req, res, url.searchParams, options.indexToken);
+	if (url.pathname === "/runs") return handleRuns(req, res, url.searchParams, options.indexToken);
+	if (url.pathname === "/runs/revision") return handleRunsRevision(req, res, options.indexToken);
+	if (url.pathname === "/runs/remove") return void handleRunRemoval(req, res, options.indexToken);
+	if (url.pathname === "/runs/sections") return void handleRunsSections(req, res, options.indexToken);
 	if (url.pathname === "/help") return void handleHelp(req, res, url.searchParams, options.indexToken);
 	if (url.pathname === "/notifications/open") return handleNotificationOpen(req, res, url.searchParams, options.indexToken);
 	if (url.pathname === "/notifications/recent") return handleRecentNotifications(req, res, url.searchParams, options.indexToken);
@@ -13592,6 +14698,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 +14710,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,
@@ -13831,6 +14939,55 @@ async function handleNotifications(req, res, params, indexToken) {
 	}), indexCookieHeader(indexToken));
 }
 /**
+* The Runs page. One reading of the jobs directory feeds both the markup and the revision it is
+* compared against, for the reason `handleIndex` reads once.
+*/
+function handleRuns(req, res, params, indexToken) {
+	if (!indexAuthorised(req, params, indexToken)) return refuseIndex(req, res);
+	const runs = liveRuns();
+	const cleanup = lastSweep();
+	const reviews = new Map(recentWorkspaces(Number.MAX_SAFE_INTEGER).map((review) => [review.id, review]));
+	const preferences = readPreferences();
+	sendHtml(res, 200, renderRunsPage({
+		runs,
+		reviews,
+		cleanup,
+		revision: runsRevision(runs, cleanup),
+		unreadNotifications: unreadCount$1(),
+		driving: isDriving(),
+		theme: preferences.theme,
+		sectionsCollapsed: preferences.runsSections
+	}), indexCookieHeader(indexToken));
+}
+/**
+* Has anything the Runs page draws changed, the last cleanup's trouble included, and is anything
+* in progress. `/revision`'s question, for
+* this page: `live` sets how often the page asks again, never whether it does, because a run started
+* from a terminal has to reach a page that was showing nothing.
+*/
+function handleRunsRevision(req, res, indexToken) {
+	if (!indexToken || !secretMatches(indexToken, indexCookie(req))) return send(res, 403, { error: "Not authorised." });
+	const runs = liveRuns();
+	send(res, 200, {
+		revision: runsRevision(runs, lastSweep()),
+		live: runs.inProgress.length > 0,
+		unread: unreadCount$1()
+	});
+}
+/** Removing one ended run from the Runs page. See `run_removal.ts` for what that does and does not touch. */
+async function handleRunRemoval(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);
+	const key = typeof body?.key === "string" ? body.key : null;
+	if (!key) return send(res, 400, { error: "Say which run to remove." });
+	const outcome = await removeRun(key);
+	if (outcome === "removed") return send(res, 200, { ok: true });
+	if (outcome === "not-found") return send(res, 404, { error: "That run is no longer listed." });
+	if (outcome === "busy") return send(res, 409, { error: "Its review is being changed. Try again in a moment." });
+	return send(res, 409, { error: "Only a run that has ended can be removed." });
+}
+/**
 * What an open Activity page polls while it is visible: how every row now stands, and, when it asks
 * for them by id, the rows it does not have yet.
 *
@@ -14099,9 +15256,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()
 	});
@@ -14202,11 +15360,20 @@ async function handlePin(req, res, indexToken) {
 * The index cookie, like `handlePin`: the list is the only page with these sections. One section
 * per request, merged into what is stored, so the page never sends a copy of the others.
 */
+/** The Runs page's folds, as `/sections` is the Reviews page's, with the same credential. */
+async function handleRunsSections(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 (!isRunsSection(body?.section) || typeof body?.collapsed !== "boolean") return send(res, 400, { error: "Not a section this page can fold." });
+	writeRunsSectionCollapsed(body.section, body.collapsed);
+	send(res, 200, { ok: true });
+}
 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 });
 }
@@ -14507,6 +15674,7 @@ async function sendWorkspacePage(res, workspace) {
 		theme: readPreferences().theme,
 		dismissedNotices: readPreferences().dismissedNotices,
 		promptsCollapsed: readPreferences().promptsCollapsed === true,
+		reviewLayout: readPreferences().reviewLayout ?? {},
 		changeMapRegister: readPreferences().changeMapRegister ?? "simple",
 		architecture: await architecturePane(workspace),
 		transcript: workspace.transcript,
@@ -14757,7 +15925,7 @@ async function handleUpdate(req, res, workspace) {
 	}
 	let outcome;
 	try {
-		outcome = await track(updateReview(workspace));
+		outcome = await track(updateReview(workspace, { source: "workspace" }));
 	} catch (error) {
 		if (error instanceof UpdateAlreadyRunningError) return send(res, 409, { error: error.message });
 		outcome = {
@@ -14814,7 +15982,7 @@ async function handleRetry(res, workspace) {
 	if (!workspace.jobId) return send(res, 404, { error: "No job for this review." });
 	const job = loadJob(workspace.jobId);
 	if (!job || !isTerminal(job) || isClaimed(job.id)) return send(res, 409, { error: "This review is still being made. Wait for it to finish before retrying." });
-	track(runJob(workspace.id)).catch(() => {});
+	track(runJob(workspace.id, {}, "standard", { source: "workspace" })).catch(() => {});
 	send(res, 200, { ok: true });
 }
 /**
@@ -14832,7 +16000,7 @@ async function handleReanalyse(req, res, workspace) {
 		const run = reanalyseReview(workspace.id, void 0, () => {
 			send(res, 200, { ok: true });
 			resolve();
-		});
+		}, void 0, "workspace");
 		track(run).catch((error) => {
 			if (!res.headersSent) send(res, 409, { error: error instanceof Error ? error.message : String(error) });
 			resolve();
@@ -14870,7 +16038,8 @@ async function handleKiss(req, res, workspace) {
 	if (current && current.status === "generating" && isClaimed(current.jobId)) return send(res, 409, { error: "A KISS review of this change is already running." });
 	startKissJob({
 		workspaceId: workspace.id,
-		audience
+		audience,
+		source: "workspace"
 	}).catch(() => {});
 	send(res, 200, { ok: true });
 }
@@ -15302,6 +16471,8 @@ async function handlePrefs(req, res) {
 	if (typeof askWidth === "number") writeAskWidth(askWidth);
 	else if (askWidth === null) clearAskWidth();
 	if (typeof body?.promptsCollapsed === "boolean") writePromptsCollapsed(body.promptsCollapsed);
+	const layout = readReviewLayoutPatch(body?.reviewLayout);
+	if (layout) writeReviewLayout(layout);
 	if (body?.changeMapRegister === "simple" || body?.changeMapRegister === "technical") writeChangeMapRegister(body.changeMapRegister);
 	if (typeof body?.dismissNotice === "string" && !dismissNotice(body.dismissNotice)) return send(res, 400, { error: "Not a notice this page can dismiss." });
 	send(res, 200, { ok: true });
@@ -15513,118 +16684,6 @@ function toEvent(body, reviewId) {
 		default: return null;
 	}
 }
-/**
-* The reviewer-facing half of that. A job whose driver was killed did not fail: it stopped
-* updating, which the page had no way to tell from working. This is the sentence that makes the
-* difference visible, and marking the job failed is what puts Retry on the page.
-*/
-var ABANDONED_MESSAGE = "Nothing has updated it for over half an hour, so whatever was making it is no longer running.";
-async function sweep(now = Date.now()) {
-	const report = {
-		abandoned: 0,
-		retired: 0,
-		orphansRemoved: 0,
-		refusals: []
-	};
-	const jobs = allJobs();
-	for (const job of jobs) {
-		if (!isTerminal(job)) {
-			if (markAbandoned(job, now)) report.abandoned += 1;
-			continue;
-		}
-		if (now - endedAt(job) < 216e5) continue;
-		if (await retire(job, report)) report.retired += 1;
-	}
-	await removeOrphans(jobs, report);
-	pruneNotifications(now);
-	return report;
-}
-/**
-* Record that a job stopped, unless it has moved since this pass read it.
-*
-* The reload is the whole of the safety here. Between `allJobs` and this line a driver in another
-* process can have written a progress line, and saving a failure over that would take a review
-* that is being made and tell its reviewer it stopped.
-*/
-function markAbandoned(job, now) {
-	if (now - job.updatedAt < 18e5) return false;
-	if (isClaimed(job.id, now)) return false;
-	const current = loadJob(job.id);
-	if (!current || current.updatedAt !== job.updatedAt) return false;
-	const abandoned = fail$1(current, ABANDONED_MESSAGE);
-	saveJob(abandoned);
-	announceJob(abandoned);
-	return true;
-}
-/** A finished job, discarded on the shared sequence. See `job_cleanup.ts` for why it is an order. */
-async function retire(job, report) {
-	const outcome = await discardJob(job);
-	if (outcome.refusal) report.refusals.push(outcome.refusal);
-	return outcome.removed;
-}
-/**
-* Directories under the managed root that no job record names.
-*
-* A crash between creating a worktree and saving the record that points at it leaves exactly this.
-* The origin repository comes from the directory's own marker, because there is nothing else left
-* to ask, and that does make `removeWorktree`'s marker check tautological on this path. It is not
-* the guard here and was never meant to be: git is asked first and answers about a real repository,
-* and where git has disowned the path what remains is the managed root and `ORPHAN_MIN_AGE_MS`,
-* which is the ordering the removal guard has always had.
-*/
-async function removeOrphans(jobs, report) {
-	const claimed = new Set(jobs.map((job) => job.worktreePath).filter((path) => !!path));
-	let names;
-	try {
-		names = readdirSync(MANAGED_ROOT);
-	} catch {
-		return;
-	}
-	for (const name of names) {
-		const path = join(MANAGED_ROOT, name);
-		if (claimed.has(path) || isWorktreeHeld(path)) continue;
-		try {
-			if (!statSync(path).isDirectory()) continue;
-		} catch {
-			continue;
-		}
-		const marker = readMarker(path);
-		if (!marker) continue;
-		const outcome = await removeWorktree({
-			originRepoPath: marker.originRepoPath,
-			worktreePath: path
-		});
-		if (outcome.removed) report.orphansRemoved += 1;
-		else if (outcome.reason !== "too-young") report.refusals.push(outcome.message);
-	}
-}
-/**
-* How often the pass runs.
-*
-* Chosen from what it costs to be late rather than what it costs to run. A sweep is a directory
-* listing and a `git worktree list` per finished job, so ten minutes is nothing; being an hour
-* late telling a reviewer their review stopped is not. Ten minutes puts that answer between thirty
-* and forty minutes after the last sign of life.
-*/
-var SWEEP_INTERVAL_MS = 6e5;
-/**
-* Run the pass on a timer, and return the stop.
-*
-* Once immediately, because a server that has just started is very often one that restarted after
-* whatever killed the last one, and the jobs that died with it are exactly what this finds.
-*
-* Nothing here throws outward. A sweep that fails is disk it did not reclaim, and the server it
-* runs inside is serving reviews, which matters more.
-*/
-function startSweeping() {
-	const run = () => {
-		sweep().catch(() => {});
-	};
-	run();
-	const timer = setInterval(run, SWEEP_INTERVAL_MS);
-	timer.unref();
-	return () => clearInterval(timer);
-}
 //#endregion
 //#region ../../packages/review-harness/src/cli/server.ts
 /**