prreviewbuddy 0.92.0 → 0.95.2

package/dist/server.js

@@ -1,9 +1,9 @@
-import { $a as runnableAgents, $i as explanationOf, $n as authorPreview, $r as kissDecisionsOf, $t as recordRuntimeBestEffort, A as settleQueue, Ai as createWithMembers, An as moveIds, Ar as attemptIdOf, At as UpdateAlreadyRunningError, B as humanizeModelId, Ba as agentIdOf, Bi as queueStamp, Bn as existingPaths, Br as phasesFor, C as parsePullRequestLink, Ca as objectWithAnyOf, Ci as lifecyclePillAction, Cn as createPrState, Cr as followedBranch, Ct as RefreshUnavailableError, D as activateQueued, Da as resolveTarget, Di as sectionOf$1, Dn as markAllRead, Dr as fillFileUrlTemplate, E as relativeTime$1, Ea as kissOutcome, Ei as parseLifecycle, En as listNotifications, Er as forgeResolver, Et as mergeUpdateInto, Fa as shorthandOf, Fi as setMembership, Fn as retireNotification, Fr as pruneJobResidue, Ft as prepareReview, G as reviewTag, Ga as STORE_ROOT, Gi as issuesOutstanding, Gn as storedConversation, Gr as isClaimed, Gt as recordTelemetryUploadConsent, H as findingRef, Ha as readAgentPreference, Hi as doneVerb, Hn as adoptLegacyBaseline, Hr as purposeOf, Ht as record, Ia as git, Ii as updateCollections, In as toneOf, Ir as saveJob, It as settleReview, Ja as agentFor$1, Ji as reviewerDispositions, Jn as isUnchanged, Jr as followedRefName, Jt as BUILD_VERSION, K as reviewTagsIn, Ka as AGENT_IDS, Ki as questionsOutstanding, Kn as unforeseenFailure, Kt as telemetryUploadConsent, L as modelProvenanceOf, La as refExists, Li as queueAdd, Ln as unreadAround, Lt as reanalyseReview, Ma as resolveBase, Mi as nameProblemText, Mn as readNotification, Mr as fail$1, Mt as runningJobs, N as cliEntry, Na as AmbiguousRefError, Ni as readCollections, Nn as readStateOf, Nr as isTerminal, Nt as failureOf$1, O as compactQueue, Oa as originRemote, Oi as collectionsStamp, On as markRead, Or as RUN_RECORD_RETENTION_MS, Ot as updateReview, Pa as shortNameOf, Pi as renameCollection, Pn as removeNotification, Pr as loadJob, Pt as observeReview, Q as markAskRunning, Qa as parkedReason, Qi as explanationActionOf, Qn as UNESTABLISHED_MOTIVATION, Qr as kissDecisionRefusal, Qt as mapRuntimes, R as provenanceDetailLines, Ra as resolveAgent, Ri as queueAddMany, Rn as unreadCount$1, Rr as isLiveJob, Rt as runJob, S as extractPullRequestLinks, Sa as extractJsonText, Si as lifecycleName$1, Sn as createArchitectureNotification, Sr as checkReview, St as FETCH_TIMEOUT_MS, T as runBatch, Ta as WITHHELD_REASON, Ti as offersLifecycle, Tn as eventName, Tr as fetchHead, Tt as cancellableHere, U as findingRefs, Ua as writeAgentPreference, Ui as isIssueOutstanding, Un as prepareConversationWithin, V as findingAtRef, Va as clearAgentPreference, Vi as readQueue, Vn as ASK_REREAD_CEILING_MS, Vr as progressSteps, Vt as readEvents, W as refOf, Wi as isQuestionOutstanding, Wn as saveRefresh, X as isRequestId, Xa as detectAgents, Xi as processDiscussion, Xn as EXPLAIN_SIMPLY_PROMPT, Xr as indexKeptIds, Xt as feedbackUrl, Ya as agentIdentityOf, Yi as verdictClosure, Yn as agentEnvOf, Yr as groupByLineage, Za as isAgentId, Zi as recommendationsOf, Zn as chatConversationSection, Zr as indexReviewGroups, Zt as waitingHistory, _ as endRun, _a as statusLookup, _i as activityAttributes, _n as writeJsonAtomically, _r as requestJobStop, _t as parseWorkspacePort, a as lineageIds, aa as assessmentLookup, ai as mutateWorkspace, an as loadArchitecture, ar as escapeHtml$1, b as stopRun, ba as SEVERITIES, bi as lifecycleChip, bn as subjectOf, br as findExistingReview, bt as writePortPreference, c as discardJob, ca as findingAssessment, ci as previousKissResult, cn as repositoryKey, cr as ReviewBeingDeletedError, ct as serverEntryExists, d as startKissJob, da as gradeScale, dn as trackedFiles, dr as MANAGED_ROOT, ea as isExplanationAction, ei as latestKissRun, en as RUNTIME_WORDS, eo as versionFrom, er as hasAuthorContent, f as isDriving, fa as isGradeFor, fi as summarise, fn as ownersOf, fr as createWorktree, g as completeRun, ga as sourcePhrase, gi as LIFECYCLES, gn as isArchitectureId, gr as removeWorktree, gt as MIN_WORKSPACE_PORT, h as beginRun, ha as reassessIn, hi as workspaceStamps, hn as ancestorsOf, hr as readMarker, ht as MAX_WORKSPACE_PORT, i as deleteReview, ia as analysisRefOf, in as checkArchitecture, ir as CODE_COPY_CLASS, ja as isCommitReview, ji as deleteCollection, jn as pruneNotifications, jr as endedAt, jt as liveUpdateFor, ka as DetachedHeadError, ki as createCollection, kn as markReadForReview, kr as allJobs, kt as askCheckout, l as kissAgentId, la as findingIn, li as recentWorkspaces, ln as storeArchitecture, lr as isBusy, lt as spawnServer, m as RUN_KINDS, ma as promptGrade, mi as workspaceRevision, mn as REPOSITORY_SCOPE, mr as isWorktreeHeld, mt as DEFAULT_WORKSPACE_PORT, n as MCP_TOOL_NAMES, na as ANALYSIS_ONLY, ni as lineagePosition, nn as formatDuration, no as AgentCancelledError, nr as renderMarkdown, o as liveJobsFor, oa as closesFinding, on as partFiles, or as renderInlineText, ot as readServerRecord, p as track, pa as isOffered, pi as touchWorkspace, pn as QUOTE_LIMITS, pr as holdWorktree, pt as writeServerRecord, q as endAskRequest, qa as agentById, qi as resolvedByConversation, qn as refreshPrContext, qr as decideKissRecommendation, r as deleteLineage, ra as NO_STATUS, ri as loadWorkspace, rn as ARCHITECTURE_DIR, ro as AgentUnavailableError, rr as CODE_BLOCK_CLASS, rt as clearServerRecordOwnedBy, s as wasBlocked, sa as currentGradeIn, si as presentedKissRunOf, sn as readArchitecture, ta as withExplanation, ti as lineageKey, tn as describeRuntimes, tr as GITHUB_MARKDOWN, tt as readIndexToken, ua as findingStatus, ui as reviewedCommit, un as storedScopes, ur as withReviewLock, ut as stopChild, v as heldRuns, va as wasReassessed, vi as activityLabel, vn as announceJob, vt as resolveWorkspacePort, w as unsupportedReason, wa as describeAuthorship, wi as lifecyclePillLabel, wn as createPrUpdate, wr as reviewedShaOf, wt as cancelUpdate, x as batchIdentity, xa as asString, xi as lifecycleItemLabel, xn as categoryOf, xr as checkCodeFreshness, y as reportRun, ya as followUpFindingId, yi as isLifecycle, yn as branchOf, yt as statedWorkspacePort, z as agentDisplayName, za as resolveModel, zi as queueRemove, zn as withUsageRecorded, zr as isTerminalJobPhase } from "./mcp_tools-BKPpd9dN.js";
-import { basename, delimiter, isAbsolute, join, relative, resolve } from "node:path";
-import { execFile, spawn } from "node:child_process";
+import { $ as statusPillLabel, $i as lifecycleItemLabel, $n as writeJsonAtomically, $r as findExistingReview, $t as statedWorkspacePort, A as anythingRunning, Aa as currentGradeIn, Ai as indexReviewGroups, An as BUILD_VERSION, Ao as deleteCollection, Ar as chatConversationSection, At as isRequestId, B as completedLabel, Ba as statusLookup, Bi as previousKissResult, Bn as checkArchitecture, Bt as readServerRecord, C as parsePullRequestLink, Ca as isExplanationAction, Cn as readEvents, Cr as ASK_REREAD_CEILING_MS, Ct as findingRefs, D as INDEX_SECTIONS, Da as analysisRefOf, Di as followedRefName, Dn as recordTelemetryUploadConsent, Do as collectionsStamp, Dr as isUnchanged, Dt as endAskRequest, E as relativeTime$1, Ea as NO_STATUS, Ei as decideKissRecommendation, Er as storedConversation, Et as reviewTagsIn, F as collectionFold, Fa as isGradeFor, Fi as loadWorkspace, Fn as recordRuntimeBestEffort, Fo as STORE_ROOT, Fr as renderMarkdown, Ft as readIndexToken, G as markItemLabel, Ga as extractJsonText, Gi as touchWorkspace, Gn as storeArchitecture, Gr as createWorktree, H as homeSection, Ha as followUpFindingId, Hi as reviewedCommit, Hn as partFiles, Hr as isBusy, Ht as serverEntryExists, Ia as isOffered, In as RUNTIME_WORDS, Ir as CODE_BLOCK_CLASS, J as queueItemLabel, Ja as WITHHELD_REASON, Ji as LIFECYCLES, Jn as ownersOf, Jr as readMarker, Jt as DEFAULT_WORKSPACE_PORT, K as omittedText, Ka as objectWithAnyOf, Ki as workspaceRevision, Kn as storedScopes, Kr as holdWorktree, L as collectionPlacement, La as promptGrade, Li as mutateWorkspace, Ln as describeRuntimes, Lr as CODE_COPY_CLASS, Lt as clearServerRecordOwnedBy, M as authorOptions, Ma as findingIn, Mi as kissDecisionsOf, Mn as feedbackUrl, Mo as readCollections, Mr as authorPreview, Mt as markAskRunning, N as collectionCountLabel, Na as findingStatus, Ni as latestKissRun, Nn as waitingHistory, No as renameCollection, Nr as hasAuthorContent, O as INDEX_SECTION_NAMES, Oa as assessmentLookup, Oi as groupByLineage, On as telemetryUploadConsent, Oo as createCollection, Or as agentEnvOf, P as collectionEmptyText, Pa as gradeScale, Pi as lineagePosition, Pn as mapRuntimes, Po as setMembership, Pr as GITHUB_MARKDOWN, Q as statusLabel, Qa as DetachedHeadError, Qi as lifecycleChip, Qn as isArchitectureId, Qt as resolveWorkspacePort, R as collectionsLine, Ra as reassessIn, Rn as formatDuration, Rr as escapeHtml$1, S as extractPullRequestLinks, Sa as explanationOf, So as versionFrom, Sr as existingPaths, St as findingRef, T as runBatch, Ta as ANALYSIS_ONLY, To as AgentUnavailableError, Tr as saveRefresh, Tt as reviewTag, U as isCollectionId, Ua as SEVERITIES, Un as readArchitecture, Ur as withReviewLock, Ut as spawnServer, V as countLabel, Va as wasReassessed, Vi as recentWorkspaces, Vn as loadArchitecture, Vr as ReviewBeingDeletedError, W as isFoldKey, Wa as asString, Wn as repositoryKey, Wr as MANAGED_ROOT, Wt as stopChild, X as sectionOpen, Xa as resolveTarget, Xi as activityLabel, Xn as REPOSITORY_SCOPE, Xr as requestJobStop, Xt as MIN_WORKSPACE_PORT, Y as queueOptionLabel, Ya as kissOutcome, Yi as activityAttributes, Yn as QUOTE_LIMITS, Yr as removeWorktree, Yt as MAX_WORKSPACE_PORT, Z as selectAllLabel, Za as originRemote, Zi as isLifecycle, Zn as ancestorsOf, Zt as parseWorkspacePort, _ as endRun, _a as reviewerDispositions, _i as isLiveJob, _n as prepareReview, _o as agentIdentityOf, _r as retireNotification, _t as modelProvenanceOf, a as lineageIds, aa as sectionOf$1, ai as forgeResolver, an as cancellableHere, ao as git, ar as createPrState, at as lineageKeysFor, b as stopRun, ba as recommendationsOf, bi as progressSteps, bn as runJob, bo as parkedReason, br as unreadCount$1, bt as humanizeModelId, c as discardJob, ca as queueRemove, ci as allJobs, cn as recheckConversation, co as resolveModel, cr as listNotifications, ct as compactQueue, d as startKissJob, da as doneVerb, di as fail$1, dn as findingsChanged, do as readAgentPreference, dr as markReadForReview, ea as lifecycleName, ei as checkCodeFreshness, en as writePortPreference, eo as isCommitReview, er as announceJob, et as deliver, f as isDriving, fa as isIssueOutstanding, fi as isTerminal, fn as UpdateAlreadyRunningError, fo as writeAgentPreference, fr as moveIds, g as completeRun, ga as resolvedByConversation, gn as observeReview, go as agentFor$1, gr as removeNotification, h as beginRun, ha as questionsOutstanding, hi as saveJob, hn as failureOf$1, ho as agentById, hr as readStateOf, i as deleteReview, ia as parseLifecycle, ii as fetchHead, in as cancelUpdate, io as shorthandOf, ir as createArchitectureNotification, it as retryableMiss, j as authorOptionLabel, ja as findingAssessment, ji as kissDecisionRefusal, jo as nameProblemText, jr as UNESTABLISHED_MOTIVATION, k as PR_FILTER_OPTIONS, ka as closesFinding, ki as indexKeptIds, ko as createWithMembers, kr as EXPLAIN_SIMPLY_PROMPT, l as kissAgentId, la as queueStamp, li as attemptIdOf, ln as updateReview, lo as agentIdOf, lr as markAllRead, m as RUN_KINDS, ma as issuesOutstanding, mi as pruneJobResidue, mn as runningJobs, mo as AGENT_IDS, mr as readNotification, n as MCP_TOOL_NAMES, na as lifecyclePillLabel, ni as followedBranch, nn as FETCH_TIMEOUT_MS, no as AmbiguousRefError, nr as subjectOf, o as liveJobsFor, oa as queueAdd, oi as fillFileUrlTemplate, on as mergeUpdateInto, oo as refExists, or as createPrUpdate, ot as settleCollections, p as track, pa as isQuestionOutstanding, pi as loadJob, pn as liveUpdateFor, pr as pruneNotifications, pt as cliEntry, q as pinItemLabel, qa as describeAuthorship, qi as workspaceStamps, qn as trackedFiles, qr as isWorktreeHeld, qt as writeServerRecord, r as deleteLineage, ra as offersLifecycle, ri as reviewedShaOf, rn as RefreshUnavailableError, ro as shortNameOf, rr as categoryOf, rt as openDestination, s as wasBlocked, sa as queueAddMany, si as RUN_RECORD_RETENTION_MS, so as resolveAgent, sr as eventName, st as activateQueued, ta as lifecyclePillAction, ti as checkReview, to as resolveBase, tr as branchOf, ua as readQueue, ui as endedAt, un as askCheckout, uo as clearAgentPreference, ur as markRead, ut as settleQueue, v as heldRuns, va as verdictClosure, vi as isTerminalJobPhase, vn as settleReview, vo as detectAgents, vr as toneOf, vt as provenanceDetailLines, w as unsupportedReason, wa as withExplanation, wi as isClaimed, wn as record, wo as AgentCancelledError, wr as prepareConversationWithin, wt as refOf, x as batchIdentity, xa as explanationActionOf, xi as purposeOf, xo as runnableAgents, xr as withUsageRecorded, xt as findingAtRef, y as reportRun, ya as processDiscussion, yi as phasesFor, yn as reanalyseReview, yo as isAgentId, yr as unreadAround, yt as agentDisplayName, z as completedFold, za as sourcePhrase, zi as presentedKissRunOf, zn as ARCHITECTURE_DIR, zr as renderInlineText } from "./mcp_tools-DDbcXys2.js";
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, delimiter, isAbsolute, join, relative, resolve } from "node:path";
 import { homedir } from "node:os";
