prreviewbuddy 0.52.2 → 0.55.1

package/dist/server.js

@@ -1,4 +1,4 @@
-import { $ as compactQueue, $t as loadWorkspace, A as createPrState, An as reviewerDispositions, At as followedBranch, B as toneOf, Bn as resolveModel, Bt as phasesFor, C as readEvents, Cn as queueStamp, Ct as claimRequestUrl, D as announceJob, Dn as isQuestionOutstanding, Dt as fillFileUrlTemplate, E as telemetryUploadConsent, En as isIssueOutstanding, Et as remoteHost, F as markAllRead, Ft as isTerminal, G as extractJsonText, Gn as STORE_ROOT, Gt as isClaimed, H as withUsageRecorded, Hn as readAgentPreference, Ht as purposeOf, I as markRead, It as loadJob, J as readMarker, Jt as indexKeptIds, K as ReviewBeingDeletedError, Kn as AGENT_IDS, Kt as followedRefName, L as pruneNotifications, Ln as isCommitReview, Lt as saveJob, M as eventName, Mn as describeAuthorship, Mt as allJobs, N as headline, Nn as WITHHELD_REASON, Nt as endedAt, O as branchOf, On as issuesOutstanding, Ot as checkCodeFreshness, P as listNotifications, Pn as kissOutcome, Pt as fail, Q as activateQueued, Qn as AgentUnavailableError, Qt as lineagePosition, R as readNotification, Rn as git, Sn as queueRemove, St as writePortPreference, T as recordTelemetryUploadConsent, Tn as doneVerb, Tt as forgeFor, U as EXPLAIN_SIMPLY_PROMPT, Un as writeAgentPreference, V as unreadCount$1, Vn as clearAgentPreference, Vt as progressSteps, W as asString, Xt as latestKissRun, Y as removeWorktree, Yn as agentFor, Yt as indexReviewGroups, Z as relativeTime$1, Zn as AgentCancelledError, _ as agentEnvOf, _n as offersLifecycle, _t as MAX_WORKSPACE_PORT, a as wasBlocked, an as reviewedCommit, bn as queueAdd, bt as resolveWorkspacePort, c as RefreshUnavailableError, cn as touchWorkspace, ct as serverEntryExists, d as refreshPrContext, dn as LIFECYCLES, f as isUnchanged, fn as activityLabel, ft as writeServerRecord, gn as lifecyclePill, gt as DEFAULT_WORKSPACE_PORT, h as liveUpdateFor, hn as lifecycleChip, ht as feedbackUrl, i as liveJobsFor, in as recentWorkspaces, it as clearServerRecord, j as createPrUpdate, jn as processDiscussion, jt as reviewedShaOf, k as subjectOf, kn as questionsOutstanding, kt as checkReview, l as mergeUpdateInto, ln as workspaceRevision, lt as spawnServer, m as UpdateAlreadyRunningError, mn as lifecycleAction, n as deleteReview, nt as readIndexToken, o as discardJob, ot as readServerRecord, p as askCheckout, pn as isLifecycle, pt as BUILD_VERSION, q as MANAGED_ROOT, qt as groupByLineage, r as lineageIds, rn as previousKissResult, s as FETCH_TIMEOUT_MS, t as deleteLineage, tn as mutateWorkspace, tt as settleQueue, u as updateReview, un as workspaceStamps, vn as parseLifecycle, vt as MIN_WORKSPACE_PORT, w as record, wn as readQueue, x as runJob, xn as queueAddMany, xt as statedWorkspacePort, y as startKissJob, yn as sectionOf, yt as parseWorkspacePort, z as removeNotification, zt as isLiveJob } from "./delete_review-BiV1aBpx.js";
+import { $ as relativeTime$1, $n as AGENT_IDS, $t as kissDecisionRefusal, A as createPrState, An as readQueue, At as checkCodeFreshness, B as toneOf, Bn as WITHHELD_REASON, C as readEvents, Cn as offersLifecycle, Ct as statedWorkspacePort, D as announceJob, Dn as queueAddMany, Dt as forgeFor, E as telemetryUploadConsent, En as queueAdd, F as markAllRead, Fn as questionsOutstanding, Ft as endedAt, G as isLongDescription, Gn as git, H as withUsageRecorded, Ht as phasesFor, I as markRead, In as reviewerDispositions, It as fail, J as ReviewBeingDeletedError, Jn as clearAgentPreference, Jt as decideKissRecommendation, K as asString, L as pruneNotifications, Ln as processDiscussion, Lt as isTerminal, M as eventName, Mn as isIssueOutstanding, Mt as followedBranch, N as headline, Nn as isQuestionOutstanding, Nt as reviewedShaOf, O as branchOf, On as queueRemove, Ot as remoteHost, P as listNotifications, Pn as issuesOutstanding, Pt as allJobs, Qn as STORE_ROOT, Qt as indexReviewGroups, R as readNotification, Rn as recommendationsOf, Rt as loadJob, Sn as lifecyclePill, St as resolveWorkspacePort, T as recordTelemetryUploadConsent, Tn as sectionOf, Tt as claimRequestUrl, U as EXPLAIN_SIMPLY_PROMPT, Ut as progressSteps, V as unreadCount$1, Vn as kissOutcome, Vt as isLiveJob, W as hasAuthorContent, Wn as isCommitReview, Wt as purposeOf, X as readMarker, Xn as writeAgentPreference, Xt as groupByLineage, Y as MANAGED_ROOT, Yn as readAgentPreference, Yt as followedRefName, Z as removeWorktree, Zt as indexKeptIds, _ as agentEnvOf, _n as LIFECYCLES, _t as feedbackUrl, a as wasBlocked, ar as AgentUnavailableError, b as reanalyseReview, bn as lifecycleAction, bt as MIN_WORKSPACE_PORT, c as RefreshUnavailableError, cn as presentedKissRunOf, ct as readServerRecord, d as refreshPrContext, dn as reviewedCommit, dt as spawnServer, en as kissDecisionsOf, et as activateQueued, f as isUnchanged, gn as workspaceStamps, h as liveUpdateFor, hn as workspaceRevision, ht as BUILD_VERSION, i as liveJobsFor, in as loadWorkspace, ir as AgentCancelledError, it as readIndexToken, j as createPrUpdate, jn as doneVerb, jt as checkReview, k as subjectOf, kn as queueStamp, kt as fillFileUrlTemplate, l as mergeUpdateInto, ln as previousKissResult, m as UpdateAlreadyRunningError, mn as touchWorkspace, mt as writeServerRecord, n as deleteReview, nr as agentFor, o as discardJob, on as mutateWorkspace, ot as clearServerRecord, p as askCheckout, q as extractJsonText, qn as resolveModel, qt as isClaimed, r as lineageIds, rn as lineagePosition, rt as settleQueue, s as FETCH_TIMEOUT_MS, t as deleteLineage, tn as latestKissRun, tt as compactQueue, u as updateReview, un as recentWorkspaces, ut as serverEntryExists, vn as activityLabel, vt as DEFAULT_WORKSPACE_PORT, w as record, wn as parseLifecycle, wt as writePortPreference, x as runJob, xn as lifecycleChip, xt as parseWorkspacePort, y as startKissJob, yn as isLifecycle, yt as MAX_WORKSPACE_PORT, z as removeNotification, zn as describeAuthorship, zt as saveJob } from "./delete_review-B2bqhgtx.js";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { createHash, timingSafeEqual } from "node:crypto";
@@ -186,6 +186,7 @@ function composeReview(session) {
 	return {
 		schemaVersion: 1,
 		summary: primary.summary,
+		...primary.motivation ? { motivation: primary.motivation } : {},
 		recommendation: primary.recommendation,
 		nextSteps: primary.nextSteps,
 		overallRisk,
@@ -839,13 +840,28 @@ var FINDING_COPY_CLASS = "pr-helper-finding-copy";
 * a chat reply's "Copy message".
 */
 function renderFindingCopySource(source, kind) {
-	const name = kind === "issue" ? "Copy finding" : "Copy question";
+	const name = kind === "issue" ? "Copy finding" : kind === "question" ? "Copy question" : "Copy recommendation";
 	return button(`${MESSAGE_SOURCE_ATTR}="${escapeHtml$1(source)}"`, {
 		label: "",
 		aria: name,
 		tip: name
 	});
 }
+/**
+* The same control with its word showing, for a footer of worded actions.
+*
+* A KISS card's Copy draft comment sits among Plan to simplify and Leave it, where an icon alone
+* would read as decoration. `extra` is for attributes the caller's own client needs, such as the
+* handle Copy recommendations is found by; the source may be updated after render, since the
+* listener reads it at the moment of the click.
+*/
+function renderLabelledCopySource(source, label, extra = "") {
+	return button(`${MESSAGE_SOURCE_ATTR}="${escapeHtml$1(source)}"${extra ? ` ${extra}` : ""}`, {
+		label,
+		aria: label,
+		tip: label
+	});
+}
 /** Where a finding's button keeps its resting word and name. Absent on a chat reply's. */
 var IDLE_LABEL_ATTR = "data-copy-idle-label";
 var IDLE_ARIA_ATTR = "data-copy-idle-aria";
@@ -1097,6 +1113,32 @@ function renderInline(value) {
 	}).replace(/(?<!!)\[([^\]\n]+)\]\(([^)\s]+)\)/g, (match, label, href) => SAFE_HREF.test(href) ? `<a href="${href}" target="_blank" rel="noopener noreferrer">${label}</a>` : match).replace(/\*\*([^*\n]+)\*\*/g, "<strong>$1</strong>").replace(/__([^_\n]+)__/g, "<strong>$1</strong>").replace(/(^|[^*\w])\*([^*\n]+)\*/g, "$1<em>$2</em>").replace(/(^|[^_\w])_([^_\n]+)_(?![\w_])/g, "$1<em>$2</em>").replace(INLINE_TOKEN, (_match, index) => `<code>${codeSpans[Number(index)]}</code>`);
 }
 //#endregion
