prreviewbuddy 0.53.1 → 0.55.6

package/dist/{delete_review-DMJXD3bf.js → delete_review-DEvRanb6.js}

@@ -1643,7 +1643,8 @@ function completeReviewSession(session, result, context, options = {}) {
 			...session.metadata,
 			...context ? reviewFacts(result, context) : {
 				fileCoverage: void 0,
-				discussionStats: void 0
+				discussionStats: void 0,
+				authorDescription: void 0
 			},
 			commitSha: options.commitSha ?? session.metadata.commitSha,
 			durationMs: Math.max(0, now - session.metadata.generatedAt)
@@ -1664,7 +1665,8 @@ function reviewFacts(result, context) {
 			reviewedFiles: sectionedFiles(result, context),
 			totalChangedFiles: context.fileCoverage.totalChangedFiles
 		},
-		...context.prContext ? { discussionStats: countDiscussion(context) } : {}
+		...context.prContext ? { discussionStats: countDiscussion(context) } : {},
+		authorDescription: context.prContext?.pullRequest.body
 	};
 }
 /**
@@ -2237,6 +2239,7 @@ async function buildChangeSet(options) {
 				number: 0,
 				title: changeTitle(subjects, headRef),
 				body: subjects.length > 1 ? subjects.map((s) => `- ${s}`).join("\n") : null,
+				bodySource: "commit-subjects",
 				base: {
 					ref: base.display,
 					sha: mergeBase
@@ -6296,6 +6299,7 @@ function sanitisePullRequest(value) {
 	};
 	const title = typeof value.title === "string" ? value.title.trim() : "";
 	if (title) pr.title = title.slice(0, 200);
+	if (typeof value.body === "string" && value.body.trim()) pr.body = value.body;
 	const headSha = label(value.headSha);
 	if (headSha) pr.headSha = headSha;
 	const headRef = label(value.headRef);
@@ -6851,7 +6855,7 @@ function slug(repo) {
 * `baseRefOid` is a diff taken against the wrong *commit*, which is worse because the branch name
 * is right and everything reads as normal. A list nobody asserts is a list somebody tidies.
 */