-import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { execFile, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { createServer } from "node:http";
 //#region ../../packages/review-harness/src/domain/ai_review/review_composition.ts
@@ -477,317 +477,6 @@ function renderIntegrationsNotice(names) {
 </div>`;
 }
 //#endregion
-//#region ../../packages/review-harness/src/workspace/reviews_index.ts
-/**
-* The sections of the list, top to bottom.
-*
-* Pinned is not a lifecycle state. It is where a card is drawn, on top of a lifecycle it keeps: a
-* pinned review can be Active, Waiting or Done, and unpinning it puts it back in the section that
-* says. That is why it lives here, beside the other placement rules, and not in `LIFECYCLES`.
-*/
-var INDEX_SECTIONS = [
-	"pinned",
-	"active",
-	"waiting",
-	"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"
-	},
-	active: {
-		title: lifecycleName("active"),
-		key: "a"
-	},
-	waiting: {
-		title: lifecycleName("waiting"),
-		key: "w"
-	},
-	done: {
-		title: lifecycleName("done"),
-		key: "d"
-	}
-};
-/**
-* Whether a section starts open. The reviewer's choice wins, and otherwise everything is open but
-* the archives: Done, and each collection's completed reviews. A new collection starts open. The
-* one place that default is written.
-*/
-function sectionOpen(section, collapsed) {
-	return !(collapsed?.[section] ?? (section === "done" || section.startsWith("collection-done:")));
-}
-/** 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);
-}
-/** A fold the store accepts: a list section, or a collection's, by an id shaped like one. */
-function isFoldKey(value) {
-	if (isListSection(value)) return true;
-	if (typeof value !== "string") return false;
-	const match = /^collection(?:-done)?:(.*)$/.exec(value);
-	return match !== null && isCollectionId(match[1]);
-}
-function collectionFold(id) {
-	return `collection:${id}`;
-}
-function completedFold(id) {
-	return `collection-done:${id}`;
-}
-var COLLECTION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-/**
-* Whether a value is shaped like a collection's id. Here, in the module both halves share, because
-* the hash and the fold store check it in the browser and on the server alike.
-*/
-function isCollectionId(value) {
-	return typeof value === "string" && COLLECTION_ID.test(value);
-}
-/**
-* Which section a card is drawn in: Pinned when pinned, and otherwise where its lifecycle says.
-*
-* Pinning controls prominence in the general list and never overrides an ordering the reviewer
-* asked for. Under such a filter a pinned card stays in its lifecycle section, in the order the
-* filter gives, and only its star says it is pinned.
-*/
-function indexSectionOf(pinned, lifecycle, activity, filter) {
-	return pinned && !ordersExplicitly(filter) ? "pinned" : sectionOf$1(lifecycle, activity);
-}
-/**
-* Where a review's own card is drawn, or absent when it is drawn only inside its collections.
-*
-* Pinned first and exclusive, as it always was: a pinned review is drawn in Pinned and nowhere else,
-* collected or not, and unpinning it puts it back where the rest of these rules say. A review in a
-* collection is drawn there instead of in Active, Waiting or Done, so those three list what nobody
-* has grouped. Under the Queue filter neither applies: the list is the queue in its order, each card
-* in its lifecycle section, the same reason `indexSectionOf` gives for Pinned.
-*/
-function homeSection(pinned, lifecycle, activity, collected, filter) {
-	if (collected && !pinned && !ordersExplicitly(filter)) return void 0;
-	return indexSectionOf(pinned, lifecycle, activity, filter);
-}
-/**
-* Where a review is drawn inside each collection it belongs to: with the collection's reviews still
-* needing attention, under its completed reviews, or not at all.
-*
-* Completed means Done, by the same derivation that places the card everywhere else, so Waiting is
-* still in play and the Reviewed mark has nothing to do with it. One state for every collection the
-* review is in: marking it Done moves it in all of them at once. Not drawn while pinned (Pinned is
-* exclusive) or under the Queue filter (see `homeSection`).
-*/
-function collectionPlacement(pinned, lifecycle, activity, filter) {
-	if (pinned || ordersExplicitly(filter)) return void 0;
-	return sectionOf$1(lifecycle, activity) === "done" ? "completed" : "active";
-}
-/** A collection heading's count: what still needs attention, and the members drawn in Pinned. */
-function collectionCountLabel(active, pinned) {
-	const label = `${active} active`;
-	return pinned === 0 ? label : `${label} · ${pinned} pinned`;
-}
-/**
-* The quiet line on a card naming its collections, or absent when it would say nothing new.
-*
-* Inside a collection the heading already names that one, so the line says only where else the
-* review is ("Also in Release 0.82"), and nothing for a review in one collection. Outside every
-* collection heading, which is Pinned and the Queue filter, it names them all.
-*/
-function collectionsLine(memberOf, collections, current) {
-	const names = collections.filter((collection) => collection.id !== current && memberOf.includes(collection.id)).map((collection) => collection.name);
-	if (names.length === 0) return void 0;
-	return `${current === void 0 ? "In" : "Also in"} ${names.join(", ")}`;
-}
-/**
-* What a collection says when its main list is empty, or absent when it is not. A collection is
-* never hidden for having nothing active: it is still somewhere its finished reviews live, and
-* somewhere to put the next one.
-*/
-function collectionEmptyText(counts, filtered) {
-	if (counts.active > 0) return void 0;
-	if (filtered) return "Nothing in this collection matches the filters.";
-	if (counts.members === 0) return "Nothing here yet. Add reviews from a card’s menu, or select several and choose Manage collections.";
-	if (counts.pinned > 0 && counts.completed === 0) return "Its reviews are pinned, so they are listed under Pinned.";
-	return "No active reviews";
-}
-/** Said under a collection whose oldest members are not drawn, so it never looks smaller than it is. */
-function omittedText(omitted) {
-	return omitted === 1 ? "1 older review in this collection is not listed." : `${omitted} older reviews in this collection are not listed.`;
-}
-/** The disclosure holding a collection's Done reviews. */
-function completedLabel(completed) {
-	return `Show completed (${completed})`;
-}
-/**
-* Whether a filter replaces the activity order with one the reviewer set. Queue is the only one:
-* the list is the queue, in its order.
-* `orderIndex` and `indexSectionOf` both ask this, so the ordering and the placement cannot disagree.
-*/
-function ordersExplicitly(filter) {
-	return filter === "queue";
-}
-/**
-* "45 reviews · 13 branches", and "13 reviews" when those are the same thirteen things.
-*
-* The two numbers are different questions and only both worth asking once they differ. A page of
-* thirteen branches reviewed once each would read "13 reviews · 13 branches", which invites the
-* reader to work out what the distinction is on the one page where there isn't one.
-*
-* `of` is every review on the page, given while the search or a filter is narrowing the list:
-* "12 of 71 reviews" says the list is filtered and by how much, where "12 reviews" reads as all
-* there are.
-*/
-function countLabel(reviews, branches, of) {
-	const label = of === void 0 ? `${reviews} review${reviews === 1 ? "" : "s"}` : `${reviews} of ${of} review${of === 1 ? "" : "s"}`;
-	if (reviews === branches) return label;
-	return `${label} · ${branches} branch${branches === 1 ? "" : "es"}`;
-}
-/**
-* Every login the author dropdown offers, once each, in alphabetical order of what the reader sees:
-* the name where there is one, the login otherwise, regardless of case. Read from the cards the page
-* is showing, so it never lists somebody with nothing to show.
-*
-* A login's name is the one on its newest review that has a name, chosen here by `createdAt` rather
-* than by the order the caller happens to pass, so an account renamed upstream reads as it does now.
-*/
-function authorOptions(cards) {
-	const newest = /* @__PURE__ */ new Map();
-	for (const card of cards) {
-		if (!card.handle) continue;
-		const seen = newest.get(card.handle);
-		if (!seen) newest.set(card.handle, {
-			name: card.name || void 0,
-			createdAt: card.createdAt
-		});
-		else if (card.name && (!seen.name || card.createdAt > seen.createdAt)) newest.set(card.handle, {
-			name: card.name,
-			createdAt: card.createdAt
-		});
-	}
-	return [...newest].map(([handle, { name }]) => name && name !== handle ? {
-		handle,
-		name
-	} : { handle }).sort((a, b) => (a.name ?? a.handle).localeCompare(b.name ?? b.handle, void 0, { sensitivity: "base" }));
-}
-/** An author option as the dropdown spells it: the name and the login, or the login alone. */
-function authorOptionLabel(option) {
-	return option.name ? `${option.name} · @${option.handle}` : `@${option.handle}`;
-}
-/**
-* A card menu's status item, which sets the state it names. The bulk bar's words for the same two
-* actions, so a card and a selection never disagree. Here rather than in the page renderer because
-* the browser relabels the item after a change, and that renderer reaches the store.
-*/
-function markItemLabel(mark) {
-	return mark === "complete" ? "Mark reviewed" : "Mark not reviewed";
-}
-/**
-* The review page's Pin item, which says what pressing it will do. The words of the index's star,
-* so pinning from either place reads as the same act. Here because the browser relabels the item
-* after the change, for the reason `markItemLabel` is here.
-*/
-function pinItemLabel(pinned) {
-	return pinned ? "Unpin review" : "Pin review";
-}
-/**
-* The queue item, on a card and on the review's own page. "review queue" rather than "queue",
-* because a menu is where somebody meets the idea for the first time. Here because the browser
-* relabels it after a change, on both pages.
-*/
-function queueItemLabel(queued) {
-	return queued ? "Remove from review queue" : "Add to review queue";
-}
-/**
-* The Queue pill, which carries a number only once there is one.
-*
-* "Queue 0" is a count of something that is not there, and reads as a fault. Bare "Queue" reads as
-* the place it is -- empty, and still the thing you would click to put something in it.
-*/
-function queueOptionLabel(queued) {
-	return queued === 0 ? "Queue" : `Queue (${queued})`;
-}
-/**
-* The words on the status chip.
-*
-* Here rather than in the renderer because the browser now writes this chip too: marking a
-* selection reviewed repaints it without asking the server for the page again, and two copies of
-* these three words is how a page ends up saying "Reviewed" in one place and "Complete" in the
-* other about the same review.
-*/
-function statusLabel(status) {
-	if (status === "complete") return "Reviewed";
-	return status === "in-progress" ? "Not reviewed" : "New";
-}
-/**
-* The status pill's accessible name: where the reviewer is, then what pressing it does. The visible
-* words are the state, so a screen reader hears both rather than only a state it cannot act on.
-*/
-function statusPillLabel(status) {
-	return `${statusLabel(status)}. Mark as ${status === "complete" ? "not reviewed" : "reviewed"}`;
-}
-/**
-* The bulk bar's way to tick everything the filters show, across pages.
-*
-* Counted ("Select all 7") only while the headline is not already saying "of 7", so the number is
-* on the bar once. With PR set to Merged this is how a reviewer clears the merged reviews in one go,
-* by way of the existing Mark reviewed.
-*/
-function selectAllLabel(inView, scopeShown = false) {
-	return inView === 0 || scopeShown ? "Select all" : `Select all ${inView}`;
-}
-/** The PR filter's options, in order, as the select shows them. */
-var PR_FILTER_OPTIONS = [
-	{
-		value: "any",
-		label: "Any"
-	},
-	{
-		value: "open",
-		label: "Open"
-	},
-	{
-		value: "merged",
-		label: "Merged"
-	},
-	{
-		value: "closed",
-		label: "Closed"
-	}
-];
-/**
-* Whether any of that is work still going on, which is what sets the polling cadence.
-*
-* Here rather than beside `analysisStates` because this module is the DOM-free, filesystem-free
-* arithmetic both halves of the index share, and the renderer needs this one answer without
-* needing an import that reads the jobs directory to get it.
-*
-* A stopped analysis is a state, not an activity. Counting it as live would leave the index asking
-* once a second about a review that finished failing an hour ago, for as long as the tab stayed
-* open.
-*/
-function anythingRunning(states, operations = []) {
-	if (operations.length > 0) return true;
-	for (const state of states.values()) if (state.phase !== "failed") return true;
-	return false;
-}
-//#endregion
 //#region ../../packages/review-harness/src/workspace/fetch_updates_view.ts
 /** A card's and a review page's item. Named for what it reaches: a remote branch, not the list. */
 var FETCH_REVIEW_LABEL = "Fetch remote updates";
@@ -1033,7 +722,7 @@ function statusPillHtml(status, attributes = "") {
 */
 function lifecycleControlHtml(lifecycle, activity, options) {
 	const state = lifecycle?.state ?? "active";
-	const name = escapeHtml$1(lifecycleName$1(lifecycle));
+	const name = escapeHtml$1(lifecycleName(lifecycle));
 	const attributes = options.attributes ?? "";
 	if (!options.interactive) return `<span class="prb-state-pill prb-lifecycle-pill" data-lifecycle-pill="${state}"${attributes}>${name}</span>`;
 	const action = lifecyclePillAction(lifecycle);
@@ -5015,13 +4704,12 @@ ${renderDecisions(processed)}
 ${processed.all.length === 0 ? "<p class=\"prb-pr-empty\">This pull request has no comments yet.</p>" : buckets}`;
 }
 /**
-* Re-reading the threads, and what the last re-read found.
+* Re-checking the discussion, and what the last re-read found.
 *
-* The narrowest useful action in the product, and the copy has to keep it narrow. This corrects
-* what the review already claims about other people's threads — who raised one, whether it is
-* still open — and it cannot produce a finding, because deciding whether a new comment changes
-* anything is judgement and judgement is a fresh review. A reviewer who pressed this expecting a
-* re-review would be worse off than one who never saw the button.
+* Two things, said in the order they happen: the threads are fetched and every "already raised"
+* note corrected, then the findings are reassessed against whatever in the discussion is new to
+* them. The copy keeps it narrow in the one way that still matters: the code is the commit the
+* review read, so this is not a re-review and a comment claiming a fix cannot settle it here.
 */
 function renderRefresh(refresh) {
 	if (!refresh?.enabled) return "";
@@ -5029,10 +4717,12 @@ function renderRefresh(refresh) {
 	return `<div class="prb-pr-refresh">
   <button type="button" data-pr-recheck>Re-check the conversation</button>
   <span class="prb-pr-refresh-note">
-    Fetches every thread again and updates what this review says about them. If someone has
-    replied or resolved a thread since the review ran, the "Already raised" notes on the Issues
-    view will be corrected to match, and any note pointing at a thread that has been deleted will
-    be removed. Your code is not looked at again, so no findings are added, changed or removed.
+    Fetches the description and every thread again, corrects the "Already raised" notes, then
+    reassesses the issues and questions against anything new. A reply can answer a question,
+    resolve or reopen an issue, or suggest a different severity, and a concern it raises becomes a
+    new issue only once it is confirmed in the reviewed code. A comment saying something is fixed
+    is not taken on trust: the issue stays open until an update sees the fix in the code. Newer
+    commits are left for Update review.
   </span>
   ${last ? `<p class="prb-pr-refresh-last" data-ok="${last.ok}">
            Last re-checked ${escapeHtml$1(relativeTime$1(last.at))}. ${escapeHtml$1(last.message)}
@@ -6050,6 +5740,7 @@ function renderFreshAlternative(command) {
 */
 function renderUpdateOutcome(outcome) {
 	if (!outcome) return "";
+	if (outcome.scope === "conversation") return renderRecheckOutcome(outcome);
 	const state = outcome.ok ? "done" : outcome.stop === "refused" ? "refused" : outcome.stop === "cancelled" ? "cancelled" : "stopped";
 	const title = outcome.ok ? "Review updated" : outcome.stop === "refused" ? "There was nothing to update against" : outcome.stop === "cancelled" ? "Update cancelled" : "The review was not updated";
 	const facts = outcome.ok ? updateFacts(outcome) : null;
@@ -6062,6 +5753,72 @@ function renderUpdateOutcome(outcome) {
 </div>`;
 }
 /**
+* What a Re-check of the PR discussion did, in the same notice an update reports through.
+*
+* Five outcomes, each with its own headline, because the one the reviewer most needs to tell apart
+* is the partial: the discussion came in, so the "already raised" lines are current, but the
+* findings were not judged against it. That one says why and, when trying again could help, offers it.
+*/
+function renderRecheckOutcome(outcome) {
+	const retry = outcome.stop === "analysis-failed" && outcome.conversationOk === true;
+	const { state, title, body } = recheckWords(outcome);
+	const facts = outcome.ok && outcome.stop === null ? recheckFacts(outcome) : null;
+	return `<div class="prb-update-result" data-state="${state}" data-update-result data-recheck-result role="status">
+  <div class="prb-update-result-body">
+    ${facts ? `<p class="prb-update-facts"><strong>${escapeHtml$1(title)}</strong>${facts.map((fact) => `<span class="prb-update-fact">${escapeHtml$1(fact)}</span>`).join("")}</p>` : `<p><strong>${escapeHtml$1(title)}</strong> ${escapeHtml$1(body)}</p>`}
+    ${retry ? "<p class=\"prb-update-footnote\"><button type=\"button\" class=\"prb-fresh-quiet\" data-pr-recheck>Try again</button></p>" : ""}
+  </div>
+  <button type="button" class="prb-fresh-dismiss" data-update-close>Close</button>
+</div>`;
+}
+function recheckWords(outcome) {
+	if (outcome.stop === "cancelled") return {
+		state: "cancelled",
+		title: "Re-check cancelled",
+		body: "The findings and the discussion shown are exactly as they were."
+	};
+	if (outcome.conversationOk !== true) return {
+		state: "refused",
+		title: "The PR discussion was not re-checked",
+		body: outcome.message
+	};
+	if (outcome.stop === "already-current") return {
+		state: "done",
+		title: "No findings changed",
+		body: outcome.message
+	};
+	if (outcome.stop !== null) return {
+		state: "stopped",
+		title: "Discussion refreshed, findings not reassessed",
+		body: `The latest comments are in, and the notes about who raised what are current. ${outcome.message}`
+	};
+	if (outcome.counts && !findingsChanged(outcome.counts)) return {
+		state: "done",
+		title: "No findings changed",
+		body: "The new comments were read against every open issue and question, and each one stands as it was."
+	};
+	return {
+		state: "done",
+		title: "Findings reassessed against the PR discussion",
+		body: outcome.message
+	};
+}
+/** What a Re-check changed, largest news first, in the words an update uses. No commit: none moved. */
+function recheckFacts(outcome) {
+	const counts = outcome.counts;
+	if (!counts || !findingsChanged(counts)) return null;
+	const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+	return [
+		counts.questionsAnswered ? `${plural(counts.questionsAnswered, "question", "questions")} answered` : "",
+		counts.resolved ? `${plural(counts.resolved, "issue", "issues")} resolved by the discussion` : "",
+		counts.reopened ? `${plural(counts.reopened, "issue", "issues")} reopened` : "",
+		counts.affected ? `${counts.affected} to look at again` : "",
+		counts.newIssues ? plural(counts.newIssues, "new issue", "new issues") : "",
+		counts.gradeChanges ? `${plural(counts.gradeChanges, "grade change", "grade changes")} suggested` : "",
+		counts.decisionsChallenged ? `${plural(counts.decisionsChallenged, "accepted answer", "accepted answers")} put back to you` : ""
+	].filter(Boolean);
+}
+/**
 * A successful update as a row of facts: the commit it reached, then what changed, largest news first.
 *
 * Read at a glance rather than parsed. The sentence it replaces ("Updated to 7bc233f: 2 fixed,
@@ -6446,14 +6203,14 @@ function comparisonNote(code, hasPullRequest) {
 * button is the subject of the sentence now, so there is one name for one thing and the reviewer
 * presses the words they just read.
 *
-* Safe to run from here for the reason it always was: re-reading threads can only correct the
-* state of claims that already exist, never produce a finding.
+* It reads no new code: the findings are reassessed against the discussion at the reviewed commit,
+* and newer commits stay the Update button's.
 */
 function conversationNote(report, actions) {
 	if (!report.conversation.attached) return "";
 	const when = escapeHtml$1(relativeTime$1(report.conversation.importedAt));
 	if (!actions) return `The PR conversation was last checked ${when}.`;
-	return `<button type="button" class="prb-fresh-quiet" data-pr-recheck>Re-check the conversation</button> to refresh comments and resolved threads without re-running the code review. Last checked ${when}.`;
+	return `<button type="button" class="prb-fresh-quiet" data-pr-recheck>Re-check the conversation</button> to fetch new comments and reassess issues and questions against them, at the reviewed commit. Last checked ${when}.`;
 }
 //#endregion
 //#region ../../packages/review-harness/src/workspace/progress_view.ts
@@ -6551,7 +6308,7 @@ function renderProgressView(job, fileCount, cancellable = false, history) {
 * and can be carried on; an update has the previous review, which is why the two are worded apart.
 */
 function renderElapsed(job, cancel, history) {
-	const button = !cancel ? "" : cancel === "Cancel review" ? `<button type="button" class="prb-progress-cancel" data-review-cancel="${escapeHtml$1(job.id)}">Cancel review</button>` : `<button type="button" class="prb-progress-cancel" data-update-cancel="${escapeHtml$1(job.id)}">Cancel update</button>`;
+	const button = !cancel ? "" : cancel === "Cancel review" ? `<button type="button" class="prb-progress-cancel" data-review-cancel="${escapeHtml$1(job.id)}">Cancel review</button>` : `<button type="button" class="prb-progress-cancel" data-update-cancel="${escapeHtml$1(job.id)}">${cancel}</button>`;
 	return `<div class="prb-progress-foot">
     <div class="prb-progress-runtime">
       <p class="prb-progress-elapsed" data-started-at="${job.startedAt}">${escapeHtml$1(runningFor(job.startedAt))}</p>${renderHistory$1(history)}
@@ -6599,11 +6356,14 @@ function renderHistory$1(history) {
 */
 function renderUpdateProgress(job, cancellable = false, history) {
 	if (!isLiveJob(job)) return "";
-	return `<div class="prb-update-progress" data-update-phase="${escapeHtml$1(job.phase)}" role="status" aria-live="polite">
-  <h3 class="prb-doc-title"><span class="prb-spinner" aria-hidden="true"></span>Updating this review</h3>
-  <p class="prb-progress-lead">The previous review will be replaced when reassessment finishes.</p>
+	const recheck = job.scope === "conversation";
+	const title = recheck ? "Re-checking the PR discussion" : "Updating this review";
+	const lead = recheck ? "Issues and questions will be updated from the discussion when reassessment finishes." : "The previous review will be replaced when reassessment finishes.";
+	return `<div class="prb-update-progress" data-update-phase="${escapeHtml$1(job.phase)}"${recheck ? " data-update-scope=\"conversation\"" : ""} role="status" aria-live="polite">
+  <h3 class="prb-doc-title"><span class="prb-spinner" aria-hidden="true"></span>${title}</h3>
+  <p class="prb-progress-lead">${lead}</p>
   ${renderSteps(job)}
-  ${renderElapsed(job, cancellable ? "Cancel update" : null, history)}
+  ${renderElapsed(job, cancellable ? recheck ? "Cancel re-check" : "Cancel update" : null, history)}
 </div>`;
 }
 //#endregion
@@ -7009,7 +6769,7 @@ function renderAttributionAge(view) {
 	return `<div class="prb-discussion-age">
           <details class="prb-discussion-age-detail">
             <summary class="prb-discussion-age-summary">PR discussion checked ${escapeHtml$1(imported)}</summary>
-            <p class="prb-discussion-age-body">Any &ldquo;already raised&rdquo; note below, and whether each thread was still open, describes the pull request as it stood when its discussion was fetched. A reply or a resolved thread since then is not reflected here until the conversation is re-checked.</p>
+            <p class="prb-discussion-age-body">The issues and questions below, their &ldquo;already raised&rdquo; notes and whether each thread was still open describe the pull request as it stood when its discussion was fetched. A reply or a resolved thread since then is not reflected here until the conversation is re-checked, which also reassesses the issues and questions against it.</p>
           </details>
           <span class="prb-discussion-age-sep" aria-hidden="true">&middot;</span>
           <button type="button" class="prb-doc-note-link" data-view-nav="prcontext">Re-check in PR context</button>
@@ -10324,7 +10084,8 @@ function renderReviewsPage(view) {
 	const collectedHome = /* @__PURE__ */ new Set();
 	for (const group of ordered) {
 		const collected = (memberOf.get(group.key) ?? []).length > 0;
-		const home = homeSection(group.latest.pinned === true, group.latest.lifecycle, activityOf(group), collected, "all");
+		const pinned = group.latest.pinned === true;
+		const home = homeSection(pinned, group.latest.lifecycle, activityOf(group), collected, "all");
 		if (home === void 0) collectedHome.add(group);
 		sections[home ?? sectionOf$1(group.latest.lifecycle, activityOf(group))].push(group);
 	}
@@ -12746,8 +12507,15 @@ feature:                   E</pre>
     matters and what is needed, with the original question and its files under <b>Technical
     context</b>. Any answer so far stays on the card.</p>
     <p>When the review came with a pull request discussion, the line above the issues says when it
-    was last checked. Its “already raised” notes describe the discussion as it was then; <b>Re-check
-    in PR context</b> takes you to bring it up to date.</p>
+    was last checked. The issues, the questions and their “already raised” notes describe the
+    discussion as it was then; <b>Re-check in PR context</b> takes you to bring it up to date.</p>
+    <p>Re-checking fetches the latest comments and reassesses every issue and question against
+    anything new in them. A reply can answer a question, resolve or reopen an issue, or suggest a
+    different severity or importance, and a concern raised in a comment becomes a new issue once it
+    is confirmed in the reviewed code. A thread marked resolved, or a comment saying something is
+    fixed, does not resolve an issue on its own: it stays open until an Update sees the fix in the
+    code. Re-checking reads no new commits; Update review does. When the comments only change how
+    much one finding matters, <b>Reassess</b> on its card asks about that one alone.</p>
     <p>Resolved and dismissed issues are in the closed list at the bottom. One the new commits fixed
     leads with what the code now does, when the update could see it.</p>`
 	},
@@ -12760,7 +12528,7 @@ feature:                   E</pre>
       <li><b>Update</b> brings the review up to date with commits added since it was made. Its
       findings are checked against the new commits rather than thrown away, and each says whether
       the new commits affected it. In the workspace, Update review appears on a review whose
-      branch has moved on.</li>
+      branch has moved on. It also reads the pull request discussion, as Re-check does.</li>
       <li><b>Reanalyse</b> analyses the same commit again, for a fresh judgement of the same change,
       for example with a different model.</li>
       <li><b>Fresh review</b> reviews the target again as a new review, and keeps the existing one
@@ -12825,7 +12593,14 @@ feature:                   E</pre>
     a time unless <code>--concurrency</code> says otherwise.</p>
     <p>One that fails does not stop the others. Ctrl-C stops them all, and running the same command
     again carries each one on from where it got to. Add <code>--queue</code> to put each review on
-    your review queue as soon as it exists, rather than when it is ready.</p>`
+    your review queue as soon as it exists, rather than when it is ready.</p>
+    <p>To keep a batch together, add it to a collection: <code>--collection "Release review"</code>
+    for one you have, or <code>--new-collection "Friday batch"</code> to make one, with
+    <code>--also-queue</code> to put the reviews on your review queue as well. In New review, choose
+    the same from <b>Add to</b>: <b>Reviews list only</b>, <b>Review queue</b>, a collection, or
+    <b>Create collection…</b>, and tick <b>Also add to review queue</b> for both. When the batch
+    ends, <b>Open collection</b> shows it. A retry adds only what is missing, to the same
+    collection.</p>`
 	},
 	{
 		id: "review-lenses",
@@ -13118,50 +12893,6 @@ function renderNotificationRow(notification, gone) {
   </li>`;
 }
 //#endregion
-//#region ../../packages/review-harness/src/workspace/collections_live.ts
-/**
-* Collections as they relate to reviews that actually exist.
-*
-* `collections.ts` stores lineage keys and must not learn to read the review store, for the cycle
-* `queue_live.ts` describes: the prune in `store.ts` imports it. Anything that asks both questions
-* lives here, which imports both and is imported by neither.
-*/
-/**
-* Drop members whose lineage has no review any more, deleted elsewhere or pruned by age, and store
-* the result if that changed anything. Read against every group, not the windowed list, so a branch
-* the recency window happens to hide keeps its place.
-*
-* Compacted again under the lock rather than written from what was read, so a member somebody added
-* since is kept. On a failed write the compacted copy still stands in, so the page draws what exists.
-*/
-function settleCollections(groups) {
-	const live = new Set(groups.map((group) => group.key));
-	const compact = (collections) => collections.some((collection) => collection.members.some((key) => !live.has(key))) ? collections.map((collection) => ({
-		...collection,
-		members: collection.members.filter((key) => live.has(key))
-	})) : null;
-	const read = readCollections();
-	const compacted = compact(read);
-	if (compacted === null) return read;
-	return updateCollections((current) => compact(current)) ?? compacted;
-}
-/**
-* The lineage each review id belongs to, for the routes: the page sends the ids on its cards, and
-* the lineage is the server's to derive. An id with no review, or one that cannot be summarised, is
-* left out, and the caller says so.
-*/
-function lineageKeysFor(ids) {
-	const keys = /* @__PURE__ */ new Map();
-	for (const id of new Set(ids)) {
-		const workspace = loadWorkspace(id);
-		if (!workspace) continue;
-		try {
-			keys.set(id, lineageKey(summarise(workspace)));
-		} catch {}
-	}
-	return keys;
-}
-//#endregion
 //#region ../../packages/review-harness/src/workspace/working_folders.ts
 /**
 * The local Git working folders PR Review Buddy can find right now.
@@ -13370,7 +13101,13 @@ function realAddReviewDeps() {
 			} : null;
 		},
 		agentName: agentNameOf,
-		home: homedir()
+		home: homedir(),
+		collections: () => readCollections().map((collection) => ({
+			id: collection.id,
+			name: collection.name
+		})),
+		openDestination,
+		deliver
 	};
 }
 function modelHelpOf(agentId) {
@@ -13511,7 +13248,8 @@ async function addReviewOptions(deps) {
 				kind: "refused",
 				error: unresolvedAgent(resolution)
 			},
-			canChooseFolder: deps.chooseFolder !== null
+			canChooseFolder: deps.chooseFolder !== null,
+			collections: deps.collections()
 		}
 	};
 }
@@ -13625,12 +13363,13 @@ function pendingBatchRows() {
 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) {
+function newBatch(rows, destination = { queue: false }) {
 	forgetFinished(Date.now());
 	const now = Date.now();
 	const batch = {
 		id: randomUUID(),
 		rows,
+		destination,
 		finishedAt: now,
 		seenAt: now,
 		running: 0,
@@ -13657,7 +13396,14 @@ function fail(row, error) {
 	row.reason = refusal.error;
 	if (refusal.detail) row.detail = refusal.detail;
 }
-var rowsOf = (batch) => batch.rows.map((row) => ({ ...row }));
+var rowsOf = (batch) => batch.rows.map((row) => ({
+	...row,
+	...missToRetry(row, batch) ? { addAgain: true } : {}
+}));
+/** What of the batch's destination this row's review is still worth adding to, or null. */
+function missToRetry(row, batch) {
+	return row.reviewId && row.delivered ? retryableMiss(row.delivered, batch.destination) : null;
+}
 /**
 * 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.
@@ -13717,6 +13463,7 @@ async function stillThere(row, target, what, deps) {
 */
 async function retryReview(row, batch, deps) {
 	const reviewId = row.reviewId;
+	deliverRow(row, batch, deps);
 	const kept = deps.resumeOf(reviewId);
 	begin(row);
 	if (kept) {
@@ -13730,6 +13477,14 @@ async function retryReview(row, batch, deps) {
 * 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.
 */
+/**
+* Put a row's review where its batch goes, as soon as it has one. Idempotent, so it runs again on
+* every retry and fills in only what is missing. A batch for the reviews list alone does nothing.
+*/
+function deliverRow(row, batch, deps) {
+	if (!row.reviewId || !batch.destination.queue && !batch.destination.collection) return;
+	row.delivered = deps.deliver(row.reviewId, batch.destination);
+}
 function keepFreshPending(row, replaced) {
 	if (row.status === "failed" && !replaced) row.stale = true;
 }
@@ -13768,13 +13523,18 @@ async function startPullRequestBatch(body, deps) {
 	}
 	const model = modelOf(body?.model);
 	if (isAnswer(model)) return model;
+	const requested = destinationRequestOf(body?.destination);
+	if (isAnswer(requested)) return requested;
 	const agent = await agentFor(body?.agent, deps);
 	if (isAnswer(agent)) return agent;
+	const opened = deps.openDestination(requested);
+	if (!opened.ok) return destinationRefusal(opened, deps);
+	const destination = opened.destination;
 	const batch = newBatch(items.map((item) => ({
 		key: item.key,
 		label: `${item.owner}/${item.repo} #${item.number}`,
 		status: "waiting"
-	})));
+	})), destination);
 	batch.rows.forEach((row, index) => noteRow(row, {
 		repoPath: items[index].folder,
 		prNumber: items[index].number
@@ -13813,6 +13573,7 @@ async function startPullRequestBatch(body, deps) {
 			}
 			claimed.set(identity, index);
 			const prepared = await prepareRow(row, target, agent.agentId, model, deps, fresh);
+			deliverRow(row, batch, deps);
 			if (fresh) {
 				resolved[index] = target;
 				replaced = true;
@@ -13834,15 +13595,79 @@ async function startPullRequestBatch(body, deps) {
 		status: 200,
 		body: {
 			batchId: batch.id,
-			rows: rowsOf(batch)
+			rows: rowsOf(batch),
+			destination
 		}
 	};
 }
 /**
+* What the panel's Add to asked for. A collection it picked comes as an id and is matched as one,
+* never as a name; one it is to make comes as a name. Nothing, or the reviews list, is no
+* destination at all.
+*/
+function destinationRequestOf(raw) {
+	const choose = () => refuse(400, "Choose where the reviews go from Add to.", { field: "destination" });
+	if (raw === void 0 || raw === null) return { queue: false };
+	if (typeof raw !== "object") return choose();
+	const value = raw;
+	const queue = value.queue === true;
+	switch (value.kind) {
+		case "list": return { queue: false };
+		case "queue": return { queue: true };
+		case "collection": return typeof value.id === "string" && value.id !== "" ? {
+			collectionId: value.id,
+			queue
+		} : choose();
+		case "new-collection": return typeof value.name === "string" ? {
+			newCollection: value.name,
+			queue
+		} : choose();
+		default: return choose();
+	}
+}
+/** A destination that could not be opened, said beside Add to, with the collections as they are now. */
+function destinationRefusal(refusal, deps) {
+	const extra = {
+		field: "destination",
+		collections: deps.collections()
+	};
+	switch (refusal.reason) {
+		case "missing": return refuse(409, "That collection no longer exists. Choose again from Add to. Nothing was started.", extra);
+		case "empty":
+		case "too-long":
+		case "duplicate": return refuse(400, `${nameProblemText(refusal.reason)} Nothing was started.`, extra);
+		case "full": return refuse(409, `You have 100 collections, which is as many as there can be. Delete one, or add these to one you have. Nothing was started.`, extra);
+		default: return refuse(500, "The collection could not be saved. Nothing was started. Try again.", extra);
+	}
+}
+/**
+* The batch's destination as the panel shows it, under the collection's current name: a rename
+* keeps the id, so the batch still delivers to it, and the result should call it what it is now.
+*/
+function destinationNow(batch, deps) {
+	const collection = batch.destination.collection;
+	if (!collection || !deps) return batch.destination;
+	const current = deps.collections().find((one) => one.id === collection.id);
+	if (!current) return {
+		...batch.destination,
+		collection: {
+			...collection,
+			deleted: true
+		}
+	};
+	return current.name !== collection.name ? {
+		...batch.destination,
+		collection: {
+			...collection,
+			name: current.name
+		}
+	} : batch.destination;
+}
+/**
 * 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) {
+function batchRows(id, deps) {
 	const batch = batches.get(id);
 	if (!batch) return lostBatch();
 	batch.seenAt = Date.now();
@@ -13850,7 +13675,34 @@ function batchRows(id) {
 		status: 200,
 		body: {
 			rows: rowsOf(batch),
-			finished: batch.finishedAt !== null
+			finished: batch.finishedAt !== null,
+			destination: destinationNow(batch, deps)
+		}
+	};
+}
+/**
+* Put one row's review where the batch goes again, and nothing else: for a review that exists but
+* missed its collection or the queue (a full queue, a write that failed). The review is not run
+* again. A row with no review yet is Retry's business, which delivers once the review exists.
+*/
+function deliverBatchRow(id, key, deps) {
+	const batch = batches.get(id);
+	if (!batch) return lostBatch();
+	const row = batch.rows.find((one) => one.key === key);
+	if (!row) return refuse(404, "That review is not part of this batch.");
+	const again = missToRetry(row, batch);
+	if (!again || !row.reviewId) return refuse(409, "Only a review that missed somewhere it can still be added can be added again.");
+	row.delivered = {
+		...row.delivered,
+		...deps.deliver(row.reviewId, again)
+	};
+	batch.seenAt = Date.now();
+	return {
+		status: 200,
+		body: {
+			rows: rowsOf(batch),
+			finished: batch.finishedAt !== null,
+			destination: destinationNow(batch, deps)
 		}
 	};
 }
@@ -17867,7 +17719,7 @@ async function handleAddReview(req, res, pathname, options) {
 			if (route === "options") return addReviewOptions(deps);
 			if (route === "folders") return listFolders(deps);
 			const batch = /^batches\/([0-9a-f-]{36})$/.exec(route);
-			if (batch) return batchRows(batch[1]);
+			if (batch) return batchRows(batch[1], deps);
 			return null;
 		}
 		if (req.method !== "POST") return {
@@ -17882,6 +17734,8 @@ async function handleAddReview(req, res, pathname, options) {
 		if (route === "branch") return startBranchReview(body, deps);
 		const retry = /^batches\/([0-9a-f-]{36})\/retry$/.exec(route);
 		if (retry) return retryBatchRow(retry[1], body?.key, body?.fresh);
+		const again = /^batches\/([0-9a-f-]{36})\/deliver$/.exec(route);
+		if (again) return deliverBatchRow(again[1], body?.key, deps);
 		return null;
 	};
 	const result = await answer();
@@ -18336,10 +18190,15 @@ async function sendWorkspacePage(res, workspace) {
 	const updateJob = liveUpdateFor(workspace.id);
 	const reviewJob = workspace.jobId ? loadJob(workspace.jobId) : void 0;
 	const kissJob = kissRun ? loadJob(kissRun.jobId) : void 0;
-	const notice = workspace.lastUpdate?.acknowledged ? void 0 : workspace.lastUpdate;
-	if (notice) mutateWorkspace(workspace.id, (current) => {
-		if (current.lastUpdate?.at === notice.at) current.lastUpdate.acknowledged = true;
-	});
+	const unseen = [workspace.lastUpdate, workspace.lastRecheck].filter((outcome) => outcome !== void 0 && !outcome.acknowledged);
+	const notice = unseen.sort((a, b) => b.at - a.at)[0];
+	if (notice) {
+		const read = new Set(unseen.map((outcome) => outcome.at));
+		mutateWorkspace(workspace.id, (current) => {
+			if (current.lastUpdate && read.has(current.lastUpdate.at)) current.lastUpdate.acknowledged = true;
+			if (current.lastRecheck && read.has(current.lastRecheck.at)) current.lastRecheck.acknowledged = true;
+		});
+	}
 	const everyReview = recentWorkspaces(Number.MAX_SAFE_INTEGER);
 	const html = renderWorkspace({
 		session: workspace.session,
@@ -18568,33 +18427,78 @@ async function kissFreshnessOrNull(workspace) {
 	}
 }
 /**
-* Re-read the pull request conversation, at the reviewer's request.
+* Re-check the pull request discussion, at the reviewer's request: re-read it, then reconcile the
+* findings with whatever in it is new to them, at the commit the review read.
 *
-* Answers 200 with `ok: false` rather than an error status when it does not work. The page's job
-* here is to tell the reviewer what happened in a sentence, and a failed re-read is an outcome —
-* the conversation on disk is untouched and the review is exactly as usable as it was a moment
-* ago. An HTTP error would make the page choose between a stack trace and silence.
+* Answers 200 with `ok: false` rather than an error status when it does not work, for the reason the
+* update route does: a failure is an outcome the page has to explain in a sentence. 409 when an update
+* or another Re-check holds the review, which the reloaded page then shows running.
+*
+* Saved in two ways, because two different things can come of it. A reassessment that was applied
+* goes on the way an update does, onto the review as it is on disk. Anything short of that changed
+* only the conversation and the "already raised" lines, and goes on the way a re-read always has,
+* through `saveRefresh`, which will not put an older conversation over a newer one.
 */
 async function handleRefreshPr(res, workspace) {
 	const reattributing = JSON.stringify(workspace.session.result);
-	adoptLegacyBaseline(workspace);
-	const startedAt = Date.now();
+	const begun = Date.now();
 	let outcome;
 	try {
-		outcome = await refreshPrContext(workspace);
-	} catch {
-		outcome = unforeseenFailure(startedAt);
+		outcome = await track(recheckConversation(workspace, { source: "workspace" }));
+	} catch (error) {
+		if (error instanceof UpdateAlreadyRunningError) return send(res, 409, { error: error.message });
+		outcome = {
+			at: Date.now(),
+			ok: false,
+			message: error instanceof RefreshUnavailableError || error instanceof ReviewBeingDeletedError ? error.message : "The findings could not be reassessed. Nothing about them has changed.",
+			stop: "analysis-failed",
+			fetchFailed: false,
+			moved: false,
+			...rereadSince(workspace, begun) ? { conversationOk: workspace.lastPrRefresh.ok } : {},
+			fromSha: null,
+			toSha: null,
+			scope: "conversation"
+		};
 	}
-	saveRefresh(workspace, outcome, reattributing);
+	const applied = outcome.ok && outcome.stop === null;
+	const cancelled = outcome.stop === "cancelled";
+	workspace.lastRecheck = outcome;
+	const reread = !applied && !cancelled ? rereadSince(workspace, begun) : void 0;
+	if (reread) saveRefresh(workspace, reread, reattributing);
+	const saved = mutateWorkspace(workspace.id, (fresh) => applied ? {
+		...mergeUpdateInto(fresh, workspace),
+		lastRecheck: outcome
+	} : {
+		...fresh,
+		lastRecheck: outcome
+	});
+	const refresh = reread ?? (applied ? workspace.lastPrRefresh : void 0);
 	record({
 		event: "pr_conversation_rechecked",
 		reviewId: workspace.id,
-		ok: outcome.ok,
-		changed: outcome.changes ? !isUnchanged(outcome.changes) : false,
-		attributionsRestated: outcome.attributionsRestated ?? 0,
-		attributionsWithdrawn: outcome.attributionsWithdrawn ?? 0
+		ok: outcome.conversationOk === true,
+		changed: refresh?.changes ? !isUnchanged(refresh.changes) : false,
+		attributionsRestated: refresh?.attributionsRestated ?? 0,
+		attributionsWithdrawn: refresh?.attributionsWithdrawn ?? 0,
+		reassessment: reassessmentOf(outcome),
+		resolved: outcome.counts?.resolved ?? 0,
+		questionsAnswered: outcome.counts?.questionsAnswered ?? 0,
+		newIssues: outcome.counts?.newIssues ?? 0
 	});
-	send(res, 200, outcome);
+	send(res, 200, saved?.lastRecheck ?? outcome);
+}
+/** The re-read this request made, if it made one: the copy's record, begun no earlier than the request. */
+function rereadSince(workspace, begun) {
+	const refresh = workspace.lastPrRefresh;
+	return refresh && (refresh.startedAt ?? refresh.at) >= begun ? refresh : void 0;
+}
+/** What a Re-check did to the findings, as the closed set the log records. */
+function reassessmentOf(outcome) {
+	if (outcome.stop === "cancelled") return "cancelled";
+	if (outcome.stop === "already-current") return "not-needed";
+	if (outcome.stop === "analysis-failed") return "failed";
+	if (outcome.stop !== null) return "skipped";
+	return outcome.counts && findingsChanged(outcome.counts) ? "changed" : "unchanged";
 }
 /**
 * Bring the whole review up to date with the checkout, at the reviewer's request.