+//#region ../../packages/review-harness/src/domain/ui/components/intent_note.ts
+/**
+* The Overview's unclear motive, kept in step with its Intent question.
+*
+* Its own module for the same reason the Author's context toggle is: the workspace marks a question
+* answered in place, without re-rendering the Overview, and its client should not have to bundle
+* the tab renderer to keep the two in agreement. The markup is written by `renderWhyThisChange`.
+*
+* Marking a question answered records that it was answered, never what the answer was, so nothing
+* here touches the stored motivation. It only says the analysis is older than the answer.
+*/
+var INTENT_NOTE_COPY = "This question is marked answered. If the answer was added to the PR description or conversation, run the review again to incorporate it.";
+var RUN_REVIEW_AGAIN = "Run review again";
+//#endregion
+//#region ../../packages/review-harness/src/domain/ui/components/author_context_toggle.ts
+/**
+* The Author's context preview, opened and closed.
+*
+* Its own module because both hosts call it from their own click handling, and the workspace
+* client should not have to bundle the whole tab renderer to do it. The markup it acts on is
+* written by `renderAuthorContext` in review_tabs.ts, from the same constants.
+*/
+var AUTHOR_CONTEXT_COLLAPSED_CLASS = "pr-helper-author-context-collapsed";
+var SHOW_FULL_DESCRIPTION = "Show full description";
+var AUTHOR_CONTEXT_SECTION_ID = "pr-helper-author-context";
+//#endregion
 //#region ../../packages/review-harness/src/domain/utils/model_label.ts
 var KNOWN_BRANDS = {
 	gpt: "GPT",
@@ -1735,6 +1777,109 @@ function renderOverviewActions(session, options) {
 	if (!options?.diagrams) return explain;
 	return `<div class="pr-helper-overview-actions">${explain}<button type="button" class="pr-helper-map-button" data-view-nav="map">Diagrams</button></div>`;
 }
+/**
+* The pull request's description, as the author wrote it, ahead of anything we say about the change.
+*
+* Read from the analysis's own snapshot, never from the live request, so an older analysis shows
+* the description it was made against. Nothing at all when there is none or it is an unfilled
+* template: an empty "Author's context" would read as the author having said nothing, when on a
+* local branch there was never anyone to ask.
+*
+* Long descriptions are clamped rather than cut. The whole text is in the page, checklists and
+* testing notes included, and the button only changes how much of it shows.
+*/
+function renderAuthorContext(session) {
+	const description = session.metadata.authorDescription;
+	if (!hasAuthorContent(description)) return "";
+	const id = "pr-helper-author-context-body";
+	const long = isLongDescription(description);
+	const toggle = long ? `<button type="button" class="pr-helper-author-context-toggle" aria-expanded="false" aria-controls="${id}" data-author-context-toggle>${SHOW_FULL_DESCRIPTION}</button>` : "";
+	return `
+    <section class="pr-helper-author-context" id="${AUTHOR_CONTEXT_SECTION_ID}" aria-labelledby="pr-helper-author-context-heading">
+      <h4 class="pr-helper-overview-heading" id="pr-helper-author-context-heading" tabindex="-1">Author's context</h4>
+      <div class="pr-helper-author-context-body pr-helper-markdown${long ? ` ${AUTHOR_CONTEXT_COLLAPSED_CLASS}` : ""}" id="${id}">${renderMarkdown(description)}</div>
+      ${toggle}
+    </section>
+  `;
+}
+/**
+* An evidence path, presented as what the host could establish about it. A changed file opens in
+* the diff and a real unchanged one in the source view; a path nobody could check is shown as text,
+* with no `data-file`, so nothing invites the reader to trust it as a link.
+*/
+function renderEvidenceFile(item) {
+	if (!item.file) return "";
+	if (item.fileState === "changed") return renderFileLocation(item.file, "pr-helper-why-evidence-file");
+	if (item.fileState === "unchanged") return renderRelatedFiles([item.file]);
+	return `<span class="pr-helper-why-evidence-unverified"><code>${escapeHtml$1(item.file)}</code> · unverified path</span>`;
+}
+var MOTIVATION_LABELS = {
+	stated: "Stated by the author",
+	inferred: "Likely motivation",
+	unclear: "Motivation unclear"
+};
+var EVIDENCE_LABELS = {
+	test: "Test",
+	behaviour: "Behaviour",
+	issue: "Issue",
+	commit: "Commit",
+	docs: "Docs",
+	code: "Code"
+};
+/**
+* Why the change exists, and how the review knows.
+*
+* Every status shows what supports it: a stated motive its quote, an inferred one its evidence, an
+* unclear one the question that would settle it. `verifyMotivation` guarantees each is there, so a
+* status rendered without its support would be a stored result this version did not write.
+*
+* Nothing for a result with no motivation, which covers every review made before the field and
+* every review where the motive would not change how it should be read.
+*/
+function renderWhyThisChange(motivation, session, questions) {
+	if (!motivation) return "";
+	if (motivation.status === "unclear") return renderUnclearMotive(motivation, session, questions);
+	let support = "";
+	if (motivation.status === "stated" && motivation.sourceQuote) {
+		const source = hasAuthorContent(session.metadata.authorDescription) ? `<button type="button" class="pr-helper-why-link" data-author-context-reveal>From Author's context</button>` : "";
+		support = `<blockquote class="pr-helper-why-quote">${renderInlineText(motivation.sourceQuote)}</blockquote>${source}`;
+	} else if (motivation.status === "inferred" && motivation.evidence?.length) support = `<ul class="pr-helper-why-evidence">${motivation.evidence.map((item) => `<li><span class="pr-helper-why-evidence-kind">${EVIDENCE_LABELS[item.kind]}</span> ${renderInlineText(item.detail)}${renderEvidenceFile(item)}</li>`).join("")}</ul>`;
+	return `
+    <section class="pr-helper-why" aria-labelledby="pr-helper-why-heading">
+      <h4 class="pr-helper-overview-heading" id="pr-helper-why-heading">Why this change?</h4>
+      <p class="pr-helper-why-status pr-helper-why-status-${motivation.status}">${MOTIVATION_LABELS[motivation.status]}</p>
+      <p class="pr-helper-why-summary">${renderInlineText(motivation.summary)}</p>
+      ${support}
+    </section>
+  `;
+}
+/**
+* An unclear motive, and what became of its question.
+*
+* Once the question is answered the stored motivation is still the analysis's, so it is shown as
+* that: unclear when analysed. Only a new analysis that reads the answer may replace it, and the
+* button runs one. Both halves are rendered and one is hidden, so the workspace can switch them
+* when a question is marked answered in place (`syncIntentNote`).
+*/
+function renderUnclearMotive(motivation, session, questions) {
+	const intent = questions.find((q) => q.category === "intent");
+	const answered = intent ? !isQuestionOutstanding(intent, new Set(session.answeredQuestionIds ?? [])) : false;
+	const hide = (yes) => yes ? " hidden" : "";
+	return `
+    <section class="pr-helper-why" aria-labelledby="pr-helper-why-heading"${intent ? ` data-intent-question="${escapeHtml$1(intent.id)}"` : ""}>
+      <h4 class="pr-helper-overview-heading" id="pr-helper-why-heading">Why this change?</h4>
+      <p class="pr-helper-why-status pr-helper-why-status-unclear" data-intent-open${hide(answered)}>${MOTIVATION_LABELS.unclear}</p>
+      <p class="pr-helper-why-status pr-helper-why-status-unclear" data-intent-answered${hide(!answered)}>Motivation was unclear when analysed</p>
+      <p class="pr-helper-why-summary">${renderInlineText(motivation.summary)}</p>
+      ${motivation.authorQuestion ? `<p class="pr-helper-why-question">${renderInlineText(motivation.authorQuestion)}</p>` : ""}
+      <button type="button" class="pr-helper-why-link" data-overview-nav="questions" data-intent-open${hide(answered)}>Asked in Questions, under Intent</button>
+      <div class="pr-helper-why-answered" data-intent-answered${hide(!answered)}>
+        <p class="pr-helper-why-answered-note">${INTENT_NOTE_COPY}</p>
+        <button type="button" class="pr-helper-why-rerun" data-run-review-again>${RUN_REVIEW_AGAIN}</button>
+      </div>
+    </section>
+  `;
+}
 function renderOverviewTab(session, iconUrl = "", options) {
 	if (!session) return renderNoReviewState(iconUrl);
 	if (session.status === "generating") return renderGeneratingOverview(session, iconUrl);
@@ -1744,6 +1889,12 @@ function renderOverviewTab(session, iconUrl = "", options) {
 	const nextSteps = result.nextSteps.map((step) => `<li class="pr-helper-markdown">${renderMarkdown(step)}</li>`).join("") || "<li>None</li>";
 	const metrics = deriveReviewMetrics(result);
 	return `
+    ${renderAuthorContext(session)}
+    ${renderWhyThisChange(result.motivation, session, result.questions)}
+    <section class="pr-helper-whats-changing" aria-labelledby="pr-helper-whats-changing-heading">
+      <h4 class="pr-helper-overview-heading" id="pr-helper-whats-changing-heading">What's changing</h4>
+      <div class="pr-helper-review-summary pr-helper-markdown">${renderMarkdown(result.summary)}</div>
+    </section>
     <div class="pr-helper-risk-headline">
       <div class="pr-helper-risk-headline-top">
         <span class="pr-helper-risk-dot pr-helper-risk-dot-${result.overallRisk}"></span>
@@ -1759,7 +1910,6 @@ function renderOverviewTab(session, iconUrl = "", options) {
       ${renderRemainingStat(questionsOutstanding(result.questions, new Set(session.answeredQuestionIds ?? [])), "Questions", "questions", "answered")}
       ${renderCoverageStat(session, metrics.files)}
     </div>
-    <div class="pr-helper-review-summary pr-helper-markdown">${renderMarkdown(result.summary)}</div>
     ${renderSuggestedPath(result.sections, "Suggested review path")}
     ${renderOverviewActions(session, options)}
     ${renderReviewDetails(session, options)}
@@ -2345,6 +2495,16 @@ function renderDismissToggle(issue, isDismissed, stale, dismissal) {
 	const settled = issue.reconciliationStatus === "resolved";
 	return `<button type="button" class="pr-helper-issue-dismiss-toggle" data-issue-dismissed="${escapeHtml$1(issue.id)}" data-dismissed="${isDismissed}"${stale ? " data-stale=\"true\"" : ""}${dismissal ? ` data-dismissed-in="${escapeHtml$1(dismissal.sessionId)}"` : ""}${settled ? " data-settled=\"true\"" : ""}>${label}</button>`;
 }
+/**
+* The group an Intent question lives in, keyed like a theme's so the workspace client finds its
+* way back to it the same way: by the card's `data-section-id`. Prefixed so no model-chosen theme
+* id can be the same string.
+*/
+var INTENT_QUESTION_GROUP = "prb-intent";
+/** Where a question card belongs on the Questions tab: Intent, its theme, or neither. */
+function questionHome(q) {
+	return q.category === "intent" ? INTENT_QUESTION_GROUP : q.sectionId;
+}
 function renderQuestionCard(q, sections, answered, records, now = Date.now(), investigatingId, options) {
 	const importanceBadge = q.importance ? `<span${pillAttrs(`pr-helper-question-importance-badge pr-helper-question-importance-${q.importance}`, importanceTip(q.importance))}>${escapeHtml$1(q.importance)}</span>` : "";
 	const jumpLink = renderQuestionJump(q.file, options);
@@ -2353,7 +2513,7 @@ function renderQuestionCard(q, sections, answered, records, now = Date.now(), in
 	const investigationAnswer = q.investigationAnswer?.trim() ? `<h5>Answer from investigation</h5><p class="pr-helper-issue-desc pr-helper-investigation-answer">${renderInlineText(q.investigationAnswer)}</p>` : "";
 	const reconciliationAnswer = q.reconciliationAnswer?.trim() ? `<h5>Answered by the new changes</h5><p class="pr-helper-issue-desc pr-helper-investigation-answer">${renderInlineText(q.reconciliationAnswer)}</p>` : "";
 	return `
-    <div class="pr-helper-question-card${answered ? " pr-helper-question-card-answered" : ""}${q.investigationImpact ? ` pr-helper-issue-investigation-${q.investigationImpact}` : ""}" data-finding-card="${escapeHtml$1(q.id)}"${q.sectionId ? ` data-section-id="${escapeHtml$1(q.sectionId)}"` : ""}>
+    <div class="pr-helper-question-card${answered ? " pr-helper-question-card-answered" : ""}${q.investigationImpact ? ` pr-helper-issue-investigation-${q.investigationImpact}` : ""}" data-finding-card="${escapeHtml$1(q.id)}"${questionHome(q) ? ` data-section-id="${escapeHtml$1(questionHome(q))}"` : ""}>
       <div class="pr-helper-issue-header">
         <div class="pr-helper-issue-title-row">
           <p class="pr-helper-issue-title">${renderInlineText(q.question)}</p>
@@ -2429,10 +2589,18 @@ function renderQuestionsTab(session, investigatingId, options) {
 	const open = result.questions.filter((q) => isQuestionOutstanding(q, answered));
 	const settled = result.questions.filter((q) => !isQuestionOutstanding(q, answered));
 	const closed = settled.length === 0 ? "" : renderClosedFindings(`Answered (${settled.length})`, settled.map(card).join(""), "questions", open.length === 0);
-	if (result.sections.length === 0) return `${progress}${open.map(card).join("")}${closed}`;
+	const intent = open.filter((q) => q.category === "intent");
+	const intentHtml = result.questions.some((q) => q.category === "intent") ? `
+      <div class="pr-helper-question-group" data-question-group="${INTENT_QUESTION_GROUP}"${intent.length ? "" : " hidden"}>
+        <h5 class="pr-helper-question-group-title">Intent</h5>
+        ${intent.map(card).join("")}
+      </div>
+    ` : "";
+	const rest = open.filter((q) => q.category !== "intent");
+	if (result.sections.length === 0) return `${progress}${intentHtml}${rest.map(card).join("")}${closed}`;
 	const grouped = /* @__PURE__ */ new Map();
 	const ungrouped = [];
-	for (const q of open) if (q.sectionId && sections.has(q.sectionId)) {
+	for (const q of rest) if (q.sectionId && sections.has(q.sectionId)) {
 		const list = grouped.get(q.sectionId) ?? [];
 		list.push(q);
 		grouped.set(q.sectionId, list);
@@ -2447,8 +2615,8 @@ function renderQuestionsTab(session, investigatingId, options) {
 	* card to the bottom of the tab (which is what it did) puts it below the answered drawer,
 	* outside any theme, where a reload then moves it somewhere else.
 	*/
-	const themed = new Set(result.questions.filter((q) => q.sectionId).map((q) => q.sectionId));
-	return `${progress}${result.sections.filter((s) => themed.has(s.id)).map((s) => `
+	const themed = new Set(result.questions.filter((q) => q.sectionId && q.category !== "intent").map((q) => q.sectionId));
+	return `${progress}${intentHtml}${result.sections.filter((s) => themed.has(s.id)).map((s) => `
       <div class="pr-helper-question-group" data-question-group="${escapeHtml$1(s.id)}"${grouped.has(s.id) ? "" : " hidden"}>
         <h5 class="pr-helper-question-group-title">${escapeHtml$1(s.title)}</h5>
         ${(grouped.get(s.id) ?? []).map(card).join("")}
@@ -3565,6 +3733,58 @@ function verdictLabel(verdict) {
 	return VERDICT_LABELS[verdict] ?? verdict;
 }
 //#endregion
+//#region ../../packages/review-harness/src/domain/kiss/handoff.ts
+function handoffSource(recommendation) {
+	const { id, title, gist, complexity, whyNotJustified, simplerDirection, draftComment, locations } = recommendation;
+	return {
+		id,
+		title,
+		...gist ? { gist } : {},
+		...complexity ? { complexity } : {},
+		whyNotJustified,
+		simplerDirection,
+		...draftComment ? { draftComment } : {},
+		locations
+	};
+}
+/**
+* One recommendation: the title, why it matters, the simpler approach, where to start, and the
+* draft comment when the run wrote one.
+*
+* "Why it matters" is the gist, which carries the case in a sentence or two. A schema 1 record has
+* none, and its `whyNotJustified` is the field of that shape that says why the complexity is not
+* needed, so it stands in rather than leaving the line out.
+*/
+function recommendationMarkdown(recommendation) {
+	const why = recommendation.gist || recommendation.whyNotJustified;
+	const primary = recommendation.locations.find((location) => location.primary) ?? recommendation.locations[0];
+	return [
+		`### ${recommendation.title.trim()}`,
+		why ? `**Why it matters:** ${why.trim()}` : "",
+		`**Simpler approach:** ${recommendation.simplerDirection.trim()}`,
+		primary ? `**Start here:** \`${primary.line ? `${primary.path}:${primary.line}` : primary.path}\`` : "",
+		recommendation.draftComment?.trim() ? `**Draft comment:**\n\n${quote(recommendation.draftComment.trim())}` : ""
+	].filter((part) => part !== "").join("\n\n");
+}
+/** The reviewer's handoff: the recommendations they chose to raise, in the order given. */
+function handoffMarkdown(recommendations) {
+	if (recommendations.length === 0) return "";
+	return [`## Simplification suggestions (${recommendations.length})`, ...recommendations.map(recommendationMarkdown)].join("\n\n");
+}
+function quote(text) {
+	return text.split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
+}
+/**
+* The sources as JSON that is safe inside a `<script type="application/json">` element.
+*
+* JSON unicode escapes rather than HTML entities: `JSON.parse` restores the original characters,
+* while `<\/script>` in a title or a draft can no longer end the element early. `&` is escaped too
+* so no sequence in the text can be read as markup by anything that looks at the raw element.
+*/
+function embedHandoffSources(sources) {
+	return JSON.stringify(sources).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/kiss_view.ts
 /**
 * The KISS review, on the page.
@@ -3628,11 +3848,13 @@ var INTENTS = [{
 	audience: "author",
 	label: "Review my code",
 	describes: "Reviewing my code",
+	perspective: "My code",
 	consequence: "Get direct suggestions to simplify your implementation."
 }, {
 	audience: "reviewer",
 	label: "Review someone else's code",
 	describes: "Reviewing someone else's code",
+	perspective: "Someone else's code",
 	consequence: "Decide which simplifications are worth raising with the author."
 }];
 /**
@@ -3648,6 +3870,61 @@ function audienceSentence(audience) {
 	return INTENTS.find((intent) => intent.audience === audience)?.describes ?? "";
 }
 /**
+* The two decisions, in each audience's words.
+*
+* One stored value, two vocabularies: an author accepts by planning the change and a reviewer by
+* raising it, and neither declines by dismissing, because declining is not a verdict that the
+* recommendation was wrong. Total over both unions, so a new audience or decision will not build
+* without its words. Exported for the client, which relabels a card after a click.
+*/
+var DECISION_LABELS = {
+	author: {
+		accepted: "Plan to simplify",
+		declined: "Keep as implemented"
+	},
+	reviewer: {
+		accepted: "Raise with author",
+		declined: "Leave it"
+	}
+};
+/** What a card's status pill says. "Open" until decided, then the decision in the audience's words. */
+function decisionStatusLabel(audience, decision) {
+	return decision === "undecided" ? "Open" : DECISION_LABELS[audience][decision];
+}
+/** The line over the list. Shared with the client so a click and a reload say the same thing. */
+function kissProgressBody(total, open) {
+	return open === 0 ? `<span class="pr-helper-questions-progress-check" aria-hidden="true">\u2713</span><span class="pr-helper-questions-progress-count">All ${total} decided</span>` : `<span class="pr-helper-questions-progress-count">${open} of ${total} undecided</span>`;
+}
+/** The drawer's heading. Shared with the client for the same reason. */
+function decidedDrawerTitle(count) {
+	return `Decided (${count})`;
+}
+/**
+* Whether the reviewer's handoff can be copied, and the sentence that says why or why not.
+*
+* Stale comes first: handing off advice about commits the branch has moved past presents old advice
+* as current, however carefully it was chosen. The sentence is visible text beside the button
+* rather than a tooltip, so a disabled control always says what would enable it.
+*/
+function handoffState(accepted, stale, saving = false) {
+	if (saving) return {
+		enabled: false,
+		note: "Saving your decision. You can copy once it is saved."
+	};
+	if (stale) return {
+		enabled: false,
+		note: "Run KISS again before handing these recommendations off."
+	};
+	if (accepted === 0) return {
+		enabled: false,
+		note: "Choose Raise with author on the recommendations you want to hand off."
+	};
+	return {
+		enabled: true,
+		note: `${accepted === 1 ? "1 recommendation" : `${accepted} recommendations`} to raise with the author.`
+	};
+}
+/**
 * The KISS summary: the assessment, what drives it, and the complexity worth keeping.
 *
 * This is the pane the rail's KISS entry opens, so it carries every state the section can be in.
@@ -3659,13 +3936,53 @@ function renderKissSummary(view) {
 	if (!run) return renderKissEmpty(view.canRun);
 	if (run.status === "generating") return renderRunning(run, view.job ?? null);
 	if (run.status === "failed" || !run.result) return renderFailed(run, view);
-	return `${renderDocHead("KISS review", `${renderAnalysisDetails(provenanceFacts(run))}${KISS_TOGGLE}`)}
-<div class="prb-kiss-fresh-region" data-kiss-fresh-region data-reviewed-sha="${escapeHtml$1(run.reviewedSha)}"${view.freshness ? ` data-freshness="${escapeHtml$1(JSON.stringify(view.freshness))}"` : ""}${view.dismissedFreshnessSha ? ` data-dismissed-sha="${escapeHtml$1(view.dismissedFreshnessSha)}"` : ""}>${renderKissFreshness(run.reviewedSha, view.freshness ?? null, {
+	return `${renderDocHead("KISS review", `${renderPerspective(run.audience)}${renderAnalysisDetails(provenanceFacts(run))}${renderRunAgain(view.canRun)}${KISS_TOGGLE}`)}
+${renderFreshRegion(run, view)}
+${renderResultBody(run, "header")}
+${renderRunDialog(view.canRun, run.audience)}`;
+}
+/**
+* Whether the answer on the page still describes the branch, for the run the page presents.
+*
+* Drawn wherever a result is shown, including the earlier answer under a failed rerun: that answer
+* is the one being decided and handed off, and without this region the client has nowhere to repaint
+* a push it notices later.
+*/
+function renderFreshRegion(run, view) {
+	return `<div class="prb-kiss-fresh-region" data-kiss-fresh-region data-reviewed-sha="${escapeHtml$1(run.reviewedSha)}"${view.freshness ? ` data-freshness="${escapeHtml$1(JSON.stringify(view.freshness))}"` : ""}${view.dismissedFreshnessSha ? ` data-dismissed-sha="${escapeHtml$1(view.dismissedFreshnessSha)}"` : ""}>${renderKissFreshness(run.reviewedSha, view.freshness ?? null, {
 		dismissedSha: view.dismissedFreshnessSha,
 		actions: view.canRun
-	})}</div>
-${renderResultBody(run, "header")}
-${renderRunControl(view.canRun, "Run KISS review again")}`;
+	})}</div>`;
+}
+/**
+* Whose code the run was about, said as configuration rather than as part of the report.
+*
+* A compact line in the header rather than the question left standing under the result: the
+* choice was made, and what a finished report owes the reader is which choice it was.
+*/
+function renderPerspective(audience) {
+	const intent = INTENTS.find((candidate) => candidate.audience === audience);
+	if (!intent) return "";
+	return `<span class="prb-kiss-perspective" data-kiss-perspective="${audience}">Perspective: ${escapeHtml$1(intent.perspective)}</span>`;
+}
+/** Opens the run dialog. Beside Analysis details, because running again is a fact about the run too. */
+function renderRunAgain(canRun) {
+	return canRun ? "<button type=\"button\" class=\"prb-kiss-run-again\" data-kiss-run-open>Run again</button>" : "";
+}
+/**
+* The run control once a result exists: the same question, asked in a dialog.
+*
+* The previous run's audience is preselected, and the choice is still shown and still has to be
+* confirmed by pressing Run. Preselecting carries yesterday's framing forward only as far as the
+* reader can see it, which is the difference from the remembered default the empty state refuses.
+*/
+function renderRunDialog(canRun, audience) {
+	if (!canRun) return "";
+	return `<dialog class="prb-kiss-run-dialog" data-kiss-run-dialog aria-labelledby="prb-kiss-run-dialog-title">
+  <h4 class="prb-kiss-run-dialog-title" id="prb-kiss-run-dialog-title">Run KISS review again</h4>
+  ${renderRunControl(true, "Run KISS review", audience)}
+  <button type="button" class="prb-kiss-run-cancel" data-kiss-run-cancel>Cancel</button>
+</dialog>`;
 }
 /**
 * A completed run's answer, from the outcome down to how it was made.
@@ -3692,12 +4009,15 @@ ${provenance === "header" ? "" : renderProvenance(run)}`;
 }
 function renderKissFreshness(reviewedSha, freshness, options = {}) {
 	if (!freshness || freshness.state !== "changed") return "";
-	if (options.dismissedSha && options.dismissedSha === freshness.latestSha) return "";
+	const runAgain = options.actions ? "<button type=\"button\" class=\"prb-kiss-fresh-run\" data-kiss-run-open>Run again</button>" : "";
+	if (options.dismissedSha && options.dismissedSha === freshness.latestSha) return `<div class="prb-kiss-fresh" data-kiss-freshness="changed" data-collapsed role="status">
+  <p><strong>This KISS review describes commit ${escapeHtml$1(reviewedSha.slice(0, 7))}.</strong> The branch has moved on since. ${runAgain}</p>
+</div>`;
 	const moved = freshness.rewritten ? "The branch has been rewritten since, so this report describes commits that are no longer on it." : freshness.newCommits !== null ? `There ${freshness.newCommits === 1 ? "has been 1 commit" : `have been ${freshness.newCommits} commits`} on the branch since.` : "The branch has moved on since.";
 	return `<div class="prb-kiss-fresh" data-kiss-freshness="changed" role="status">
   <p><strong>This KISS review describes commit ${escapeHtml$1(reviewedSha.slice(0, 7))}.</strong> ${escapeHtml$1(moved)}</p>
-  <p class="prb-kiss-fresh-note">Running KISS again analyses the branch as it is now. The report below is kept either way.</p>
-  ${options.actions && freshness.latestSha ? `<button type="button" class="prb-kiss-fresh-dismiss" data-kiss-freshness-dismiss="${escapeHtml$1(freshness.latestSha)}">Not now</button>` : ""}
+  <p class="prb-kiss-fresh-note">Running KISS again analyses the branch as it is now. The report below and your decisions about it are kept either way.</p>
+  <p class="prb-kiss-fresh-actions">${runAgain}${options.actions && freshness.latestSha ? `<button type="button" class="prb-kiss-fresh-dismiss" data-kiss-freshness-dismiss="${escapeHtml$1(freshness.latestSha)}">Not now</button>` : ""}</p>
 </div>`;
 }
 /**
@@ -3718,8 +4038,73 @@ function renderKissRecommendations(view) {
       <h4 class="prb-kiss-outcome-title">Nothing to simplify</h4>
       <p class="prb-kiss-outcome-body">The analysis completed and did not identify a materially simpler way to meet these requirements.</p>
     </div>`;
+	const decisions = decisionsFor(view, presented);
+	const stale = view.freshness?.state === "changed";
+	const card = (recommendation, rank) => renderRecommendation(recommendation, {
+		runId: presented.id,
+		audience: presented.audience,
+		decision: decisions.get(recommendation.id) ?? "undecided",
+		rank,
+		stale,
+		actions: view.canRun
+	});
+	const recommendations = recommendationsOf(result);
+	const ranked = recommendations.map((recommendation, rank) => ({
+		recommendation,
+		rank
+	}));
+	const open = ranked.filter(({ recommendation }) => !decisions.has(recommendation.id));
+	const decided = ranked.filter(({ recommendation }) => decisions.has(recommendation.id));
+	const total = recommendations.length;
 	return `${RECS_HEAD}${earlier}${renderWithheldNote(presented)}
-${result.recommendations.map((recommendation) => renderRecommendation(recommendation)).join("")}`;
+${presented.audience === "reviewer" ? renderHandoff(recommendations, decisions, stale) : ""}
+<div class="pr-helper-questions-progress prb-kiss-progress" data-kiss-progress role="status">${kissProgressBody(total, open.length)}</div>
+<div class="prb-kiss-open-list" data-kiss-open-list>${open.map(({ recommendation, rank }) => card(recommendation, rank)).join("")}</div>
+<details class="pr-helper-closed-findings prb-kiss-decided" data-kiss-decided${decided.length === 0 ? " hidden" : ""}${open.length === 0 ? " data-nothing-open" : ""}>
+  <summary class="pr-helper-closed-findings-summary" data-kiss-decided-summary>${escapeHtml$1(decidedDrawerTitle(decided.length))}</summary>
+  <div class="pr-helper-closed-findings-list" data-kiss-decided-list>${decided.map(({ recommendation, rank }) => card(recommendation, rank)).join("")}</div>
+</details>`;
+}
+/**
+* What was decided about the run this pane presents, by recommendation id.
+*
+* Only decisions about recommendations the run still lists: a stored decision is never shown on a
+* card it was not made about, and a recommendation withheld as incomplete has no card to decide on.
+*/
+function decisionsFor(view, run) {
+	const listed = new Set(recommendationsOf(run.result).map((recommendation) => recommendation.id));
+	return new Map((view.decisions ?? []).filter((entry) => entry.runId === run.id && listed.has(entry.recommendationId)).map((entry) => [entry.recommendationId, entry.decision]));
+}
+/** The decisions made about the run the panes present, for the rail. */
+function kissDecisionCounts(view) {
+	const run = presentedKissRun(view);
+	if (!run?.result) return null;
+	const total = recommendationsOf(run.result).length;
+	return {
+		total,
+		open: total - decisionsFor(view, run).size
+	};
+}
+/**
+* The reviewer's handoff: what they chose to raise, as Markdown to paste.
+*
+* An export of the decisions on this page, not a report of its own. The Markdown comes from one
+* helper, over the model's own fields embedded beside the button, so what is copied is never read
+* back out of the rendered cards. The button's source is filled here for the decisions the page
+* loaded with, and refilled by the client after every decision.
+*
+* Reviewer runs only: an author was never going to hand these to anybody.
+*/
+function renderHandoff(recommendations, decisions, stale) {
+	const accepted = recommendations.filter((recommendation) => decisions.get(recommendation.id) === "accepted");
+	const state = handoffState(accepted.length, stale);
+	const sources = recommendations.map(handoffSource);
+	const copy = renderLabelledCopySource(state.enabled ? handoffMarkdown(accepted.map(handoffSource)) : "", "Copy recommendations", `data-kiss-handoff-copy aria-describedby="prb-kiss-handoff-note"${state.enabled ? "" : " disabled"}`);
+	return `<div class="prb-kiss-handoff" data-kiss-handoff${stale ? " data-stale" : ""}>
+  ${copy}
+  <p class="prb-kiss-handoff-note" id="prb-kiss-handoff-note" data-kiss-handoff-note>${escapeHtml$1(state.note)}</p>
+  <script type="application/json" data-kiss-handoff-source>${embedHandoffSources(sources)}<\/script>
+</div>`;
 }
 /**
 * A run whose every recommendation was withheld: incomplete, and said to be.
@@ -3780,22 +4165,23 @@ ${renderRunControl(canRun, "Run KISS review")}`;
 * the reader that the page argues with them; one that is plainly waiting on the choice above it
 * teaches them what the choice is for.
 *
-* Nothing is preselected, on a first run or on a rerun. The audience is confirmed every time,
-* because the same person is an author on Monday and a reviewer on Tuesday, and a remembered
-* answer would carry Monday's framing into Tuesday's report without saying so.
+* Nothing is preselected on a first run: there is no earlier answer, and a default would be the
+* page guessing whose code this is. A rerun preselects the audience the run it replaces was asked
+* for, inside a dialog that shows both choices and waits for Run, so the framing carried forward is
+* one the reader can see and change rather than one remembered for them.
 */
-function renderRunControl(canRun, label) {
+function renderRunControl(canRun, label, preselected) {
 	if (!canRun) return "";
 	return `<div class="prb-kiss-run" data-kiss-run-control>
   <fieldset class="prb-kiss-intents">
     <legend>Whose code is this?</legend>
     ${INTENTS.map((intent) => `<label class="prb-kiss-intent">
-      <input type="radio" name="kiss-audience" value="${intent.audience}" data-kiss-audience>
+      <input type="radio" name="kiss-audience${preselected ? "-again" : ""}" value="${intent.audience}" data-kiss-audience${intent.audience === preselected ? " checked" : ""}>
       <span class="prb-kiss-intent-label">${escapeHtml$1(intent.label)}</span>
       <span class="prb-kiss-intent-note">${escapeHtml$1(intent.consequence)}</span>
     </label>`).join("")}
   </fieldset>
-  <button type="button" class="prb-kiss-start" data-kiss-run disabled>${escapeHtml$1(label)}</button>
+  <button type="button" class="prb-kiss-start" data-kiss-run${preselected ? "" : " disabled"}>${escapeHtml$1(label)}</button>
 </div>`;
 }
 /**
@@ -3833,15 +4219,15 @@ function renderRunning(run, job) {
 */
 function renderFailed(run, view) {
 	const standing = view.previous ?? null;
-	return `${renderDocHead("KISS review", KISS_TOGGLE)}
+	return `${renderDocHead("KISS review", `${standing ? renderRunAgain(view.canRun) : ""}${KISS_TOGGLE}`)}
 <div class="prb-kiss-outcome" data-review-outcome="failed">
   <h4 class="prb-kiss-outcome-title">KISS review could not be completed</h4>
   <p class="prb-kiss-outcome-body">${escapeHtml$1(run.error ?? "The analysis did not finish.")}</p>
   ${standing ? "" : "<p class=\"prb-kiss-outcome-note\">Nothing was recorded from this run.</p>"}
   ${renderRejectedAnswer(run)}
 </div>
-${standing ? renderEarlier(standing) : ""}
-${renderRunControl(view.canRun, "Run KISS review again")}`;
+${standing ? `${renderFreshRegion(standing, view)}${renderEarlier(standing)}` : ""}
+${standing ? renderRunDialog(view.canRun, run.audience) : renderRunControl(view.canRun, "Run KISS review again", run.audience)}`;
 }
 /**
 * What the agent actually replied, folded away.
@@ -3935,14 +4321,14 @@ function renderProvenance(run) {
 */
 function renderJustified(items) {
 	if (items.length === 0) return "";
-	return `<section class="prb-kiss-justified">
-  <h4 class="prb-kiss-heading">Complexity worth keeping</h4>
-  ${items.map((item) => `<div class="prb-kiss-kept">
-    <p class="prb-kiss-kept-title">${escapeHtml$1(item.title)}</p>
+	return `<details class="prb-kiss-justified" data-kiss-justified>
+  <summary class="prb-kiss-justified-summary">Complexity worth keeping (${items.length})</summary>
+  ${items.map((item) => `<details class="prb-kiss-kept" data-kiss-kept>
+    <summary class="prb-kiss-kept-summary"><span class="prb-kiss-kept-title">${escapeHtml$1(item.title)}</span>${item.reason ? `<span class="prb-kiss-kept-reason" data-kiss-kept-reason>${escapeHtml$1(item.reason)}</span>` : ""}</summary>
     <div class="pr-helper-markdown">${renderMarkdown(item.rationale)}</div>
     ${renderLocations(item.locations)}
-  </div>`).join("")}
-</section>`;
+  </details>`).join("")}
+</details>`;
 }
 /**
 * What validation had to withdraw, disclosed rather than swallowed.
@@ -3964,26 +4350,20 @@ function renderAudit(run) {
   ${notes.map((note) => `<p>${escapeHtml$1(note)}</p>`).join("")}
 </div>`;
 }
-/**
-* One recommendation, as a decision aid rather than an analysis record.
-*
-* The card carries what a reviewer needs to understand and weigh the recommendation: the title,
-* the case in a sentence or two, the simpler approach, what it gains, the trade-off that could
-* change the decision, and where to start. Everything that exists to audit or challenge it sits in
-* one disclosure beneath, closed until asked for.
-*
-* Reads both schemas. A record written under schema 1 has no gist, and its `complexity` stands in
-* as the lede, because it is the only field of that shape that names what the card is about; it is
-* then not repeated in the disclosure. Stored runs are history and are not rewritten to fit.
-*/
-function renderRecommendation(recommendation) {
+function renderRecommendation(recommendation, context) {
 	const worthiness = recommendation.commentWorthiness;
 	const lede = recommendation.gist || recommendation.complexity || "";
 	const [start, ...rest] = orderedLocations(recommendation.locations);
-	return `<article class="prb-kiss-rec" data-payoff="${recommendation.payoff}"${worthiness ? ` data-worthiness="${worthiness}"` : ""}>
+	return `<article class="prb-kiss-rec" data-finding-card="${escapeHtml$1(recommendation.id)}" data-kiss-rec="${escapeHtml$1(recommendation.id)}" data-kiss-run-id="${escapeHtml$1(context.runId)}" data-audience="${context.audience}" data-rank="${context.rank}" data-decision="${context.decision}" data-payoff="${recommendation.payoff}"${worthiness ? ` data-worthiness="${worthiness}"` : ""}>
   <header class="prb-kiss-rec-head">
-    <h4 class="prb-kiss-rec-title">${escapeHtml$1(recommendation.title)}</h4>
+    <div class="prb-kiss-rec-title-row">
+      <h4 class="prb-kiss-rec-title" tabindex="-1">${escapeHtml$1(recommendation.title)}</h4>
+      ${renderFindingCopySource(recommendationMarkdown(handoffSource(recommendation)), "recommendation")}
+      ${context.actions ? renderAskBuddyMenu("recommendation") : ""}
+    </div>
     <div class="prb-kiss-rec-pills">
+      <span class="pr-helper-finding-status prb-kiss-decision-status" data-kiss-status="${context.decision}">${escapeHtml$1(decisionStatusLabel(context.audience, context.decision))}</span>
+      <span class="prb-kiss-stale" data-kiss-stale${context.stale ? "" : " hidden"}>Stale</span>
       <span class="prb-kiss-payoff" data-payoff="${recommendation.payoff}">${escapeHtml$1(PAYOFF[recommendation.payoff])}</span>
       ${worthiness ? `<span class="prb-kiss-worthiness" data-worthiness="${worthiness}">${escapeHtml$1(WORTHINESS[worthiness])}</span>` : ""}
     </div>
@@ -4000,11 +4380,33 @@ function renderRecommendation(recommendation) {
   ${recommendation.draftComment ? `<details class="prb-kiss-draft">
     <summary class="prb-kiss-draft-title">Draft comment</summary>
     <blockquote class="pr-helper-markdown">${renderMarkdown(recommendation.draftComment)}</blockquote>
-    ${renderMessageCopySource(recommendation.draftComment)}
   </details>` : ""}
+  ${renderCardActions(recommendation, context, Boolean(start))}
 </article>`;
 }
 /**
+* The card's actions: open the file, copy the draft, and the decision.
+*
+* The decision is two toggles rather than a menu, because both answers are equally ordinary and
+* the reader should see both before choosing. Pressing the pressed one again takes the decision
+* back, which is how a decision is reversed; nothing is deleted either way.
+*
+* Open file presses the card's own Start here row, so there is exactly one way a KISS location
+* opens. The draft comment copies the Markdown the model wrote, which is what a forge needs.
+*/
+function renderCardActions(recommendation, context, hasStart) {
+	const labels = DECISION_LABELS[context.audience];
+	const toggle = (decision) => `<button type="button" class="prb-kiss-decide" data-kiss-decide="${decision}" aria-pressed="${context.decision === decision}">${escapeHtml$1(labels[decision])}</button>`;
+	const openFile = hasStart ? "<button type=\"button\" class=\"prb-kiss-open-file\" data-kiss-open-primary>Open file</button>" : "";
+	const draft = recommendation.draftComment ? renderLabelledCopySource(recommendation.draftComment, "Copy draft comment") : "";
+	const decide = context.actions ? `<div class="prb-kiss-decide-group" role="group" aria-label="${escapeHtml$1(`Decision on ${recommendation.title}`)}">${toggle("accepted")}${toggle("declined")}</div>` : "";
+	if (!openFile && !draft && !decide) return "";
+	return `<div class="prb-kiss-rec-actions" data-kiss-actions>
+    <div class="prb-kiss-rec-actions-aside">${openFile}${draft}</div>
+    ${decide}
+  </div>`;
+}
+/**
 * What acting on it gains, on one line: the estimate first, then the gains.
 *
 * The estimate says it is one in words beside it, so a phrase like "~35–50 lines" cannot be taken
@@ -4927,7 +5329,8 @@ function kissViewOf(view) {
 		job: view.kissJob ?? null,
 		freshness: view.kissFreshness ?? null,
 		dismissedFreshnessSha: view.dismissedKissFreshnessSha,
-		previous: view.previousKissRun ?? null
+		previous: view.previousKissRun ?? null,
+		decisions: view.kissDecisions ?? []
 	};
 }
 function renderKissViews(view) {
@@ -5434,16 +5837,16 @@ function renderRunningRail(view) {
 * item that opens a page saying "nothing has run yet" is a promise the rail cannot keep.
 */
 function renderKissRail(view) {
-	const result = presentedKissRun(kissViewOf(view))?.result;
+	const counts = kissDecisionCounts(kissViewOf(view));
 	return railGroup({
 		id: "prb-rail-kiss",
 		title: "KISS",
 		icon: "kiss",
 		view: "kiss",
 		current: view.session.result === null && !showsProgress(view),
-		badge: result ? recommendationsBadge(result.recommendations.length) : null,
+		badge: counts ? recommendationsBadge(counts) : null,
 		collapses: "the KISS review",
-		body: result ? railLink("kissrecs", "recommendations", "Recommendations", recommendationsBadge(result.recommendations.length)) : ""
+		body: counts ? railLink("kissrecs", "recommendations", "Recommendations", recommendationsBadge(counts)) : ""
 	});
 }
 /** The one chevron both twisties draw. Rotated by CSS off `aria-expanded`, never by markup. */
@@ -5473,17 +5876,20 @@ function railGroup(group) {
   </div>`;
 }
 /**
-* How many recommendations a KISS run made, in KISS's own noun.
+* How many recommendations are still waiting on a decision, in KISS's own noun.
 *
-* A zero keeps its `0` rather than becoming a tick, for the reason `remainingBadge` gives about
-* findings and for one more: a recommendation is not work assigned to anybody, so there is nothing
-* here that can be finished, and a tick would claim somebody had dealt with all of them.
+* The same shape as the Issues and Questions badges: the open count, a tick once every one has been
+* decided, and the history in the label. "Decided" rather than "resolved", because accepting or
+* declining a suggestion fixes nothing in the code. A zero total keeps its `0`: a run that
+* recommended nothing has had nothing decided.
 */
-function recommendationsBadge(count) {
-	return {
-		text: String(count),
-		label: count === 1 ? "1 recommendation" : `${count} recommendations`
-	};
+function recommendationsBadge(counts) {
+	return remainingBadge({
+		total: counts.total,
+		open: counts.open,
+		done: counts.total - counts.open,
+		reviewerClosed: counts.total - counts.open
+	}, "recommendation", "decided");
 }
 /** Drawings are facts too, and the label is a sentence, so it has to be a sentence about one. */
 /** The map and the implementation diagrams together: everything behind the one rail item. */
@@ -5604,6 +6010,8 @@ function renderDisclosure(view) {
 		const findings = audit.relocatedFindings > 0 ? ` ${audit.relocatedFindings === 1 ? "One finding" : `${audit.relocatedFindings} findings`} pointed there; the ${audit.relocatedFindings === 1 ? "finding itself was" : "findings themselves were"} kept.` : "";
 		notes.push(removal + findings);
 	} else if (audit.relocatedFindings > 0) notes.push(`${audit.relocatedFindings} finding${audit.relocatedFindings === 1 ? "" : "s"} pointed at a file that is not in this change. The finding is kept; its location is not.`);
+	const motivation = motivationNote(audit.motivationCorrection);
+	if (motivation) notes.push(motivation);
 	if (notes.length === 0) return "";
 	return `<aside class="prb-disclosure">
   <strong>What the harness corrected</strong>
@@ -5611,6 +6019,21 @@ function renderDisclosure(view) {
 </aside>`;
 }
 /**
+* A refused motivation, described by what kind of claim it was and never by its wording: that
+* wording is exactly what the check decided the reader should not be shown.
+*
+* An unclear motive with no question is not mentioned. Withholding it costs the reader nothing,
+* since it said nothing they could act on.
+*/
+function motivationNote(correction) {
+	if (!correction || correction.reason === "no-question") return null;
+	return `The review gave ${{
+		"missing-quote": "that the author had stated why this change was made, without quoting where",
+		"unverified-quote": "that the author had stated why this change was made, quoting words that are not in the description",
+		"no-evidence": "a likely reason for this change, without evidence for it"
+	}[correction.reason]}, ${correction.outcome === "downgraded" ? "so the reason is shown as unclear, with its question to the author under Intent" : "so no reason is shown"}.`;
+}
+/**
 * Every changed file, split by whether the guide sends the reviewer there.
 *
 * The split used to be analysed / not analysed, which was the truth under a file ceiling and is a
@@ -7070,7 +7493,7 @@ function renderAuthorFilter(authors) {
 * the reviewer their place in Active. Hidden until the client has counted, so a browser with no
 * JavaScript gets every card and no control that does nothing.
 */
-function renderLoadMore(section) {
+function renderLoadMore$1(section) {
 	return `<button type="button" class="prb-index-more" data-load-more="${section}" hidden>Load more</button>`;
 }
 /**
@@ -7089,7 +7512,7 @@ function renderSection(section, groups, renderCards) {
     <div class="prb-cards" data-cards="${section}">
       ${renderCards(groups)}
     </div>
-    ${renderLoadMore(section)}
+    ${renderLoadMore$1(section)}
   </details>`;
 }
 /**
@@ -8177,7 +8600,8 @@ ${renderWorkspaceRail({
 <main class="prb-index prb-notifications-page">
   ${view.notifications.length === 0 ? `<p class="prb-index-empty">Nothing yet. When a review finishes or fails, it appears here.</p>` : `<ol class="prb-notifications" data-notifications>
     ${view.notifications.map((notification) => renderEntry(notification, view.gone?.has(notification.id) === true)).join("")}
-  </ol>`}
+  </ol>
+  ${renderLoadMore()}`}
   <p class="prb-index-note">Kept for thirty days, on this machine only.</p>
 </main>
 </div>
@@ -8199,6 +8623,14 @@ function renderReadAll(unread) {
   </div>`;
 }
 /**
+* Load more, which the browser shows once the list holds more than it is showing, as each section
+* of the Reviews page does. Hidden until the client has counted, so a browser with no JavaScript
+* gets every entry and no control that does nothing.
+*/
+function renderLoadMore() {
+	return `<button type="button" class="prb-index-more" data-notifications-more hidden>Load more</button>`;
+}
+/**
 * One event: what happened, then what to, then when. The whole row opens the review and so marks it
 * read, which is why a row has no Mark read of its own. An event, not a card: nothing about the
 * review's findings belongs here.
@@ -9540,6 +9972,7 @@ async function handle(req, res, options) {
 	}
 	if (action === "/job") return send(res, 200, jobReport(workspace));
 	if (action === "/retry") return handleRetry(res, workspace);
+	if (action === "/reanalyse") return handleReanalyse(req, res, workspace);
 	if (action === "/freshness") return handleFreshness(res, workspace, url.searchParams.get("quiet") === "1");
 	if (action === "/fetch") return handleFetchOwn(req, res, workspace);
 	if (action === "/refresh") return handleRefreshPr(res, workspace);
@@ -10434,7 +10867,8 @@ async function sendWorkspacePage(res, workspace) {
 		kissJob: kissRun ? loadJob(kissRun.jobId) : void 0,
 		kissFreshness,
 		dismissedKissFreshnessSha: workspace.dismissedKissFreshnessSha,
-		previousKissRun: previousKissResult(workspace)
+		previousKissRun: previousKissResult(workspace),
+		kissDecisions: workspace.kissDecisions ?? []
 	});
 	recordWorkspaceOpened(workspace);
 	if (freshness) record({
@@ -10578,7 +11012,7 @@ async function handleFreshness(res, workspace, quiet) {
 * an answer would be wrong.
 */
 async function kissFreshnessOrNull(workspace) {
-	const run = latestKissRun(workspace);
+	const run = presentedKissRunOf(workspace);
 	if (!run) return null;
 	try {
 		return await checkCodeFreshness(workspace, run.reviewedSha);
@@ -10697,6 +11131,27 @@ async function handleRetry(res, workspace) {
 	send(res, 200, { ok: true });
 }
 /**
+* Analyse this review again, at the commit it describes, with the agent that made it.
+*
+* The page's counterpart to `prreviewbuddy review --reanalyse`, and the same function behind it.
+* It answers once the new job exists, so the page can go and watch it; a refusal before that point
+* (a job still running, a review being deleted) comes back as one, and nothing has changed.
+*/
+async function handleReanalyse(req, res, workspace) {
+	if (req.method !== "POST") return send(res, 405, { error: "Analysing a review again needs a POST." });
+	const current = workspace.jobId ? loadJob(workspace.jobId) : null;
+	if (current && (!isTerminal(current) || isClaimed(current.id))) return send(res, 409, { error: "This review is still being made. Wait for it to finish before analysing it again." });
+	await new Promise((resolve) => {
+		track(reanalyseReview(workspace.id, void 0, () => {
+			send(res, 200, { ok: true });
+			resolve();
+		})).catch((error) => {
+			if (!res.headersSent) send(res, 409, { error: error instanceof Error ? error.message : String(error) });
+			resolve();
+		});
+	});
+}
+/**
 * The two audiences, as a closed list this file checks against rather than a string it forwards.
 *
 * The page sends this, so it is input. A run records who its report was written for, and a value
@@ -11019,6 +11474,7 @@ async function handlePrefs(req, res) {
 }
 async function handleState(req, res, workspace) {
 	const body = await readJson(req);
+	if (body !== null && "kissDecision" in body) return handleKissDecision(res, workspace, body.kissDecision);
 	const saved = STATE_FIELDS.some((field) => body !== null && field in body) ? mutateWorkspace(workspace.id, (current) => applyState(current, body)) : workspace;
 	if (!saved) return send(res, 404, { error: "No such review" });
 	send(res, 200, {
@@ -11028,6 +11484,51 @@ async function handleState(req, res, workspace) {
 		queued: readQueue().includes(saved.id)
 	});
 }
+var KISS_DECISION_VALUES = [
+	"accepted",
+	"declined",
+	"undecided"
+];
+function kissDecisionInput(value) {
+	const input = value;
+	if (typeof input?.runId !== "string" || input.runId === "") return null;
+	if (typeof input.recommendationId !== "string" || input.recommendationId === "") return null;
+	if (!KISS_DECISION_VALUES.includes(input.decision)) return null;
+	return {
+		runId: input.runId,
+		recommendationId: input.recommendationId,
+		decision: input.decision
+	};
+}
+var KISS_DECISION_REFUSED = {
+	"unknown-run": "This review has no completed KISS run with that id.",
+	"unknown-recommendation": "That KISS run has no recommendation with that id."
+};
+/**
+* One decision, written onto the review as it is now and answered with what was stored.
+*
+* Checked against a fresh read before writing, so a refused decision leaves the file alone, and
+* checked again inside the write, where the answer is final. The reply carries the stored decision
+* so the page confirms from the server rather than from what it asked for.
+*/
+function handleKissDecision(res, workspace, value) {
+	const input = kissDecisionInput(value);
+	if (!input) return send(res, 400, { error: "A KISS decision names a run, a recommendation, and accepted, declined or undecided." });
+	const before = loadWorkspace(workspace.id);
+	if (!before) return send(res, 404, { error: "No such review" });
+	const early = kissDecisionRefusal(before, input);
+	if (early) return send(res, 400, { error: KISS_DECISION_REFUSED[early] });
+	let refused = null;
+	const saved = mutateWorkspace(workspace.id, (current) => {
+		refused = decideKissRecommendation(current, input);
+	});
+	if (!saved) return send(res, 404, { error: "No such review" });
+	if (refused) return send(res, 400, { error: KISS_DECISION_REFUSED[refused] });
+	send(res, 200, {
+		ok: true,
+		decision: kissDecisionsOf(saved, input.runId).find((entry) => entry.recommendationId === input.recommendationId)?.decision ?? "undecided"
+	});
+}
 /** What `/state` can change. A body naming none of these writes nothing. */
 var STATE_FIELDS = [
 	"answeredQuestionIds",