-var PR_FIELDS = "number,url,title,headRefName,headRefOid,baseRefName,baseRefOid,changedFiles,author";
+var PR_FIELDS = "number,url,title,body,headRefName,headRefOid,baseRefName,baseRefOid,changedFiles,author";
 async function viewRequest(repo, reference, cwd, env) {
 	return await ghJson([
 		"pr",
@@ -6863,7 +6867,7 @@ async function viewRequest(repo, reference, cwd, env) {
 		PR_FIELDS
 	], cwd, env);
 }
-function text(value) {
+function text$1(value) {
 	return typeof value === "string" ? value.trim() : "";
 }
 /**
@@ -6884,30 +6888,31 @@ function fileUrlTemplate(prUrl) {
 * email address all live in `pr_context.ts` and in nothing else.
 */
 function identity(raw) {
-	const url = text(raw.url);
+	const url = text$1(raw.url);
 	const author = raw.author ?? null;
 	return {
 		provider: GITHUB_FORGE_ID,
 		number: typeof raw.number === "number" ? raw.number : 0,
 		url,
-		title: text(raw.title),
-		headSha: text(raw.headRefOid),
-		headRef: text(raw.headRefName),
-		baseRef: text(raw.baseRefName),
+		title: text$1(raw.title),
+		body: raw.body,
+		headSha: text$1(raw.headRefOid),
+		headRef: text$1(raw.headRefName),
+		baseRef: text$1(raw.baseRefName),
 		filesUrl: url ? `${url}/files` : "",
 		fileUrlTemplate: fileUrlTemplate(url),
 		author: author ? {
-			name: text(author.name),
-			handle: text(author.login)
+			name: text$1(author.name),
+			handle: text$1(author.login)
 		} : null
 	};
 }
 /**
 * The watcher's query: where the branch is, and whether the request is still open.
 *
-* Deliberately not `PR_FIELDS`. That list exists because a review needs all nine of them, and its
+* Deliberately not `PR_FIELDS`. That list exists because a review needs all ten of them, and its
 * docblock warns that trimming it fails silently rather than loudly. Sharing it here would put a
-* nine-field query on a five-minute timer across the whole working set, and would put the watcher
+* ten-field query on a five-minute timer across the whole working set, and would put the watcher
 * in a position to "optimise" a list that must never shrink.
 *
 * `state` rides on the same call rather than being a second one, which keeps the watcher's rate
@@ -6930,7 +6935,7 @@ var STATES = /* @__PURE__ */ new Map([
 * about a request GitHub declined to describe, once per cycle, indefinitely.
 */
 function readHeadSha(raw) {
-	const sha = text(raw?.headRefOid);
+	const sha = text$1(raw?.headRefOid);
 	if (!sha) return {
 		kind: "failed",
 		detail: "GitHub reported no head commit for this request."
@@ -6938,7 +6943,7 @@ function readHeadSha(raw) {
 	return {
 		kind: "head",
 		sha,
-		state: STATES.get(text(raw?.state)) ?? null
+		state: STATES.get(text$1(raw?.state)) ?? null
 	};
 }
 async function headOf(repo, number, env, cwd) {
@@ -6973,8 +6978,8 @@ async function resolve$1(repo, reference, env, cwd) {
 	} catch (error) {
 		throw new TargetError(`${reference} could not be looked up on GitHub: ${error.message}`);
 	}
-	const headRef = text(raw.headRefName);
-	const headSha = text(raw.headRefOid);
+	const headRef = text$1(raw.headRefName);
+	const headSha = text$1(raw.headRefOid);
 	if (!headRef || !headSha) throw new TargetError(`${reference} was found on GitHub but reported no branch and commit.`);
 	const resolved = {
 		reference,
@@ -6982,12 +6987,12 @@ async function resolve$1(repo, reference, env, cwd) {
 		headSha,
 		provider: GITHUB_FORGE_ID
 	};
-	const baseRef = text(raw.baseRefName);
+	const baseRef = text$1(raw.baseRefName);
 	if (baseRef) resolved.baseRef = baseRef;
-	const baseSha = text(raw.baseRefOid);
+	const baseSha = text$1(raw.baseRefOid);
 	if (baseSha) resolved.baseSha = baseSha;
 	if (typeof raw.changedFiles === "number") resolved.changedFiles = raw.changedFiles;
-	const url = text(raw.url);
+	const url = text$1(raw.url);
 	if (url) resolved.url = url;
 	if (typeof raw.number === "number") resolved.number = raw.number;
 	return resolved;
@@ -9081,7 +9086,7 @@ Follow-up Prompts:
 ${buildFollowUpPromptsSpec()}
 
 PR Title: ${raw.pullRequest.title}
-${raw.pullRequest.body ? `\nPR Description:\n${raw.pullRequest.body}\n` : ""}
+${raw.pullRequest.body ? `\n${raw.pullRequest.bodySource === "commit-subjects" ? "Commit subjects (there is no PR Description)" : "PR Description"}:\n${raw.pullRequest.body}\n` : ""}
 ${diff}`;
 	const overheadChars = assemble({
 		diff: "",
@@ -9390,10 +9395,688 @@ function normalizeSections(value) {
 	return sections;
 }
 //#endregion
+//#region ../../packages/review-harness/src/domain/utils/html.ts
+function escapeHtml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderInlineText(value) {
+	return escapeHtml(value).replace(/`([^`\n]+)`/g, "<code>$1</code>");
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/utils/code_block.ts
+var CODE_BLOCK_CLASS = "pr-helper-code-block";
+var CODE_COPY_CLASS = "pr-helper-code-copy";
+//#endregion
+//#region ../../packages/review-harness/src/domain/utils/markdown.ts
+var BLOCK_MARKER = "\0";
+var INLINE_MARKER = "
";
+var BLOCK_TOKEN = /\u0000(\d+)\u0000/g;
+var BLOCK_TOKEN_LINE = /^\u0000\d+\u0000$/;
+var INLINE_TOKEN = /\u0001(\d+)\u0001/g;
+var SAFE_HREF = /^(?:https?:\/\/|#)/i;
+function renderMarkdown(value, options = {}) {
+	const { text, blocks } = extractFencedBlocks(scanMarkdownLines(value.replace(/[\u0000\u0001]/g, ""), options));
+	return restoreFencedBlocks(renderBlocks(text), blocks);
+}
+/**
+* The fence character a line opens a code block with, or null when it opens none. Shared with the
+* Author's context preview, which must find the same code blocks this renderer does.
+*/
+function fenceOpening(line) {
+	return line.match(/^\s*(`{3,}|~{3,})\s*[\w+#.-]*\s*$/)?.[1][0] ?? null;
+}
+/** Whether a line closes a code block opened with `fence`: only a fence of the same character does. */
+function closesFence(line, fence) {
+	return new RegExp(`^\\s*${fence}{3,}\\s*$`).test(line);
+}
+var COMMENT_START_OR_CODE_SPAN = /`[^`\n]+`|<!--/g;
+function commentStart(line, from) {
+	COMMENT_START_OR_CODE_SPAN.lastIndex = from;
+	for (let match; match = COMMENT_START_OR_CODE_SPAN.exec(line);) if (match[0] === "<!--") return match.index;
+	return -1;
+}
+/**
+* Each line's part in a code block and, when comments are hidden, what of it is outside one.
+*
+* Code blocks and comments are read in one pass, in the order they open, as GitHub reads them: a
+* comment inside a code block is code, and a fence inside a comment is not a fence. The renderer and
+* the Author's context preview both read Markdown through this, so they agree on what is code and
+* what is hidden. A comment never closed is not a comment: its text stays, rather than hiding the
+* rest of what was said.
+*/
+function scanMarkdownLines(value, options = {}) {
+	const result = [];
+	let fence = null;
+	let comment = false;
+	let opener = null;
+	let offset = 0;
+	for (const raw of value.split("\n")) {
+		const lineStart = offset;
+		offset += raw.length + 1;
+		if (fence) {
+			const close = closesFence(raw, fence);
+			if (close) fence = null;
+			result.push({
+				raw,
+				visible: raw,
+				code: close ? "close" : "body"
+			});
+			continue;
+		}
+		if (!comment) {
+			fence = fenceOpening(raw);
+			if (fence) {
+				result.push({
+					raw,
+					visible: raw,
+					code: "open"
+				});
+				continue;
+			}
+		}
+		if (!options.hideHtmlComments) {
+			result.push({
+				raw,
+				visible: raw
+			});
+			continue;
+		}
+		const joining = comment ? opener : null;
+		let visible = "";
+		let pos = 0;
+		while (pos < raw.length) {
+			if (comment) {
+				const end = raw.indexOf("-->", pos);
+				if (end === -1) break;
+				pos = end + 3;
+				comment = false;
+				continue;
+			}
+			const start = commentStart(raw, pos);
+			if (start === -1 || value.indexOf("-->", lineStart + start + 4) === -1) {
+				visible += raw.slice(pos);
+				break;
+			}
+			visible += raw.slice(pos, start);
+			pos = start + 4;
+			comment = true;
+		}
+		if (joining) {
+			joining.visible += visible;
+			result.push({
+				raw,
+				visible: "",
+				absent: true
+			});
+			continue;
+		}
+		const line = {
+			raw,
+			visible
+		};
+		if (comment) opener = visible.trim() === "" ? null : line;
+		result.push(line);
+	}
+	return result;
+}
+function extractFencedBlocks(lines) {
+	const blocks = [];
+	const out = [];
+	let body = null;
+	for (const line of lines) {
+		if (line.absent) continue;
+		if (line.code === "open") body = [];
+		else if (line.code === "body") body.push(line.raw);
+		else if (line.code === "close") {
+			out.push(`${BLOCK_MARKER}${blocks.length}${BLOCK_MARKER}`);
+			blocks.push(body.join("\n"));
+			body = null;
+		} else out.push(line.visible);
+	}
+	if (body) {
+		out.push(`${BLOCK_MARKER}${blocks.length}${BLOCK_MARKER}`);
+		blocks.push(body.join("\n"));
+	}
+	return {
+		text: out.join("\n"),
+		blocks
+	};
+}
+function restoreFencedBlocks(html, blocks) {
+	return html.replace(BLOCK_TOKEN, (_match, index) => `<div class="${CODE_BLOCK_CLASS}"><pre><code>${escapeHtml(blocks[Number(index)])}</code></pre><button type="button" class="${CODE_COPY_CLASS}" aria-label="Copy code">Copy</button></div>`);
+}
+function renderBlocks(text) {
+	const out = [];
+	let paragraph = [];
+	let quote = [];
+	let list = null;
+	const flush = () => {
+		if (paragraph.length) out.push(`<p>${renderInline(paragraph.join(" "))}</p>`);
+		if (quote.length) out.push(`<blockquote>${renderInline(quote.join(" "))}</blockquote>`);
+		if (list) out.push(`<${list.tag}>${list.items.map((item) => `<li>${renderInline(item)}</li>`).join("")}</${list.tag}>`);
+		paragraph = [];
+		quote = [];
+		list = null;
+	};
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (!line) {
+			flush();
+			continue;
+		}
+		if (BLOCK_TOKEN_LINE.test(line)) {
+			flush();
+			out.push(line);
+			continue;
+		}
+		if (/^(?:-{3,}|\*{3,}|_{3,})$/.test(line)) {
+			flush();
+			out.push("<hr>");
+			continue;
+		}
+		const heading = line.match(/^(#{1,6})\s+(.+)$/);
+		if (heading) {
+			flush();
+			const level = Math.min(heading[1].length, 3) + 3;
+			out.push(`<h${level}>${renderInline(heading[2])}</h${level}>`);
+			continue;
+		}
+		const bullet = line.match(/^[-*+]\s+(.+)$/);
+		if (bullet) {
+			if (list?.tag !== "ul") {
+				flush();
+				list = {
+					tag: "ul",
+					items: []
+				};
+			}
+			list.items.push(bullet[1]);
+			continue;
+		}
+		const ordered = line.match(/^\d{1,9}[.)]\s+(.+)$/);
+		if (ordered) {
+			if (list?.tag !== "ol") {
+				flush();
+				list = {
+					tag: "ol",
+					items: []
+				};
+			}
+			list.items.push(ordered[1]);
+			continue;
+		}
+		const quoted = line.match(/^>\s?(.*)$/);
+		if (quoted) {
+			if (!quote.length) flush();
+			quote.push(quoted[1]);
+			continue;
+		}
+		if (list && list.items.length) {
+			list.items[list.items.length - 1] += ` ${line}`;
+			continue;
+		}
+		if (quote.length) {
+			quote[quote.length - 1] += ` ${line}`;
+			continue;
+		}
+		paragraph.push(line);
+	}
+	flush();
+	return out.join("");
+}
+function renderInline(value) {
+	const codeSpans = [];
+	return escapeHtml(value).replace(/`([^`\n]+)`/g, (_match, code) => {
+		codeSpans.push(code);
+		return `${INLINE_MARKER}${codeSpans.length - 1}${INLINE_MARKER}`;
+	}).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/ai_review/author_description.ts
+/**
+* Reading a pull request's description for whether it says anything, without ever changing it.
+*
+* Nothing here returns a copy to store, or a reworded one to show. The description is shown
+* verbatim, so a cleaned copy is only ever a means of asking a question of it: whether it says
+* anything, whether a quote is something the author said, and where its preview ends. The preview
+* itself is the author's own lines, cut short, never edited, less the HTML comments the full view
+* hides too.
+*/
+/**
+* Lines that are a pull request template's scaffolding when they stand alone.
+*
+* Matched against a whole line only, after its heading marker, bold and trailing colon are gone.
+* A heading that says something of its own, `## Fix startup crashes`, is not a label and survives.
+*/
+var TEMPLATE_LABELS = /* @__PURE__ */ new Set([
+	"description",
+	"summary",
+	"changes",
+	"what",
+	"why",
+	"how",
+	"context",
+	"motivation",
+	"motivation and context",
+	"what changed",
+	"what does this pr do",
+	"why is this needed",
+	"type of change",
+	"testing",
+	"tests",
+	"test plan",
+	"how to test",
+	"how has this been tested",
+	"screenshots",
+	"notes",
+	"checklist",
+	"related issues",
+	"related issue",
+	"links"
+]);
+var HEADING_MARKER = /^#{1,6}\s*/;
+var UNCHECKED_TASK = /^[-*+]\s+\[ \]/;
+var EMPTY_LIST_ITEM = /^(?:[-*+]|\d+[.)])\s*$/;
+function asLabel(line) {
+	return line.replace(HEADING_MARKER, "").replace(/^\*\*(.*)\*\*$/, "$1").replace(/^__(.*)__$/, "$1").replace(/:\s*$/, "").trim().toLowerCase();
+}
+/** One line, reduced to whatever in it is the author's own words. Empty when none are. */
+function substance(line) {
+	const trimmed = line.trim();
+	if (!trimmed || UNCHECKED_TASK.test(trimmed) || EMPTY_LIST_ITEM.test(trimmed)) return "";
+	if (TEMPLATE_LABELS.has(asLabel(trimmed))) return "";
+	return trimmed.replace(HEADING_MARKER, "");
+}
+/**
+* The parts of a description the author wrote, one line each, with the template's scaffolding gone.
+*
+* Only HTML comments, unticked checklist items, empty list items and bare template labels are
+* discounted. A ticked item is the author asserting something, so it stays.
+*/
+function authorText(description) {
+	if (!description) return "";
+	return visibleLines(description).map((line) => substance(line.visible)).filter((line) => line !== "").join("\n");
+}
+/**
+* Whether a description has anything in it beyond an unfilled template.
+*
+* Conservative by design: any line that survives counts, so a sparse description is shown rather
+* than hidden.
+*/
+function hasAuthorContent(description) {
+	return authorText(description) !== "";
+}
+var LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s/;
+var ATX_HEADING = /^#{1,6}(?:\s|$)/;
+/**
+* The description as the full view reads it, by the renderer's own scan, so the two always agree
+* on what is code and what is a hidden comment.
+*/
+function visibleLines(description) {
+	return scanMarkdownLines(description, { hideHtmlComments: true }).filter((line) => !line.absent);
+}
+/**
+* The description's Markdown blocks, with a code block kept whole and always a block of its own.
+*
+* Split where Markdown itself would end one: a blank line, a heading (always a block of its own)
+* and a list that starts straight after a paragraph. Descriptions are often written with no blank
+* lines at all, and on blank lines alone those would be one block. A line that is only a comment
+* ends a block like a blank one.
+*/
+function blocks(description) {
+	const result = [];
+	let current = [];
+	const end = () => {
+		if (current.length) result.push(current);
+		current = [];
+	};
+	for (const line of visibleLines(description)) if (line.code === "open") {
+		end();
+		current.push(line);
+	} else if (line.code === "body") current.push(line);
+	else if (line.code === "close") {
+		current.push(line);
+		end();
+	} else if (line.visible.trim() === "") end();
+	else if (ATX_HEADING.test(line.visible.trim())) {
+		end();
+		result.push([line]);
+	} else if (LIST_ITEM.test(line.visible) && current.length && !LIST_ITEM.test(current[0].visible)) {
+		end();
+		current.push(line);
+	} else current.push(line);
+	end();
+	return result;
+}
+var ELLIPSIS = "…";
+/**
+* Whether cutting a paragraph after `text` leaves valid Markdown: no code span, link or bold left
+* open. Approximate by design, and erring towards an earlier cut or none.
+*/
+function closesCleanly(text) {
+	if ((text.match(/`/g) ?? []).length % 2) return false;
+	if ((text.match(/\*\*/g) ?? []).length % 2) return false;
+	if ((text.replace(/\*\*/g, "").match(/\*/g) ?? []).length % 2) return false;
+	if ((text.match(/__/g) ?? []).length % 2) return false;
+	if ((text.match(/\[/g) ?? []).length !== (text.match(/\]/g) ?? []).length) return false;
+	if ((text.match(/\]\(/g) ?? []).length !== (text.match(/\]\([^)]*\)/g) ?? []).length) return false;
+	return true;
+}
+/**
+* A paragraph cut to its first sentences, or to a word boundary near the character limit, at a
+* point that leaves no Markdown open. Null when it fits whole.
+*/
+function boundParagraph(paragraph) {
+	const text = paragraph.trimEnd();
+	const cuts = [];
+	for (const match of text.matchAll(/\s+/g)) {
+		const at = match.index;
+		if (!closesCleanly(text.slice(0, at))) continue;
+		cuts.push({
+			at,
+			sentence: /[.!?]["')\]]?$/.test(text.slice(0, at))
+		});
+	}
+	const bySentence = cuts.filter((cut) => cut.sentence)[1];
+	if (text.length <= 400 && !bySentence) return null;
+	if (bySentence && bySentence.at <= 400) return `${text.slice(0, bySentence.at)} ${ELLIPSIS}`;
+	if (text.length <= 400) return null;
+	const within = cuts.filter((cut) => cut.at <= 400).pop() ?? cuts.find((cut) => cut.at > 400);
+	return within ? `${text.slice(0, within.at)} ${ELLIPSIS}` : null;
+}
+/** A list cut to its first items, each whole with any lines that continue it. Null when it fits. */
+function boundList(lines) {
+	const indent = (line) => line.length - line.trimStart().length;
+	const base = indent(lines[0]);
+	const starts = lines.flatMap((line, i) => LIST_ITEM.test(line) && indent(line) <= base ? [i] : []);
+	if (starts.length <= 3) return null;
+	return `${lines.slice(0, starts[3]).join("\n")}\n\n${ELLIPSIS}`;
+}
+/**
+* What the Overview shows of a description before the reader asks for all of it.
+*
+* The first block the author wrote decides what to show; the bounds decide how much of it. A
+* template's labels, comments and unticked items ahead of it are passed over, so "## Summary" opens
+* on the summary itself. A heading of the author's own is kept, with the block it introduces.
+* A paragraph is cut after its first sentences or near a character limit, a list after its first
+* items, and a long code block is left out; nothing is cut mid-word or left as open Markdown.
+*
+* Null when the whole description fits: there is nothing more to open.
+*/
+function authorPreview(description) {
+	if (!hasAuthorContent(description)) return null;
+	const all = blocks(description);
+	const shown = [];
+	let codeOmitted = false;
+	let cut = false;
+	let i = 0;
+	for (; i < all.length; i++) {
+		const lines = all[i];
+		const first = lines.findIndex((line) => substance(line.visible) !== "");
+		if (first === -1) continue;
+		const raw = lines.slice(first).map((line) => line.visible);
+		if (raw.length === 1 && ATX_HEADING.test(lines[first].visible.trim())) {
+			shown.push(raw[0]);
+			if (shown.length > 1) break;
+			continue;
+		}
+		if (lines[first].code === "open") {
+			if (lines.filter((line) => line.code === "body").length > 6) {
+				codeOmitted = true;
+				cut = true;
+			} else shown.push(raw.join("\n"));
+		} else {
+			const bounded = LIST_ITEM.test(raw[0]) ? boundList(raw) : boundParagraph(raw.join("\n"));
+			cut = bounded !== null;
+			shown.push(bounded ?? raw.join("\n"));
+		}
+		break;
+	}
+	const rest = all.slice(i + 1).flat().map((line) => line.visible);
+	if (!cut && !rest.some((line) => substance(line) !== "")) return null;
+	return {
+		markdown: shown.join("\n\n"),
+		codeOmitted
+	};
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/ai_review/motivation.ts
+var MOTIVATION_STATUSES = [
+	"stated",
+	"inferred",
+	"unclear"
+];
+var MOTIVATION_EVIDENCE_KINDS = [
+	"test",
+	"behaviour",
+	"issue",
+	"commit",
+	"docs",
+	"code"
+];
+/** Ours, not the model's: what an unsupported claim is replaced with when a question remains. */
+var UNESTABLISHED_MOTIVATION = "It isn't clear why this change is needed.";
+/** Stable, so "Mark answered" on it survives a reload like any other question's. */
+var INTENT_QUESTION_ID = "intent-motivation";
+/**
+* Fewer words than this cannot attribute a reason to anyone: "the cache" is in most descriptions
+* that mention a cache. An initial setting, not a measured one.
+*/
+var MIN_QUOTE_WORDS = 3;
+function text(value) {
+	if (typeof value !== "string") return void 0;
+	return value.trim() || void 0;
+}
+function normalizeEvidence(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((raw) => {
+		const item = raw ?? {};
+		const kind = item.kind;
+		const detail = text(item.detail);
+		if (!MOTIVATION_EVIDENCE_KINDS.includes(kind) || !detail) return [];
+		const file = text(item.file);
+		return [{
+			kind,
+			detail,
+			...file ? { file } : {}
+		}];
+	});
+}
+/** The model's `motivation`, if it is one at all. Absent, or the wrong shape, is no motivation. */
+function normalizeMotivation(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const item = value;
+	const status = item.status;
+	const summary = text(item.summary);
+	if (!MOTIVATION_STATUSES.includes(status) || !summary) return void 0;
+	const sourceQuote = text(item.sourceQuote);
+	const authorQuestion = text(item.authorQuestion);
+	return {
+		status,
+		summary,
+		evidence: normalizeEvidence(item.evidence),
+		...sourceQuote ? { sourceQuote } : {},
+		...authorQuestion ? { authorQuestion } : {}
+	};
+}
+/** Whitespace is the one thing a faithful quote may differ in: line wrapping is not wording. */
+function collapse(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+/**
+* Whether the author wrote this, in these words, in the description the analysis read.
+*
+* Searched in the author's own text only. A template's instructions are in the description too, and
+* "Explain why this change is needed" would otherwise pass as the author explaining why.
+*/
+function isAuthorQuote(quote, description) {
+	if (!quote) return false;
+	const needle = collapse(quote);
+	if (needle.split(" ").length < MIN_QUOTE_WORDS) return false;
+	return collapse(authorText(description)).includes(needle);
+}
+/**
+* The checks, applied to one candidate.
+*
+* Each status has one thing it cannot stand without: a verified quote, evidence, a question. The
+* fields that belong to the other statuses are dropped rather than carried, so a `stated` motive
+* cannot also show a guess and an `unclear` one cannot also show a quote.
+*
+* A claim that fails keeps none of its summary and becomes unclear, in our words, asking the
+* model's question or ours. Its evidence goes to the audit. An unclear motive that asked nothing
+* keeps its own summary, which claims nothing, and gets our question.
+*/
+function verifyMotivation(candidate, authorDescription) {
+	if (!candidate) return {};
+	const base = {
+		contractVersion: 1,
+		summary: candidate.summary
+	};
+	if (candidate.status === "stated" && isAuthorQuote(candidate.sourceQuote, authorDescription)) return { motivation: {
+		...base,
+		status: "stated",
+		sourceQuote: candidate.sourceQuote
+	} };
+	if (candidate.status === "inferred" && candidate.evidence.length > 0) return { motivation: {
+		...base,
+		status: "inferred",
+		evidence: candidate.evidence
+	} };
+	if (candidate.status === "unclear" && candidate.authorQuestion) return { motivation: {
+		...base,
+		status: "unclear",
+		authorQuestion: candidate.authorQuestion
+	} };
+	const reason = candidate.status === "stated" ? candidate.sourceQuote ? "unverified-quote" : "missing-quote" : candidate.status === "inferred" ? "no-evidence" : "no-question";
+	const correction = {
+		status: candidate.status,
+		summary: candidate.summary,
+		reason,
+		...rejectedQuote(candidate, reason),
+		...candidate.evidence.length > 0 ? { discardedEvidence: candidate.evidence } : {}
+	};
+	return {
+		motivation: {
+			contractVersion: 1,
+			status: "unclear",
+			summary: candidate.status === "unclear" ? candidate.summary : UNESTABLISHED_MOTIVATION,
+			authorQuestion: candidate.authorQuestion ?? "What problem does this change solve, or what goal does it serve?"
+		},
+		correction: {
+			...correction,
+			outcome: "downgraded"
+		}
+	};
+}
+function rejectedQuote(candidate, reason) {
+	if (reason !== "unverified-quote" || !candidate.sourceQuote) return {};
+	const quote = candidate.sourceQuote;
+	return quote.length > 500 ? {
+		rejectedQuote: quote.slice(0, 500),
+		rejectedQuoteTruncated: true
+	} : { rejectedQuote: quote };
+}
+/**
+* The one evidence-link policy, for both hosts.
+*
+* A changed file is a diff link and a real unchanged file a source link. A path the host can show
+* does not exist is removed and returned for the audit. A path the host cannot check keeps its
+* text and gets no state, so it is never presented as a link the reader can trust.
+*/
+function placeEvidenceFiles(motivation, paths) {
+	if (!motivation?.evidence) return {
+		motivation,
+		removed: []
+	};
+	const removed = [];
+	const evidence = motivation.evidence.map(({ fileState: _ignored, ...item }) => {
+		if (!item.file) return item;
+		if (paths.changed(item.file)) return {
+			...item,
+			fileState: "changed"
+		};
+		if (!paths.exists) return item;
+		if (paths.exists(item.file)) return {
+			...item,
+			fileState: "unchanged"
+		};
+		removed.push(item.file);
+		const { file: _gone, ...rest } = item;
+		return rest;
+	});
+	return {
+		motivation: {
+			...motivation,
+			evidence
+		},
+		removed
+	};
+}
+/** Two questions are the same question when they differ only in case, spacing or end punctuation. */
+function sameQuestion(a, b) {
+	const key = (value) => collapse(value).toLowerCase().replace(/[?.!\s]+$/, "");
+	return key(a) === key(b);
+}
+/**
+* File an unclear motive's question with the rest, as the one Intent question.
+*
+* A question the model already asked in the same words becomes the Intent question rather than a
+* second copy, so the reader meets it once. It takes the stable id either way: a model's ids are
+* new on every analysis, and "Mark answered" is stored by id. Telling two differently worded
+* questions apart is judgement and is left to the prompt.
+*/
+function withIntentQuestion(questions, motivation) {
+	if (motivation?.status !== "unclear" || !motivation.authorQuestion) return questions;
+	const asked = motivation.authorQuestion;
+	const existing = questions.findIndex((q) => sameQuestion(q.question, asked));
+	const taken = new Set(questions.filter((_, index) => index !== existing).map((q) => q.id));
+	let id = INTENT_QUESTION_ID;
+	for (let n = 2; taken.has(id); n += 1) id = `${INTENT_QUESTION_ID}-${n}`;
+	if (existing >= 0) return questions.map((q, index) => index === existing ? {
+		...q,
+		id,
+		category: "intent"
+	} : q);
+	return [...questions, {
+		id,
+		question: asked,
+		category: "intent"
+	}];
+}
+/** The candidate checked and, when it ends unclear, its question filed. */
+function applyMotivation(result, candidate, authorDescription) {
+	const { motivation, correction } = verifyMotivation(candidate, authorDescription);
+	const { motivation: _unverified, ...rest } = result;
+	return {
+		result: {
+			...rest,
+			...motivation ? { motivation } : {},
+			questions: withIntentQuestion(result.questions, motivation)
+		},
+		...correction ? { correction } : {}
+	};
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/ai_review/summary_guidance.ts
+/**
+* What the "summary" field is for, as both the first analysis and a reconciliation ask for it.
+*
+* One string so the two prompts cannot drift. It renders as "What's changing" on the Overview,
+* between "Why this change?" and the risk card, so it says neither why nor how good.
+*/
+var SUMMARY_GUIDANCE = `"summary": WHAT the change does, for a reviewer about to read it. Roughly 80-120 words, and fewer for a small change. Name the parts that change and what each now does. Do not explain why the change exists, and do not judge whether it is correct or safe: other fields carry both.`;
+//#endregion
 //#region ../../packages/review-harness/src/domain/ai_review/pipeline.ts
 var STRUCTURED_OUTPUT_INSTRUCTIONS = `In addition to the review principles above, first understand the implementation, then respond with a single JSON object (no markdown, no surrounding text) matching exactly this shape:
 {
   "summary": string,
+  "motivation"?: {
+    "status": "stated" | "inferred" | "unclear",
+    "summary": string,
+    "sourceQuote"?: string,
+    "evidence"?: [{ "kind": "test" | "behaviour" | "issue" | "commit" | "docs" | "code", "detail": string, "file"?: string }],
+    "authorQuestion"?: string
+  },
   "overallRisk": "low" | "medium" | "high",
   "sections": [{
     "id": string,
@@ -9416,6 +10099,12 @@ var STRUCTURED_OUTPUT_INSTRUCTIONS = `In addition to the review principles above
 }
 
 Field guidance:
+- ${SUMMARY_GUIDANCE}
+- "motivation": WHY this change exists, which is a different question from what it does ("summary" covers that). Name the problem being solved or the goal being served, never the mechanics: "adds a retry loop" is what the code does, "the sync job was failing on transient network errors" is why. Weigh sources in this order: the PR Description and any issue it links; then tests and user-visible behaviour; then commit messages and docs; then the implementation itself. Choose exactly one "status":
+  - "stated": the author's own words in the PR Description say why. "sourceQuote" is REQUIRED: a short passage (one sentence or less, at least three words) copied character for character from the PR Description, which says why. Copy it exactly as written, keeping backticks, punctuation, hyphenation and spelling; never paraphrase, shorten words, join two sentences or correct a typo. Only the PR Description counts as the author stating it: a reason that appears only in commit messages, review comments, or an issue the description merely links to is not "stated" (use "inferred" and cite it as evidence). Never use "stated" when the description only restates what the code does. If the change itself also shows the reason, include it as "evidence".
+  - "inferred": nothing states it, but the change gives real evidence of it. "evidence" is REQUIRED and non-empty: each entry names what points to the motive, such as a test asserting the fixed behaviour, an issue reference, or a commit message, with "file" set to the changed file it is in where there is one. Never infer a motive from names alone (a branch, a function or a file being called "fix-x" is not evidence). Word the summary as a likely reading, not a fact: "This appears to..." rather than "This fixes...".
+  - "unclear": neither the description nor the change establishes why, AND knowing why would change how this change should be reviewed (for example, whether a behaviour change is intended). "authorQuestion" is REQUIRED: one focused question for the author that would settle it. Do not also ask that question, in any wording, in "questions".
+  If the motive is unclear and knowing it would not change the review, omit "motivation" entirely. Do not add it just to fill the field.
 - "sections": partition the pull request into logical implementation sections (e.g. "Authentication", "Database Migration", "API Changes"), grouped by responsibility/purpose, not by directory or file type. Identify a sensible number of sections — most PRs will naturally have between 2 and 8, but do not invent or split sections simply to reach a target; let the actual structure of the change decide the count. For each section: "oneLineSummary" is a single sentence; "purpose" explains why this part of the change exists; "whyReview" is a short note aimed at the reviewer about what to focus on; "checklist" is a short list of things to verify (review prompts, not findings — never report bugs, code smells, or recommendations inside a section, that's what "issues" is for). Assign "order" starting at 1 in the sequence a reviewer should walk through the sections (narrative order, not file count or alphabetical). "reviewWeight" is a relative time-budget indicator from 1 (skim) to 5 (spend the most time here), independent of "priority" and "reviewAttention". Set "recommendedStartingPoint": true on exactly one section — whichever one a reviewer should actually read first for the rest of the review to make sense. This is not necessarily the section with "order": 1 (e.g. a foundational database migration might naturally come first while a reviewer should still start with the authentication logic it enables). Set it to false on every other section. Every file in the diff must appear in exactly one section — the sections are the only file list the developer sees, so an omitted file is a file they never review. Files with no natural home (lockfiles, dependency bumps, generated output, formatting-only changes) go in a single final catch-all section — title it for what it contains, e.g. "Supporting changes" or "Dependency and config updates" — with "priority": "supporting" and "reviewAttention": "low". Never drop a file just because it is uninteresting; say that it is uninteresting instead.
 - "files" inside a section: "path" is the file path exactly as it appears in the diff. "focus" is REQUIRED on every file — if a file is worth listing in a section, it is worth explaining why the reviewer has been brought to it. Keep it to one or two short sentences, roughly 20-35 words, never more than two sentences. Make it actionable rather than descriptive: name the role this specific file plays in the section, then say what the reviewer should verify there. For example: "Introduces the new association reader. Verify it preserves the existing lookup behaviour." / "Implements the retry path. Confirm error handling matches the existing gateway implementation." / "Registers the generated behaviour with Active Record. Check the hook fires for subclasses too." Do not restate the section's summary or checklist, do not use bullet points, and do not write filler such as "Review this file carefully."
 - "file" on an issue or question: prefer anchoring a finding to the changed file responsible for the concern, named exactly as it appears in the diff. If an unchanged repository file is necessary context and no changed-file location accurately represents the finding, it may be referenced as an unchanged related file. Never list an unchanged file in a section's "files" array, and never describe an unchanged file as part of the pull request.
@@ -9426,7 +10115,7 @@ Field guidance:
 - "existingDiscussion" on an issue: set this only when a thread in the PR DISCUSSION CONTEXT block already raises this same concern, and you have independently confirmed from the diff that it still applies. "threadId" must be copied verbatim from that thread's [T_...] marker — never invent an id, never guess, and omit the field entirely if no thread matches. Set "relation" to "same" when the thread already makes this exact point, or "related" when it discusses this area without covering the finding — a reviewer acts differently on "someone said this already" than on "someone was looking near here". Still write the issue normally; this field only records that the point was raised before, so the reviewer is not shown it as a fresh discovery. Do not use it to pad the review with issues you would otherwise have left out.
 - "confidence" on an issue: how sure you are the issue is real, on the same high/medium/low scale as a question's "importance". This is a separate axis from "severity", which is how much it would matter if real — a critical issue you are unsure about and a nit you are certain of are different things to act on, so do not let one field stand in for the other. Use LOW when you are reasoning from a diff excerpt without the surrounding code, and say what would confirm it in the description. Omit the field rather than guessing a middle value.
 - "questions": each one is a genuine open item the reviewer needs answered before they can sign off, not a rhetorical prompt. "importance" is how much attention it deserves, on the same high/medium/low scale as a section's "reviewAttention" (e.g. a question about a possibly-exposed secret is "high"; a naming preference is "low"). "whyThisMatters" is 1-2 sentences explaining the concrete consequence of the question going unanswered — not a restatement of the question itself.
-- Every section's "oneLineSummary"/"purpose"/"whyReview", each file's "focus", and each question's "whyThisMatters" are rendered as plain prose paragraphs, not markdown — write them as normal sentences. Do not use "- " bullet points or numbered lists inside these fields; if you're enumerating several points, join them into flowing sentences instead. Inline code/identifiers may use backtick spans (e.g. \`ErrorSeverity\`) — those do render.
+- Every section's "oneLineSummary"/"purpose"/"whyReview", each file's "focus", each question's "whyThisMatters", and every text field inside "motivation" are rendered as plain prose paragraphs, not markdown — write them as normal sentences. Do not use "- " bullet points or numbered lists inside these fields; if you're enumerating several points, join them into flowing sentences instead. Inline code/identifiers may use backtick spans (e.g. \`ErrorSeverity\`) — those do render.
 - "summary", "recommendation" and each "nextSteps" entry are rendered as Markdown, so use it where it carries meaning: backtick spans for identifiers, a fenced block for a snippet worth reading as code, a short bullet list where the content genuinely is a list. Prose is still the default and these fields are still short. Do not add headings, and do not turn a paragraph into bullets to look organised.
 
 This JSON object is the only output the developer sees. The free-text sections above (Overview, Guide, Issues, Questions, Follow-up Prompts) are for your own internal reasoning — do not copy them verbatim into any JSON field.`;
@@ -9444,7 +10133,22 @@ function buildStructuredReviewPrompt(pr, options = {}) {
 		partialFiles: partialFiles ?? []
 	};
 }
-function parseReviewResult(raw) {
+/**
+* A reply, parsed, with the motivation checked against the description the analysis read.
+*
+* The check happens here rather than after, so there is no parsed result anywhere whose motivation
+* has not been through it. `correction` says what the check refused, for a caller with an audit to
+* put it in.
+*/
+function parseReviewResponse(raw, authorDescription) {
+	const { result, motivation } = parseUnchecked(raw);
+	const applied = applyMotivation(result, motivation, authorDescription);
+	return {
+		result: applied.result,
+		...applied.correction ? { motivationCorrection: applied.correction } : {}
+	};
+}
+function parseUnchecked(raw) {
 	const jsonText = extractJsonText(raw);
 	let parsed;
 	try {
@@ -9458,14 +10162,17 @@ function parseReviewResult(raw) {
 	const recommendation = asString(obj.recommendation);
 	if (!summary && !recommendation && !Array.isArray(obj.issues) && !Array.isArray(obj.nextSteps)) throw new Error("The AI returned valid JSON, but not in the expected analysis shape (missing summary/recommendation/issues/nextSteps). This usually means the model ignored the requested schema.");
 	return {
-		schemaVersion: 1,
-		summary,
-		overallRisk: RISKS.includes(obj.overallRisk) ? obj.overallRisk : "medium",
-		sections: normalizeSections(obj.sections),
-		issues: normalizeIssues(obj.issues),
-		questions: normalizeQuestions(obj.questions),
-		recommendation,
-		nextSteps: asStringArray(obj.nextSteps)
+		result: {
+			schemaVersion: 1,
+			summary,
+			overallRisk: RISKS.includes(obj.overallRisk) ? obj.overallRisk : "medium",
+			sections: normalizeSections(obj.sections),
+			issues: normalizeIssues(obj.issues),
+			questions: normalizeQuestions(obj.questions),
+			recommendation,
+			nextSteps: asStringArray(obj.nextSteps)
+		},
+		motivation: normalizeMotivation(obj.motivation)
 	};
 }
 var EXPLAIN_SIMPLY_PROMPT = "Explain this review in plain English for someone unfamiliar with this codebase. Avoid jargon, use a simple everyday analogy if it helps, and keep it skippable — a couple of short paragraphs is enough.";
@@ -9836,6 +10543,7 @@ async function assemble(changeSet, budget, lens, prContext) {
 		...changeSet.data,
 		files: selection.inline,
 		changedFileCount: allFiles.length,
+		...prContext ? { pullRequest: pullRequestFor(changeSet.data.pullRequest, prContext) } : {},
 		discussion: prContext?.discussion
 	}, selection.inline.length, null);
 	const shared = {
@@ -9865,6 +10573,21 @@ async function assemble(changeSet, budget, lens, prContext) {
 	};
 }
 /**
+* The change's pull request, as the prompt should present it once a forge request is attached.
+*
+* With no description, the commit subjects stay: they are still the best account of the change
+* there is, and still labelled as commits rather than as the author's words.
+*/
+function pullRequestFor(local, prContext) {
+	const body = prContext.pullRequest.body;
+	if (!body) return local;
+	const { bodySource: _commits, ...rest } = local;
+	return {
+		...rest,
+		body
+	};
+}
+/**
 * The inline patches as one blob, for grounding the assistant.
 *
 * No ceiling of its own. `selectInlineDiffs` already bounded this, and a second constant guarding
@@ -10199,13 +10922,14 @@ async function existingPaths(repoPath, paths, commit = "HEAD") {
 * from the change set, and it costs one git call, or none when the guide cites nothing off-diff.
 */
 async function validateGuide(rawResponse, context) {
-	const result = parseReviewResult(rawResponse);
+	const { result, motivationCorrection } = parseReviewResponse(rawResponse, context.prContext?.pullRequest.body);
 	const changedPaths = new Set(context.changeSet.data.files.map((file) => file.name));
 	const sectionIds = new Set(result.sections.map((section) => section.id));
 	const findings = [...result.issues, ...result.questions];
 	const offDiff = /* @__PURE__ */ new Set();
 	for (const section of result.sections) for (const file of section.files) if (!changedPaths.has(file.path)) offDiff.add(file.path);
 	for (const finding of findings) if (finding.file && !changedPaths.has(finding.file)) offDiff.add(finding.file);
+	for (const evidence of result.motivation?.evidence ?? []) if (evidence.file && !changedPaths.has(evidence.file)) offDiff.add(evidence.file);
 	const realButUnchanged = await existingPaths(context.changeSet.repoPath, [...offDiff]);
 	const unknownPaths = /* @__PURE__ */ new Set();
 	const sectioned = /* @__PURE__ */ new Set();
@@ -10246,6 +10970,13 @@ async function validateGuide(rawResponse, context) {
 			orphanedSectionRefs += 1;
 		}
 	}
+	const placed = placeEvidenceFiles(result.motivation, {
+		changed: (path) => changedPaths.has(path),
+		exists: (path) => realButUnchanged.has(path)
+	});
+	if (placed.motivation) result.motivation = placed.motivation;
+	for (const path of placed.removed) unknownPaths.add(path);
+	for (const evidence of placed.motivation?.evidence ?? []) if (evidence.fileState === "unchanged" && evidence.file) noteReferenced(evidence.file);
 	const attribution = attributeIssuesToDiscussion(result, context.processed.discussion);
 	return {
 		result: attribution.result,
@@ -10253,7 +10984,8 @@ async function validateGuide(rawResponse, context) {
 			unknownPaths: [...unknownPaths].sort(),
 			relocatedFindings,
 			orphanedSectionRefs,
-			rejectedAttributions: attribution.rejected
+			rejectedAttributions: attribution.rejected,
+			...motivationCorrection ? { motivationCorrection } : {}
 		},
 		referencedFiles: [...referenced].map(([path, sections]) => ({
 			path,
@@ -11760,7 +12492,7 @@ function buildReconciliationInstructions(input, options = {}) {
    The completeness rule applies here too: one entry per numbered question, and "still-open" with a note rather than an omission when you are unsure. Do not manufacture an answer out of intent you cannot see. A question about why something was done the way it was is often not answerable from code at all, and "still-open" is the correct answer to it.`] : [],
 		`Read the changed code above as a reviewer, not only as an auditor of the numbered list. These commits have not been reviewed by anyone. Report every genuinely NEW problem you find in them in "newIssues", whether or not it relates to anything on the list — code written to fix a finding is exactly where a regression gets introduced, and reassessing the list and stopping there is half the job. Do NOT repeat a previous finding here: if it still stands, that is what "still-open" is for.`,
 		`If the new changes introduce an area the earlier analysis had no section for, add it to "newSections". Otherwise return an empty array. Do not restate or restructure the earlier analysis's existing sections.`,
-		`Give a fresh "summary", "overallRisk", "recommendation" and "nextSteps" for the pull request AS IT NOW STANDS, taking both the earlier findings that survive and the new changes into account. Unlike a partial review, you have been shown the earlier analysis in full and are expected to revise its verdict where the new changes justify it.`
+		`Give a fresh "summary", "overallRisk", "recommendation" and "nextSteps" for the pull request AS IT NOW STANDS, taking both the earlier findings that survive and the new changes into account. Unlike a partial review, you have been shown the earlier analysis in full and are expected to revise its verdict where the new changes justify it. ${SUMMARY_GUIDANCE}`
 	].map((task, index) => `${index + 1}. ${task}`).join("\n");
 	return `You are RECONCILING an earlier analysis of this pull request against the changes pushed since that analysis was made.
 
@@ -12317,6 +13049,7 @@ function movable(fetched) {
 	};
 	copy("headSha");
 	copy("title");
+	copy("body");
 	copy("filesUrl");
 	copy("fileUrlTemplate");
 	copy("author");
@@ -12526,6 +13259,7 @@ async function reconcile(workspace, runners, reviewedSha, remote, conversationOk
 	const result = {
 		schemaVersion: 1,
 		summary: parsed.summary || previous.summary,
+		...previous.motivation ? { motivation: previous.motivation } : {},
 		overallRisk: parsed.overallRisk ?? previous.overallRisk,
 		recommendation: parsed.recommendation || previous.recommendation,
 		nextSteps: parsed.nextSteps.length ? parsed.nextSteps : previous.nextSteps,
@@ -13084,4 +13818,4 @@ function lineageIds(id) {
 	return [.../* @__PURE__ */ new Set([id, ...lineage.map((review) => review.id)])];
 }
 //#endregion
-export { compactQueue as $, agentById as $n, latestKissRun as $t, createPrState as A, isIssueOutstanding as An, followedBranch as At, toneOf as B, resolveTarget as Bn, phasesFor as Bt, readEvents as C, sectionOf as Cn, claimRequestUrl as Ct, announceJob as D, queueStamp as Dn, fillFileUrlTemplate as Dt, telemetryUploadConsent as E, queueRemove as En, remoteHost as Et, markAllRead as F, processDiscussion as Fn, isTerminal as Ft, extractJsonText as G, resolveModel as Gn, isClaimed as Gt, withUsageRecorded as H, isCommitReview as Hn, purposeOf as Ht, markRead as I, recommendationsOf as In, loadJob as It, readMarker as J, writeAgentPreference as Jn, groupByLineage as Jt, ReviewBeingDeletedError as K, clearAgentPreference as Kn, decideKissRecommendation as Kt, pruneNotifications as L, describeAuthorship as Ln, saveJob as Lt, eventName as M, issuesOutstanding as Mn, allJobs as Mt, headline as N, questionsOutstanding as Nn, endedAt as Nt, branchOf as O, readQueue as On, checkCodeFreshness as Ot, listNotifications as P, reviewerDispositions as Pn, fail as Pt, activateQueued as Q, DEFAULT_AGENT_ID as Qn, kissDecisionsOf as Qt, readNotification as R, WITHHELD_REASON as Rn, PHASES as Rt, startJob as S, parseLifecycle as Sn, writePortPreference as St, recordTelemetryUploadConsent as T, queueAddMany as Tn, forgeFor as Tt, EXPLAIN_SIMPLY_PROMPT as U, git as Un, clearClaim as Ut, unreadCount as V, displayRef as Vn, progressSteps as Vt, asString as W, resolveAgent as Wn, driverGone as Wt, modelHelpLines as X, STORE_ROOT as Xn, indexReviewGroups as Xt, removeWorktree as Y, CONFIG_PATH as Yn, indexKeptIds as Yt, relativeTime as Z, AGENT_IDS as Zn, kissDecisionRefusal as Zt, agentEnvOf as _, isLifecycle as _n, MAX_WORKSPACE_PORT as _t, wasBlocked as a, positionInLineage as an, ensureServer as at, reanalyseReview as b, lifecyclePill as bn, resolveWorkspacePort as bt, RefreshUnavailableError as c, recentWorkspaces as cn, serverEntryExists as ct, refreshPrContext as d, summarise as dn, workspaceUrl as dt, lineageKeyFor as en, agentFor as er, queueForReview as et, isUnchanged as f, touchWorkspace as fn, writeServerRecord as ft, runningJobs as g, activityLabel as gn, DEFAULT_WORKSPACE_PORT as gt, liveUpdateFor as h, LIFECYCLES as hn, feedbackUrl as ht, liveJobsFor as i, mutateWorkspace as in, clearServerRecord as it, createPrUpdate as j, isQuestionOutstanding as jn, reviewedShaOf as jt, subjectOf as k, doneVerb as kn, checkReview as kt, mergeUpdateInto as l, reviewedCommit as ln, spawnServer as lt, UpdateAlreadyRunningError as m, workspaceStamps as mn, PACKAGE_NAME as mt, deleteReview as n, loadWorkspace as nn, AgentCancelledError as nr, readIndexToken as nt, discardJob as o, presentedKissRunOf as on, readServerRecord as ot, askCheckout as p, workspaceRevision as pn, BUILD_VERSION as pt, MANAGED_ROOT as q, readAgentPreference as qn, followedRefName as qt, lineageIds as r, matchingWorkspaceIds as rn, AgentUnavailableError as rr, bootstrapUrl as rt, FETCH_TIMEOUT_MS as s, previousKissResult as sn, reviewsUrl as st, deleteLineage as t, lineagePosition as tn, detectAgents as tr, settleQueue as tt, updateReview as u, reviewedRepositories as un, stopServer as ut, recordKissRun as v, lifecycleAction as vn, MIN_WORKSPACE_PORT as vt, record as w, queueAdd as wn, forgeResolver as wt, runJob as x, offersLifecycle as xn, statedWorkspacePort as xt, startKissJob as y, lifecycleChip as yn, parseWorkspacePort as yt, removeNotification as z, kissOutcome as zn, isLiveJob as zt };
+export { extractJsonText as $, resolveModel as $n, isClaimed as $t, createPrState as A, parseLifecycle as An, writePortPreference as At, toneOf as B, issuesOutstanding as Bn, allJobs as Bt, readEvents as C, LIFECYCLES as Cn, feedbackUrl as Ct, announceJob as D, lifecycleChip as Dn, parseWorkspacePort as Dt, telemetryUploadConsent as E, lifecycleAction as En, MIN_WORKSPACE_PORT as Et, markAllRead as F, queueStamp as Fn, fillFileUrlTemplate as Ft, authorPreview as G, describeAuthorship as Gn, saveJob as Gt, withUsageRecorded as H, reviewerDispositions as Hn, fail as Ht, markRead as I, readQueue as In, checkCodeFreshness as It, CODE_BLOCK_CLASS as J, resolveTarget as Jn, phasesFor as Jt, hasAuthorContent as K, WITHHELD_REASON as Kn, PHASES as Kt, pruneNotifications as L, doneVerb as Ln, checkReview as Lt, eventName as M, queueAdd as Mn, forgeResolver as Mt, headline as N, queueAddMany as Nn, forgeFor as Nt, branchOf as O, lifecyclePill as On, resolveWorkspacePort as Ot, listNotifications as P, queueRemove as Pn, remoteHost as Pt, asString as Q, resolveAgent as Qn, driverGone as Qt, readNotification as R, isIssueOutstanding as Rn, followedBranch as Rt, startJob as S, workspaceStamps as Sn, PACKAGE_NAME as St, recordTelemetryUploadConsent as T, isLifecycle as Tn, MAX_WORKSPACE_PORT as Tt, EXPLAIN_SIMPLY_PROMPT as U, processDiscussion as Un, isTerminal as Ut, unreadCount as V, questionsOutstanding as Vn, endedAt as Vt, UNESTABLISHED_MOTIVATION as W, recommendationsOf as Wn, loadJob as Wt, escapeHtml as X, isCommitReview as Xn, purposeOf as Xt, CODE_COPY_CLASS as Y, displayRef as Yn, progressSteps as Yt, renderInlineText as Z, git as Zn, clearClaim as Zt, agentEnvOf as _, reviewedCommit as _n, spawnServer as _t, wasBlocked as a, kissDecisionRefusal as an, AGENT_IDS as ar, relativeTime as at, reanalyseReview as b, touchWorkspace as bn, writeServerRecord as bt, RefreshUnavailableError as c, lineageKeyFor as cn, agentFor as cr, queueForReview as ct, refreshPrContext as d, matchingWorkspaceIds as dn, AgentUnavailableError as dr, bootstrapUrl as dt, decideKissRecommendation as en, clearAgentPreference as er, ReviewBeingDeletedError as et, isUnchanged as f, mutateWorkspace as fn, clearServerRecord as ft, runningJobs as g, recentWorkspaces as gn, serverEntryExists as gt, liveUpdateFor as h, previousKissResult as hn, reviewsUrl as ht, liveJobsFor as i, indexReviewGroups as in, STORE_ROOT as ir, modelHelpLines as it, createPrUpdate as j, sectionOf as jn, claimRequestUrl as jt, subjectOf as k, offersLifecycle as kn, statedWorkspacePort as kt, mergeUpdateInto as l, lineagePosition as ln, detectAgents as lr, settleQueue as lt, UpdateAlreadyRunningError as m, presentedKissRunOf as mn, readServerRecord as mt, deleteReview as n, groupByLineage as nn, writeAgentPreference as nr, readMarker as nt, discardJob as o, kissDecisionsOf as on, DEFAULT_AGENT_ID as or, activateQueued as ot, askCheckout as p, positionInLineage as pn, ensureServer as pt, renderMarkdown as q, kissOutcome as qn, isLiveJob as qt, lineageIds as r, indexKeptIds as rn, CONFIG_PATH as rr, removeWorktree as rt, FETCH_TIMEOUT_MS as s, latestKissRun as sn, agentById as sr, compactQueue as st, deleteLineage as t, followedRefName as tn, readAgentPreference as tr, MANAGED_ROOT as tt, updateReview as u, loadWorkspace as un, AgentCancelledError as ur, readIndexToken as ut, recordKissRun as v, reviewedRepositories as vn, stopServer as vt, record as w, activityLabel as wn, DEFAULT_WORKSPACE_PORT as wt, runJob as x, workspaceRevision as xn, BUILD_VERSION as xt, startKissJob as y, summarise as yn, workspaceUrl as yt, removeNotification as z, isQuestionOutstanding as zn, reviewedShaOf as zt };