prreviewbuddy 0.75.0 → 0.76.9

package/dist/{delete_review-BWKGCqwI.js → delete_review-BX3lu5Q7.js}

@@ -3304,7 +3304,7 @@ async function ensureCommitByPlainFetch(root, sha) {
 	if (await hasCommit(root, sha)) return;
 	throw new TargetError(`The commit this request is on (${sha.slice(0, 7)}) is not in this repository, even after fetching.`);
 }
-function where(source, remote) {
+function where$1(source, remote) {
 	const repo = `${source.repo.host}/${source.repo.owner}/${source.repo.repo}`;
 	return remote ? `${remote} (${repo})` : source.url;
 }
@@ -3314,7 +3314,7 @@ function gitSaid(error) {
 }
 function couldNotFetch(source, remote, error) {
 	const said = gitSaid(error);
-	return `Could not fetch the head commit for pull request #${source.number} from ${where(source, remote)}.` + (said ? ` Git said: ${said}` : "");
+	return `Could not fetch the head commit for pull request #${source.number} from ${where$1(source, remote)}.` + (said ? ` Git said: ${said}` : "");
 }
 async function wrongCommit(root, source, internal, expected) {
 	const found = await refSha(root, internal);
@@ -4751,8 +4751,6 @@ function emptyProcessedDiscussion() {
 		}
 	};
 }
-//#endregion
-//#region ../../packages/review-harness/src/domain/discussion/discussion_processor.ts
 var DEFAULTS = {
 	excludeBots: true,
 	maxCommentsPerThread: 6,
@@ -5177,7 +5175,16 @@ function tally(items, outstanding, byReviewer) {
 	};
 }
 function issuesOutstanding(issues, dispositions) {
-	return tally(issues, (issue) => isIssueOutstanding(issue, dispositions), (issue) => issue.reconciliationStatus !== "resolved" && dispositions.isDismissed(issue));
+	const counts = tally(issues, (issue) => isIssueOutstanding(issue, dispositions), (issue) => issue.reconciliationStatus !== "resolved" && dispositions.isDismissed(issue));
+	const byConversation = issues.filter(resolvedByConversation).length;
+	return byConversation > 0 ? {
+		...counts,
+		byConversation
+	} : counts;
+}
+/** A finding whose resolution, as it stands, rests on the pull request conversation rather than a commit. */
+function resolvedByConversation(issue) {
+	return issue.reconciliationStatus === "resolved" && issue.statusHistory?.at(-1)?.basis === "conversation";
 }
 function questionsOutstanding(questions, answered) {
 	return tally(questions, (question) => isQuestionOutstanding(question, answered), (question) => question.reconciliationStatus !== "answered" && answered.has(question.id));
@@ -6756,12 +6763,12 @@ var UPDATE_PHASES = {
 		done: "Re-read pull request conversation"
 	},
 	context: {
-		doing: "Preparing a checkout of the new commits",
-		done: "Prepared a checkout of the new commits"
+		doing: "Preparing a checkout of the latest commit",
+		done: "Prepared a checkout of the latest commit"
 	},
 	analysing: {
-		doing: "Reassessing the review against the new commits",
-		done: "Reassessed the review against the new commits"
+		doing: "Reassessing the review against what changed",
+		done: "Reassessed the review against what changed"
 	},
 	done: {
 		doing: "Finishing",
@@ -7055,14 +7062,19 @@ function sanitisePrContextReporting(value) {
 		if (thread) discussions.push(thread);
 		if (discussions.length === 400) break;
 	}
+	const coverage = sanitiseCoverage(value.coverage);
+	if (coverage && discussions.length === 400) coverage.threads = "capped";
 	return {
 		discussion: {
 			schemaVersion: 1,
 			discussions,
-			decisions: Array.isArray(value.decisions) ? value.decisions.map(sanitiseDecision).filter((d) => d !== null) : [],
+			decisions: sanitiseDecisions(value.decisions),
+			...Array.isArray(value.reviews) ? { reviews: sanitiseDecisions(value.reviews) } : {},
 			overallDecision: DECISIONS$1.includes(value.overallDecision) ? value.overallDecision : null,
 			truncated: value.truncated === true || discussions.length === 400,
-			fetchedAt: Date.now()
+			...coverage ? { coverage } : {},
+			fetchedAt: Date.now(),
+			...typeof value.requestedAt === "number" && Number.isFinite(value.requestedAt) ? { requestedAt: value.requestedAt } : {}
 		},
 		droppedThreads: offered - discussions.length
 	};
@@ -7095,6 +7107,7 @@ function sanitiseComment(value) {
 	const id = label(value.id);
 	const body = typeof value.body === "string" ? value.body.trim() : "";
 	if (!id || !body) return null;
+	const editedAt = timestamp(value.editedAt);
 	return {
 		id,
 		author: label(value.author) || "unknown",
@@ -7102,7 +7115,8 @@ function sanitiseComment(value) {
 		body,
 		timestamp: timestamp(value.timestamp),
 		replyToId: label(value.replyToId) || null,
-		url: href$1(value.url)
+		url: href$1(value.url),
+		...editedAt ? { editedAt } : {}
 	};
 }
 function sanitiseLocation(value) {
@@ -7117,11 +7131,16 @@ function sanitiseLocation(value) {
 		commitSha: label(value.commitSha) || null
 	};
 }
+function sanitiseDecisions(value) {
+	return Array.isArray(value) ? value.map(sanitiseDecision).filter((d) => d !== null) : [];
+}
 function sanitiseDecision(value) {
 	if (!isRecord$1(value)) return null;
 	const reviewer = label(value.reviewer);
 	if (!reviewer || !VERDICTS$1.includes(value.verdict)) return null;
+	const id = label(value.id);
 	return {
+		...id ? { id } : {},
 		reviewer,
 		reviewerIsBot: value.reviewerIsBot === true,
 		verdict: value.verdict,
@@ -7129,6 +7148,24 @@ function sanitiseDecision(value) {
 		timestamp: timestamp(value.timestamp)
 	};
 }
+var COVERAGES = ["complete", "capped"];
+/**
+* All three collections or nothing. A coverage record with a collection missing or misspelled says
+* nothing provable about that collection, and "complete" is the one value that must be proved.
+*/
+function sanitiseCoverage(value) {
+	if (!isRecord$1(value)) return null;
+	const read = (field) => COVERAGES.includes(field) ? field : null;
+	const threads = read(value.threads);
+	const conversation = read(value.conversation);
+	const reviews = read(value.reviews);
+	if (!threads || !conversation || !reviews) return null;
+	return {
+		threads,
+		conversation,
+		reviews
+	};
+}
 function sanitisePullRequest(value) {
 	if (!isRecord$1(value)) return null;
 	const number = count$1(value.number);
@@ -7376,7 +7413,14 @@ async function ghGraphql(query, variables, cwd, env) {
 		"-F",
 		`number=${variables.number}`
 	];
-	if (variables.threadCursor !== void 0) args.push("-f", `threadCursor=${variables.threadCursor}`);
+	for (const name of [
+		"threadCursor",
+		"commentCursor",
+		"reviewCursor"
+	]) {
+		const cursor = variables[name];
+		if (cursor !== void 0) args.push("-f", `${name}=${cursor}`);
+	}
 	const body = await ghJson(args, cwd, env);
 	if (typeof body !== "object" || body === null || !("data" in body)) throw new GhError("The GitHub API answered without a data payload.");
 	return body.data;
@@ -7433,6 +7477,7 @@ function mapComment(raw) {
 	const body = asString(node.body);
 	if (!id || body === null) return null;
 	const { login, isBot } = readAuthor(node.author);
+	const editedAt = asString(node.lastEditedAt);
 	return {
 		id,
 		author: login,
@@ -7440,11 +7485,36 @@ function mapComment(raw) {
 		body,
 		timestamp: asString(node.createdAt) ?? "",
 		replyToId: asString(path(node, "replyTo", "id")),
-		url: asString(node.url) ?? ""
+		url: asString(node.url) ?? "",
+		...editedAt ? { editedAt } : {}
 	};
 }
-function mapComments(connection) {
-	return nodesOf(connection).map(mapComment).filter((c) => c !== null);
+function mapComments(nodes) {
+	return nodes.map(mapComment).filter((c) => c !== null);
+}
+/**
+* A thread's comment nodes in order: the opening comment, then the most recent replies, each once.
+*
+* Two connections because one cannot say "the first and the last few". When a thread is short the
+* two overlap completely, so the merge is by id. The single `comments` connection is what payloads
+* recorded before the split carry, and it is read the same way.
+*/
+function threadCommentNodes(node) {
+	const merged = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const raw of [
+		...nodesOf(node.opening),
+		...nodesOf(node.recent),
+		...nodesOf(node.comments)
+	]) {
+		const id = asString(asRecord(raw)?.id);
+		if (id !== null) {
+			if (seen.has(id)) continue;
+			seen.add(id);
+		}
+		merged.push(raw);
+	}
+	return merged;
 }
 function mapLocation(node, comments) {
 	const file = asString(node.path);
@@ -7480,10 +7550,10 @@ function mapThread(raw) {
 	if (!node) return null;
 	const id = asString(node.id);
 	if (!id) return null;
-	const rawComments = nodesOf(node.comments);
-	const comments = mapComments(node.comments);
+	const rawComments = threadCommentNodes(node);
+	const comments = mapComments(rawComments);
 	if (comments.length === 0) return null;
-	const totalCount = asNumber(path(node, "comments", "totalCount")) ?? comments.length;
+	const totalCount = asNumber(path(node, "opening", "totalCount")) ?? asNumber(path(node, "comments", "totalCount")) ?? comments.length;
 	return {
 		id,
 		type: "review_thread",
@@ -7529,7 +7599,9 @@ function mapReview(raw) {
 	const verdict = state ? VERDICTS[state] : void 0;
 	if (!verdict) return null;
 	const { login, isBot } = readAuthor(node.author);
+	const id = asString(node.id);
 	return {
+		...id ? { id } : {},
 		reviewer: login,
 		reviewerIsBot: isBot,
 		verdict,
@@ -7537,15 +7609,73 @@ function mapReview(raw) {
 		timestamp: asString(node.submittedAt) ?? ""
 	};
 }
+/**
+* The standing verdict per reviewer: their newest submission. What `latestReviews` used to answer,
+* derived from the full history instead so both views come from one fetch and cannot disagree.
+* Ordered by each reviewer's first appearance, which keeps the rendered list stable across fetches.
+*/
+function latestPerReviewer(reviews) {
+	const latest = /* @__PURE__ */ new Map();
+	for (const review of reviews) {
+		const held = latest.get(review.reviewer);
+		if (!held || review.timestamp >= held.timestamp) latest.set(review.reviewer, review);
+	}
+	return [...latest.values()];
+}
+/**
+* Whether the last page of a collection says it ended there.
+*
+* Complete only on the provider's own word. A collection with no `pageInfo` at all, which is every
+* payload recorded before it was requested, proves nothing and is therefore capped: coverage is
+* what lets a delta call a missing comment deleted, so guessing "complete" would manufacture
+* deletions out of a page boundary.
+*/
+function coverageOf(lastConnection, more) {
+	const info = asRecord(lastConnection?.pageInfo);
+	if (!info || typeof info[more] !== "boolean") return {
+		coverage: "capped",
+		provenCapped: false
+	};
+	return info[more] ? {
+		coverage: "capped",
+		provenCapped: true
+	} : {
+		coverage: "complete",
+		provenCapped: false
+	};
+}
 function mapDiscussionResponseReporting(pages, options) {
 	const discussions = [];
-	const decisions = [];
+	const legacyDecisions = [];
+	let sawLatest = false;
+	const reviews = [];
 	const seenThreadIds = /* @__PURE__ */ new Set();
+	const seenReviewIds = /* @__PURE__ */ new Set();
+	let sawReviews = false;
+	let lastThreads = null;
+	let lastConversation = null;
+	let lastReviews = null;
 	let refused = 0;
 	let overallDecision = null;
 	for (const page of pages) {
 		const pr = path(page, "repository", "pullRequest");
 		if (!asRecord(pr)) continue;
+		lastThreads = asRecord(path(pr, "reviewThreads")) ?? lastThreads;
+		lastConversation = asRecord(path(pr, "comments")) ?? lastConversation;
+		const reviewConnection = asRecord(path(pr, "reviews"));
+		if (reviewConnection) {
+			sawReviews = true;
+			lastReviews = reviewConnection;
+			for (const raw of nodesOf(reviewConnection)) {
+				const review = mapReview(raw);
+				if (!review) continue;
+				if (review.id) {
+					if (seenReviewIds.has(review.id)) continue;
+					seenReviewIds.add(review.id);
+				}
+				reviews.push(review);
+			}
+		}
 		for (const raw of nodesOf(path(pr, "reviewThreads"))) {
 			const thread = mapThread(raw);
 			if (!thread) refused++;
@@ -7562,25 +7692,46 @@ function mapDiscussionResponseReporting(pages, options) {
 				discussions.push(conversation);
 			}
 		}
+		if (asRecord(path(pr, "latestReviews"))) sawLatest = true;
 		for (const raw of nodesOf(path(pr, "latestReviews"))) {
 			const review = mapReview(raw);
-			if (review) decisions.push(review);
+			if (review) legacyDecisions.push(review);
 		}
 		const decision = asString(path(pr, "reviewDecision"));
 		if (decision && DECISIONS[decision]) overallDecision = DECISIONS[decision];
 	}
+	const threads = coverageOf(lastThreads, "hasNextPage");
+	const conversation = coverageOf(lastConversation, "hasPreviousPage");
+	const reviewCoverage = coverageOf(lastReviews, "hasPreviousPage");
+	reviews.sort((a, b) => a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0);
+	const coverage = {
+		threads: options.truncated ? "capped" : threads.coverage,
+		conversation: conversation.coverage,
+		reviews: sawReviews ? reviewCoverage.coverage : "capped"
+	};
 	return {
 		discussion: {
 			schemaVersion: 1,
 			discussions,
-			decisions,
+			decisions: sawLatest || !sawReviews ? legacyDecisions : latestPerReviewer(reviews),
+			...sawReviews ? { reviews } : {},
 			overallDecision,
-			truncated: options.truncated,
-			fetchedAt: options.fetchedAt
+			truncated: options.truncated || threads.provenCapped || conversation.provenCapped || reviewCoverage.provenCapped,
+			coverage,
+			fetchedAt: options.fetchedAt,
+			...options.requestedAt !== void 0 ? { requestedAt: options.requestedAt } : {}
 		},
 		refused
 	};
 }
+var RECENT_COMMENTS_PER_THREAD = 9;
+var COMMENT_FIELDS = `
+          id
+          body
+          createdAt
+          lastEditedAt
+          url
+          author { login __typename }`;
 var THREAD_FIELDS = `
   pageInfo { hasNextPage endCursor }
   nodes {
@@ -7591,20 +7742,41 @@ var THREAD_FIELDS = `
     line
     originalLine
     diffSide
-    comments(first: 10) {
+    opening: comments(first: 1) {
       totalCount
-      nodes {
-        id
-        body
-        createdAt
-        url
-        author { login __typename }
+      nodes {${COMMENT_FIELDS}
+        replyTo { id }
+        originalCommit { oid }
+      }
+    }
+    recent: comments(last: ${RECENT_COMMENTS_PER_THREAD}) {
+      nodes {${COMMENT_FIELDS}
         replyTo { id }
         originalCommit { oid }
       }
     }
   }`;
-/** First page: threads plus the connections that never need paginating. */
+var CONVERSATION_FIELDS = `
+        pageInfo { hasPreviousPage startCursor }
+        nodes {${COMMENT_FIELDS}
+        }`;
+var REVIEW_NODE = `
+          id
+          state
+          body
+          submittedAt
+          author { login __typename }`;
+var REVIEW_FIELDS = `
+        pageInfo { hasPreviousPage startCursor }
+        nodes {${REVIEW_NODE}
+        }`;
+/**
+* First page: one page of each collection.
+*
+* Its variables are unchanged, so the extension's transport, which walks threads alone, keeps
+* sending this document as it always has. The mapper reads each collection's `pageInfo`, so a
+* collection nobody walked further is recorded as capped rather than presented as whole.
+*/
 var PR_DISCUSSION_QUERY = `
 query PRDiscussion($owner: String!, $repo: String!, $number: Int!, $threadCursor: String) {
   repository(owner: $owner, name: $repo) {
@@ -7613,29 +7785,20 @@ query PRDiscussion($owner: String!, $repo: String!, $number: Int!, $threadCursor
       reviewThreads(first: 50, after: $threadCursor) {${THREAD_FIELDS}
       }
       latestReviews(first: 50) {
-        nodes {
-          state
-          body
-          submittedAt
-          author { login __typename }
+        nodes {${REVIEW_NODE}
         }
       }
-      comments(last: 50) {
-        nodes {
-          id
-          body
-          createdAt
-          url
-          author { login __typename }
-        }
+      reviews(last: 50) {${REVIEW_FIELDS}
+      }
+      comments(last: 50) {${CONVERSATION_FIELDS}
       }
     }
   }
   rateLimit { cost remaining }
 }`;
 /**
-* Continuation pages: threads only. Re-requesting reviews and conversation on every page would
-* burn ~100 nodes per page re-fetching data we already hold.
+* Continuation pages, one document per collection. Re-requesting the others on every page would
+* burn nodes re-fetching data we already hold.
 */
 var PR_DISCUSSION_THREADS_QUERY = `
 query PRDiscussionThreads($owner: String!, $repo: String!, $number: Int!, $threadCursor: String!) {
@@ -7647,6 +7810,35 @@ query PRDiscussionThreads($owner: String!, $repo: String!, $number: Int!, $threa
   }
   rateLimit { cost remaining }
 }`;
+/** Older conversation comments, walking backwards from the page before. */
+var PR_DISCUSSION_COMMENTS_QUERY = `
+query PRDiscussionComments($owner: String!, $repo: String!, $number: Int!, $commentCursor: String!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      comments(last: 50, before: $commentCursor) {${CONVERSATION_FIELDS}
+      }
+    }
+  }
+  rateLimit { cost remaining }
+}`;
+/**
+* Earlier review submissions, walking backwards from the newest like conversation comments do.
+*
+* Newest first because a cap that binds should cost the oldest history, never the reviews a delta
+* exists to find. Measured, not supposed: a busy public request ran to more than 150 reviews and
+* the forward walk stopped before its latest ones. The standing verdicts do not depend on this
+* walk: `latestReviews` above answers them whole, one per reviewer.
+*/
+var PR_DISCUSSION_REVIEWS_QUERY = `
+query PRDiscussionReviews($owner: String!, $repo: String!, $number: Int!, $reviewCursor: String!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviews(last: 50, before: $reviewCursor) {${REVIEW_FIELDS}
+      }
+    }
+  }
+  rateLimit { cost remaining }
+}`;
 //#endregion
 //#region ../../packages/review-harness/src/forge/adapters/github/github_adapter.ts
 var GITHUB_FORGE_ID = "github";
@@ -7911,30 +8103,54 @@ async function findRequest(repo, branch, sha, env, cwd) {
 	return null;
 }
 async function fetchConversation$1(repo, number, env, cwd) {
-	const availability = await ghAvailable(cwd, env, repo.host);
-	if (!availability.ok) return {
-		kind: availability.kind,
-		cli: availability.cli
-	};
+	const requestedAt = Date.now();
 	try {
-		const pages = [];
-		let cursor;
-		let truncated = false;
-		for (let page = 0; page < 3; page++) {
-			const data = await ghGraphql(cursor === void 0 ? PR_DISCUSSION_QUERY : PR_DISCUSSION_THREADS_QUERY, {
-				owner: repo.owner,
-				repo: repo.repo,
-				number,
-				...cursor === void 0 ? {} : { threadCursor: cursor }
-			}, cwd, env);
-			pages.push(data);
-			const next = nextCursor(data);
-			if (!next) break;
-			cursor = next;
-			if (page === 2) truncated = true;
-		}
-		return assemble$1(pages, truncated, await viewRequest(repo, String(number), cwd, env));
+		const base = {
+			owner: repo.owner,
+			repo: repo.repo,
+			number
+		};
+		const identity = viewRequest(repo, String(number), cwd, env);
+		identity.catch(() => void 0);
+		const first = await ghGraphql(PR_DISCUSSION_QUERY, base, cwd, env);
+		const walk = async (connection, query, cursorName, maxPages) => {
+			const pages = [];
+			let cursor = nextCursor(first, connection);
+			for (let page = 1; cursor && page < maxPages; page++) {
+				const data = await ghGraphql(query, {
+					...base,
+					[cursorName]: cursor
+				}, cwd, env);
+				pages.push(data);
+				cursor = nextCursor(data, connection);
+			}
+			return pages;
+		};
+		const [threads, comments, reviews] = await Promise.all([
+			walk("reviewThreads", PR_DISCUSSION_THREADS_QUERY, "threadCursor", 3),
+			walk("comments", PR_DISCUSSION_COMMENTS_QUERY, "commentCursor", 3),
+			walk("reviews", PR_DISCUSSION_REVIEWS_QUERY, "reviewCursor", 3)
+		]);
+		return assemble$1([
+			first,
+			...threads,
+			...comments,
+			...reviews
+		], false, await identity, requestedAt);
 	} catch (error) {
+		let availability;
+		try {
+			availability = await ghAvailable(cwd, env, repo.host);
+		} catch (missing) {
+			return {
+				kind: "failed",
+				detail: missing.message
+			};
+		}
+		if (!availability.ok) return {
+			kind: availability.kind,
+			cli: availability.cli
+		};
 		return {
 			kind: "failed",
 			detail: error.message
@@ -7948,10 +8164,11 @@ async function fetchConversation$1(repo, number, env, cwd) {
 * a real repository once; this is where every decision about what the reviewer ends up seeing is
 * actually made, and it should be reachable from a unit test.
 */
-function assemble$1(pages, truncated, raw) {
+function assemble$1(pages, truncated, raw, requestedAt) {
 	const mapped = mapDiscussionResponseReporting(pages, {
 		truncated,
-		fetchedAt: Date.now()
+		fetchedAt: Date.now(),
+		...requestedAt !== void 0 ? { requestedAt } : {}
 	});
 	const sanitised = sanitisePrContextReporting(mapped.discussion);
 	const pullRequest = sanitisePullRequest(identity(raw));
@@ -7975,9 +8192,19 @@ function assemble$1(pages, truncated, raw) {
 		}
 	};
 }
-function nextCursor(data) {
+/**
+* Where a collection's walk goes next, or undefined when the page says it was the last.
+*
+* Conversation comments and reviews walk backwards from the newest, so theirs is the previous
+* page's start; threads walk forwards.
+*/
+function nextCursor(data, connection) {
 	const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-	const info = record(record(record(record(record(data)?.repository)?.pullRequest)?.reviewThreads)?.pageInfo);
+	const info = record(record(record(record(record(data)?.repository)?.pullRequest)?.[connection])?.pageInfo);
+	if (connection === "comments" || connection === "reviews") {
+		if (info?.hasPreviousPage !== true) return void 0;
+		return typeof info.startCursor === "string" ? info.startCursor : void 0;
+	}
 	if (info?.hasNextPage !== true) return void 0;
 	return typeof info.endCursor === "string" ? info.endCursor : void 0;
 }
@@ -9371,12 +9598,52 @@ function renderSummary(summary) {
 	if (summary.architecturalRationale.length > 0) parts.push(`## Architectural rationale\nExplained by the author in the discussion:\n${summary.architecturalRationale.map((r) => `- ${r}`).join("\n")}`);
 	return parts;
 }
+/**
+* Modest by design: this rides along on every assistant message, unlike the review block which
+* is paid for once per review.
+*/
+var CHAT_DISCUSSION_BUDGET_CHARS = 8e3;
+/**
+* The chat-tab counterpart to buildDiscussionSection. Same thread rendering, different framing:
+* the assistant is being asked *about* the conversation ("has knjoroge's point been addressed?"),
+* not asked to review code while avoiding repetition. It also carries no severity or budget
+* apparatus, since chat has no findings to attribute.
+*/
+function buildChatDiscussionSection(pd, budgetChars = CHAT_DISCUSSION_BUDGET_CHARS) {
+	if (pd.all.length === 0 && pd.decisions.length === 0) return "";
+	const header = `EXISTING PR DISCUSSION
+This is the human conversation already on the pull request. Use it to answer questions about what reviewers raised and whether points were addressed. It records what people said, not what is true — if asked whether a concern is resolved, say what the thread shows and whether it was marked resolved, and be clear about which of those you are relying on.
+You are seeing the review and this discussion side by side, which does not tell you which informed which. Do not claim that a review finding came from, was prompted by, or reflects a thread unless that finding explicitly carries an "already raised by" note. Without one, say the two relate to the same area — not that one caused the other.`;
+	const parts = [header];
+	let spent = header.length;
+	const buckets = [
+		["Unresolved review threads", [...pd.unresolved, ...pd.unresolvedOutdated]],
+		["Resolved review threads", pd.resolved],
+		["PR conversation", pd.conversation]
+	];
+	for (const [heading, threads] of buckets) {
+		const body = [];
+		for (const thread of threads) {
+			const text = renderThread(thread);
+			if (spent + text.length > budgetChars) break;
+			spent += text.length;
+			body.push(text);
+		}
+		if (body.length > 0) parts.push(`## ${heading}\n${body.join("\n\n")}`);
+	}
+	if (pd.decisions.length > 0) {
+		const lines = pd.decisions.map((d) => `- @${d.reviewer}: ${VERDICT_LABELS[d.verdict]}${d.body ? ` — "${d.body.replace(/\s+/g, " ").trim()}"` : ""}`);
+		parts.push(`## Review decisions\n${lines.join("\n")}`);
+	}
+	return parts.join("\n\n");
+}
 function buildDiscussionSection(pd, budgetChars, options = {}) {
 	const empty = {
 		text: "",
 		overflow: false,
 		includedThreads: 0,
-		omittedThreads: 0
+		omittedThreads: 0,
+		includedThreadIds: []
 	};
 	if (!(pd.all.length > 0 || pd.decisions.length > 0 || pd.overallDecision !== null) || budgetChars <= 0) return empty;
 	const perFile = options.maxThreadsPerFile ?? DEFAULT_MAX_THREADS_PER_FILE;
@@ -9411,6 +9678,7 @@ function buildDiscussionSection(pd, budgetChars, options = {}) {
 	let omitted = 0;
 	const perFileNotes = [];
 	const rendered = [];
+	const includedThreadIds = [];
 	if (options.summary) {
 		rendered.push(...renderSummary(options.summary));
 		included = options.summary.unresolved.length;
@@ -9428,6 +9696,7 @@ function buildDiscussionSection(pd, budgetChars, options = {}) {
 			}
 			spent += text.length;
 			body.push(text);
+			includedThreadIds.push(thread.id);
 			included++;
 		}
 		if (body.length > 0) rendered.push(`${bucket.heading}\n${body.join("\n\n")}`);
@@ -9450,7 +9719,8 @@ function buildDiscussionSection(pd, budgetChars, options = {}) {
 		].filter((part) => part !== "").join("\n\n"),
 		overflow: omitted > 0,
 		includedThreads: included,
-		omittedThreads: omitted
+		omittedThreads: omitted,
+		includedThreadIds
 	};
 }
 //#endregion
@@ -9866,6 +10136,7 @@ ${diff}`;
 			breakdown: buildPromptBudget(sections).breakdown
 		},
 		discussionOverflow: discussion.overflow,
+		discussionThreadIds: discussion.includedThreadIds,
 		partiallyReadFiles: partialFiles.length,
 		partialFiles
 	};
@@ -11159,237 +11430,988 @@ function applyMotivation(result, candidate, authorDescription) {
 */
 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,
-    "order": number,
-    "title": string,
-    "oneLineSummary": string,
-    "purpose": string,
-    "files": [{ "path": string, "focus": string }],
-    "whyReview": string,
-    "checklist": string[],
-    "priority": "implementation" | "supporting" | "tests" | "documentation",
-    "reviewAttention": "high" | "medium" | "low",
-    "reviewWeight": 1 | 2 | 3 | 4 | 5,
-    "recommendedStartingPoint": boolean
-  }],
-  "issues": [{ "id": string, "severity": "critical" | "major" | "minor" | "nit", "title": string, "description": string, "file"?: string, "line"?: number, "sectionId"?: string, "confidence"?: "high" | "medium" | "low", "existingDiscussion"?: { "threadId": string, "relation": "same" | "related" } }],
-  "questions": [{ "id": string, "question": string, "importance"?: "high" | "medium" | "low", "whyThisMatters"?: string, "file"?: string, "sectionId"?: string }],
-  "recommendation": string,
-  "nextSteps": string[]
+//#region ../../packages/review-harness/src/domain/discussion/discussion_delta.ts
+/**
+* Which collections of a snapshot were capped. A snapshot from before coverage was recorded can
+* say only whether its thread list was truncated, so that is all it is taken to say.
+*/
+function partialOf(current) {
+	if (!current.coverage) return current.truncated ? ["threads"] : [];
+	return [
+		"threads",
+		"conversation",
+		"reviews"
+	].filter((collection) => current.coverage?.[collection] === "capped");
 }
-
-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.
-- "sectionId" on issues/questions: reference the "id" of the section that item belongs to. Omit it rather than guessing if an item doesn't clearly belong to one section.
-- "recommendation": a 1-2 sentence merge verdict aimed at the developer (e.g. "Approve" or "Request changes — fix the unhandled rejection before merging"). Do not just restate the risk level, and do not copy Guide section content verbatim into this field.
-- "nextSteps": concrete actions to take before merging (specific tests to run, files to double-check), not a restatement of the Guide.
-- "issues": report only issues worth the reviewer's attention — do not invent issues to fill out the array, and do not omit significant issues. Let the count reflect the actual PR (a trivial PR may have zero or one issue; a large or risky PR may have several).
-- "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", 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.`;
-function buildStructuredReviewPrompt(pr, options = {}) {
-	const { prompt, discussionOverflow, partiallyReadFiles, partialFiles } = buildChatReviewPrompt(pr, [], {
-		discussionSummary: options.discussionSummary,
-		repositoryAccess: options.repositoryAccess,
-		changeInventory: options.changeInventory,
-		guideCoverage: options.guideCoverage
-	});
+function refOf(thread) {
 	return {
-		prompt: `${prompt}\n\n---\n\n${STRUCTURED_OUTPUT_INSTRUCTIONS}`,
-		discussionOverflow: discussionOverflow ?? false,
-		partiallyReadFiles: partiallyReadFiles ?? 0,
-		partialFiles: partialFiles ?? []
+		id: thread.id,
+		type: thread.type,
+		location: thread.location
 	};
 }
+function hasHuman(thread) {
+	return thread.comments.some((comment) => !isBot(comment));
+}
+/** The review history if the snapshot has one, else its standing verdicts, else none. */
+function reviewsOf(discussion) {
+	return discussion.reviews ?? discussion.decisions ?? [];
+}
+function reviewKey(review) {
+	return `${review.reviewer}\u0000${review.verdict}\u0000${review.timestamp}`;
+}
+function after(timestamp, epochMs) {
+	const at = Date.parse(timestamp);
+	return !Number.isNaN(at) && at > epochMs;
+}
+/** Everything on the request, offered as new: for a baseline of `none` or `unknown`. */
+function everything(current, baseline) {
+	const added = [];
+	for (const thread of current.discussions) for (const comment of thread.comments) if (!isBot(comment)) added.push({
+		thread: refOf(thread),
+		comment,
+		newThread: true
+	});
+	return {
+		baseline,
+		added,
+		edited: [],
+		removed: [],
+		vanishedThreads: [],
+		newReviews: reviewsOf(current).filter((review) => !review.reviewerIsBot),
+		resolved: [],
+		reopened: [],
+		partial: partialOf(current)
+	};
+}
+function diffDiscussion(baseline, current) {
+	if (baseline === null) return everything(current, "none");
+	if (baseline === "unknown") return everything(current, "unknown");
+	const before = new Map(baseline.discussions.map((thread) => [thread.id, thread]));
+	const nowIds = new Set(current.discussions.map((thread) => thread.id));
+	const delta = {
+		baseline: "recorded",
+		added: [],
+		edited: [],
+		removed: [],
+		vanishedThreads: [],
+		newReviews: [],
+		resolved: [],
+		reopened: [],
+		partial: partialOf(current)
+	};
+	for (const thread of current.discussions) {
+		const previous = before.get(thread.id);
+		const ref = refOf(thread);
+		const previousComments = new Map((previous?.comments ?? []).map((comment) => [comment.id, comment]));
+		for (const comment of thread.comments) {
+			if (isBot(comment)) continue;
+			const held = previousComments.get(comment.id);
+			if (!held) delta.added.push({
+				thread: ref,
+				comment,
+				newThread: !previous
+			});
+			else if (comment.editedAt && comment.editedAt !== held.editedAt) {
+				if (held.editedAt || after(comment.editedAt, baseline.fetchedAt)) delta.edited.push({
+					thread: ref,
+					comment,
+					newThread: false,
+					previous: held
+				});
+			}
+		}
+		if (!previous) continue;
+		if (hasHuman(thread)) {
+			if (thread.resolved && !previous.resolved) delta.resolved.push(ref);
+			if (!thread.resolved && previous.resolved) delta.reopened.push(ref);
+		}
+		if (previous.truncatedCommentCount === 0 && thread.truncatedCommentCount === 0) {
+			const nowComments = new Set(thread.comments.map((comment) => comment.id));
+			for (const comment of previous.comments) if (!isBot(comment) && !nowComments.has(comment.id)) delta.removed.push({
+				thread: ref,
+				comment,
+				newThread: false
+			});
+		}
+	}
+	const complete = (collection) => baseline.coverage?.[collection] === "complete" && current.coverage?.[collection] === "complete";
+	for (const previous of baseline.discussions) {
+		if (nowIds.has(previous.id) || !hasHuman(previous)) continue;
+		if (previous.type === "review_thread" && complete("threads")) delta.vanishedThreads.push(refOf(previous));
+		else if (previous.type === "conversation" && complete("conversation")) {
+			for (const comment of previous.comments) if (!isBot(comment)) delta.removed.push({
+				thread: refOf(previous),
+				comment,
+				newThread: false
+			});
+		}
+	}
+	const history = baseline.reviews;
+	const seenIds = new Set((history ?? []).flatMap((review) => review.id ? [review.id] : []));
+	const seenKeys = new Set((history ?? []).map(reviewKey));
+	for (const review of reviewsOf(current)) {
+		if (review.reviewerIsBot) continue;
+		if (history ? !(review.id && seenIds.has(review.id)) && !seenKeys.has(reviewKey(review)) : after(review.timestamp, baseline.fetchedAt)) delta.newReviews.push(review);
+	}
+	return delta;
+}
 /**
-* A reply, parsed, with the motivation checked against the description the analysis read.
+* Whether anything moved that is worth an analysis.
 *
-* 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.
+* Mechanical, by the processor's own rule: a comment that is only a pleasantry or an emoji is not a
+* change to reason about on its own, and a bot never was. A thread resolved, a review submitted or
+* a comment removed always is. Whether any of it matters to a finding is the model's question.
+*
+* An edit counts when either side of it says something. Rewriting a substantive comment into
+* "thanks!" withdraws what it said exactly as deleting it would, and deleting always counts.
 */
-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 hasDiscussionChanges(delta) {
+	const substantive = (entry) => !isNoise(entry.comment);
+	const substantiveEdit = (entry) => substantive(entry) || entry.previous !== void 0 && !isNoise(entry.previous);
+	return delta.added.some(substantive) || delta.edited.some(substantiveEdit) || delta.removed.length > 0 || delta.vanishedThreads.length > 0 || delta.newReviews.length > 0 || delta.resolved.length > 0 || delta.reopened.length > 0;
 }
-/** What tells this reply's answer from a JSON example quoted in the prose before it. */
-var REVIEW_ANSWER = objectWithAnyOf("summary", "recommendation", "issues", "nextSteps");
-function parseUnchecked(raw) {
-	const jsonText = extractJsonText(raw, REVIEW_ANSWER);
-	let parsed;
-	try {
-		parsed = JSON.parse(jsonText);
-	} catch {
-		throw new Error("Could not parse the AI response as JSON.");
-	}
-	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("AI response JSON was not an object.");
-	const obj = parsed;
-	const summary = asString$1(obj.summary);
-	const recommendation = asString$1(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.");
+/**
+* The conversation as an analysis has now taken it into account: the current snapshot, with every
+* change it was not shown put back the way the baseline had it.
+*
+* What an update records as its baseline. Recording the whole current snapshot would mark a change
+* that was held back for length, or never shown at all, as accounted for, and the next update would
+* find nothing new where the model has in fact seen nothing. So each withheld change is undone:
+* an unseen comment is taken out, an unseen edit restored to what it said before, an unseen
+* deletion put back, an unseen resolution flipped back, an unseen review dropped from the history.
+* Each then reads as new to the next update, exactly as it did to this one.
+*
+* Everything not in the delta is taken from the current snapshot as it is (bots, coverage, the
+* standing verdicts), because none of it is evidence the model was or was not given.
+*/
+/**
+* The conversation as a first analysis took it into account: the snapshot without the threads its
+* prompt offered but left out, for length or past the per-file cap.
+*
+* The first analysis's half of `deliveredSnapshot`. Recording the whole snapshot would mark those
+* threads as considered, and an update with nothing new since would find nothing to show. Taken
+* away, they read to that update as new, which to the model they are.
+*
+* Only threads offered and not rendered are taken away. A thread the processor set aside, a bot's or
+* one of pleasantries only, stays, because no update shows it either and nothing was held back.
+*/
+function withoutOmittedThreads(discussion, offered, rendered) {
+	const shown = new Set(rendered);
+	const omitted = new Set(offered.filter((id) => !shown.has(id)));
+	if (omitted.size === 0) return discussion;
 	return {
-		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)
-	};
+		...discussion,
+		discussions: discussion.discussions.filter((thread) => !omitted.has(thread.id))
+	};
+}
+/** The edit time a restored, never-edited comment carries: earlier than any edit a forge reports. */
+var NEVER_SEEN_EDIT = "1970-01-01T00:00:00.000Z";
+function deliveredSnapshot(current, baseline, withheld) {
+	if (withheld.added.length + withheld.edited.length + withheld.removed.length + withheld.vanishedThreads.length + withheld.newReviews.length + withheld.resolved.length + withheld.reopened.length === 0) return current;
+	const next = structuredClone(current);
+	const threads = new Map(next.discussions.map((thread) => [thread.id, thread]));
+	const before = new Map((baseline && baseline !== "unknown" ? baseline.discussions : []).map((thread) => [thread.id, thread]));
+	/** A thread the current snapshot no longer has, put back as the baseline held it. */
+	const restore = (id) => {
+		if (threads.has(id)) return threads.get(id);
+		const held = before.get(id);
+		if (!held) return void 0;
+		const thread = structuredClone(held);
+		next.discussions.push(thread);
+		threads.set(id, thread);
+		return thread;
+	};
+	for (const entry of withheld.added) {
+		const thread = threads.get(entry.thread.id);
+		if (thread) thread.comments = thread.comments.filter((comment) => comment.id !== entry.comment.id);
+	}
+	for (const entry of withheld.edited) {
+		const thread = threads.get(entry.thread.id);
+		const previous = entry.previous && {
+			...entry.previous,
+			editedAt: entry.previous.editedAt || NEVER_SEEN_EDIT
+		};
+		if (thread && previous) thread.comments = thread.comments.map((comment) => comment.id === previous.id ? previous : comment);
+	}
+	for (const entry of withheld.removed) {
+		const thread = restore(entry.thread.id);
+		if (thread && !thread.comments.some((comment) => comment.id === entry.comment.id)) thread.comments.push(entry.comment);
+	}
+	for (const ref of withheld.vanishedThreads) restore(ref.id);
+	for (const ref of withheld.resolved) {
+		const thread = threads.get(ref.id);
+		if (thread) thread.resolved = false;
+	}
+	for (const ref of withheld.reopened) {
+		const thread = threads.get(ref.id);
+		if (thread) thread.resolved = true;
+	}
+	if (withheld.newReviews.length && next.reviews) {
+		const unseen = new Set(withheld.newReviews);
+		const unseenIds = new Set(withheld.newReviews.flatMap((review) => review.id ? [review.id] : []));
+		const unseenKeys = new Set(withheld.newReviews.map(reviewKey));
+		next.reviews = next.reviews.filter((review) => !unseen.has(review) && !(review.id && unseenIds.has(review.id)) && !unseenKeys.has(reviewKey(review)));
+	}
+	next.discussions = next.discussions.filter((thread) => thread.comments.length > 0);
+	return next;
 }
-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.";
 //#endregion
-//#region ../../packages/review-harness/src/domain/kiss/prompt.ts
-var SCOPE_BOUNDARY = `Scope:
-Judge the complexity this change introduces or materially expands. That is the whole of what you are reviewing.
-Pre-existing complexity around the change is context you may use to understand it, and is not a finding. Do not attribute it to this author.
-The one exception: where this change makes existing complexity worse, or where the work could not have been done without taking it on, that is in scope and you should say which of the two it is.
-Do not propose refactoring architecture the change merely touches.`;
-var EVIDENCE_THRESHOLD = `Evidence threshold:
-Emit a recommendation only when you can do all five of these. If you cannot, say nothing.
-1. Name the concrete complexity this change introduced. Not "this is complicated" — the actual types, layers, files, flags or machinery.
-2. Explain why the current requirements and this repository do not call for it.
-3. Describe a credible, materially simpler implementation. If you cannot say what to do instead, you do not have a recommendation.
-4. Point at the changed file or files where it was introduced.
-5. Say what acting on it is worth, and what it would cost.
-Never emit a recommendation resting on naming preference, personal taste, or a requirement nobody has yet.`;
+//#region ../../packages/review-harness/src/domain/discussion/conversation_section.ts
 /**
-* The five checks above are how to reason, not how to write.
+* The line every state ends with.
 *
-* Schema 1 gave each check its own output field, and the result was the reasoning printed five
-* times over: one argument restated under five headings, with the conclusion fourth. The checks stay
-* as the gate; this block asks for the conclusion first and keeps the checks as the audit trail.
+* Persuasion, not the boundary: the agent's tool policy is what actually stops a fetch. This is
+* here so that an answer is not padded with commands the reviewer was never going to need.
 */
-var DISTIL = `How to write a recommendation:
-Work through all five checks first. Then distil what you found. A reviewer should understand the recommendation from "title", "gist", "simplerDirection" and "gains" alone, in a few seconds, without reading anything else.
-"evidence", "whyNotJustified" and "payoffAndTradeoffs" are the audit trail for somebody who wants to check or challenge you. They carry the detail. They must not restate the gist. "evidence" and "whyNotJustified" are required: a recommendation without a basis somebody can check is withheld, however good its summary.
-Name each piece of machinery where it matters and do not repeat the same argument in every field. One argument, stated once, then supported.`;
+var NO_FORGE_RETRIEVAL = "Do not attempt to retrieve pull request or forge data yourself, and do not suggest commands or API calls for retrieving it.";
+var MISSING_PREVENTS = "Where the missing conversation prevents a conclusion, say that plainly rather than guessing.";
+var UNAVAILABLE = {
+	"unsupported-forge": "PR Review Buddy does not read pull request conversation on this forge yet",
+	"cli-missing": "the forge's command-line tool is not installed on this machine",
+	"not-authenticated": "the forge's command-line tool is not signed in on this machine",
+	failed: "the fetch failed"
+};
+var REREAD_FAILURE = {
+	...UNAVAILABLE,
+	"too-slow": "the forge took longer to answer than PR Review Buddy waits before replying"
+};
+function iso(epochMs) {
+	return Number.isFinite(epochMs) && epochMs > 0 ? new Date(epochMs).toISOString() : "an unknown time";
+}
+/** What PR Review Buddy has of the conversation, in a short paragraph that names the state outright. */
+function renderConversationState(state) {
+	switch (state.kind) {
+		case "attached":
+			if (state.reread === "failed") return [
+				`PR Review Buddy could not re-read the pull request conversation just now${state.rereadReason ? `: ${REREAD_FAILURE[state.rereadReason]}` : ""}.`,
+				`What follows is the copy it fetched at ${iso(state.fetchedAt)}, and it may be out of date. Say so where that matters.`,
+				NO_FORGE_RETRIEVAL
+			].join(" ");
+			return [state.reread === "fresh" ? `PR Review Buddy fetched the pull request conversation at ${iso(state.fetchedAt)}, for this request.` : `PR Review Buddy fetched the pull request conversation at ${iso(state.fetchedAt)}.`, NO_FORGE_RETRIEVAL].join(" ");
+		case "unavailable": return [
+			`PR Review Buddy could not retrieve the pull request conversation: ${UNAVAILABLE[state.reason]}.`,
+			"None of it is included, so do not conclude that there are no comments.",
+			MISSING_PREVENTS,
+			NO_FORGE_RETRIEVAL
+		].join(" ");
+		case "no-request": return ["This change is not on a pull request PR Review Buddy could find, so there is no conversation to include.", NO_FORGE_RETRIEVAL].join(" ");
+		case "not-attached": return [
+			"No pull request conversation is attached to this review, so none is included.",
+			MISSING_PREVENTS,
+			NO_FORGE_RETRIEVAL
+		].join(" ");
+		case "withheld": return [
+			"The reviewer has chosen not to share the pull request conversation, so none is included. Do not conclude that there are no comments.",
+			MISSING_PREVENTS,
+			NO_FORGE_RETRIEVAL
+		].join(" ");
+	}
+}
+/**
+* A ceiling, not a measurement: one and a half times the assistant's conversation budget
+* (`CHAT_DISCUSSION_BUDGET_CHARS`), so a first delta against a review made without any
+* conversation cannot crowd the diff out of an update prompt. Overflow is counted in the text,
+* so a delta that binds says so rather than reading as complete.
+*/
+var DELTA_BUDGET_CHARS = 12e3;
+var DELTA_HEADING = "PR DISCUSSION CHANGES SINCE THIS REVIEW WAS MADE";
+var BASELINE_LINE = {
+	recorded: "Computed by PR Review Buddy by comparing the conversation this review was given with the conversation now. Times are as the forge reported them.",
+	none: "This review was made without the pull request conversation, so all of it is new to the review.",
+	unknown: "The conversation this review was given was not recorded, so what is listed below may include comments the review already took into account. Treat each item as possibly new, not certainly new."
+};
+/** What a delta is measured from, in the sentence the delta section opens with. */
+function baselineNote(baseline) {
+	return BASELINE_LINE[baseline];
+}
+function where(thread) {
+	return `[${thread.id}] ${locationOf(thread)}`;
+}
+/** A comment's line names the comment as well as its thread, so a finding can cite exactly what it rests on. */
+function whereComment(entry) {
+	return `[${entry.thread.id}] [comment ${entry.comment.id}] ${locationOf(entry.thread)}`;
+}
+function body(text) {
+	return truncateBody(text.trim(), 800);
+}
+function addedLine(entry) {
+	const { comment } = entry;
+	const kind = entry.newThread ? " (new thread)" : comment.replyToId ? " (reply)" : "";
+	return `- ${whereComment(entry)} · @${comment.author} · ${comment.timestamp || "time unknown"}${kind}: ${body(comment.body)}`;
+}
+function editedLine(entry) {
+	const { comment, previous } = entry;
+	const before = previous ? ` It previously read: ${body(previous.body)}` : "";
+	return `- ${whereComment(entry)} · @${comment.author} · written ${comment.timestamp || "at an unknown time"}, edited ${comment.editedAt}. It now reads: ${body(comment.body)}${before}`;
+}
+function removedLine(entry) {
+	const { comment } = entry;
+	return `- ${whereComment(entry)} · @${comment.author} · written ${comment.timestamp || "at an unknown time"}. It read: ${body(comment.body)}`;
+}
+/** Every list of a delta, in the order a reader needs them, with its heading and its line. */
+var SECTIONS = [
+	{
+		list: "added",
+		heading: (baseline) => baseline === "recorded" ? "## Added" : "## Comments",
+		line: addedLine
+	},
+	{
+		list: "edited",
+		heading: () => "## Edited",
+		line: editedLine
+	},
+	{
+		list: "removed",
+		heading: () => "## Deleted",
+		line: removedLine
+	},
+	{
+		list: "vanishedThreads",
+		heading: () => "## Review threads no longer present",
+		line: ((thread) => `- ${where(thread)}`)
+	},
+	{
+		list: "newReviews",
+		heading: (baseline) => baseline === "recorded" ? "## New reviews submitted" : "## Reviews submitted",
+		line: ((review) => {
+			const text = review.body.trim();
+			return `- ${review.id ? `[review ${review.id}] ` : ""}@${review.reviewer} · ${VERDICT_LABELS[review.verdict]} · ${review.timestamp || "time unknown"}${text ? `: ${body(text)}` : " (no summary; any comments it left on lines are listed above as comments)"}`;
+		})
+	},
+	{
+		list: "resolved",
+		heading: () => "## Threads resolved since",
+		line: ((thread) => `- ${where(thread)}`)
+	},
+	{
+		list: "reopened",
+		heading: () => "## Threads reopened since",
+		line: ((thread) => `- ${where(thread)}`)
+	}
+];
+function emptyLike(delta) {
+	return {
+		...delta,
+		added: [],
+		edited: [],
+		removed: [],
+		vanishedThreads: [],
+		newReviews: [],
+		resolved: [],
+		reopened: []
+	};
+}
+function headerOf(delta) {
+	return `${DELTA_HEADING}\n${BASELINE_LINE[delta.baseline]}`;
+}
 /**
-* How to read the pull request conversation, for a lens that is not attributing anything to it.
+* Split a delta at a budget, by the same lines it is rendered as.
 *
-* KISS needs the conversation for one reason and it is the load-bearing one: `whyNotJustified`
-* asks whether the requirements call for the machinery, and a thread saying "please put this
-* behind a flag" is the difference between a flag nobody asked for and a flag that was required.
-* Without it the model infers the requirements from the code it is being asked to judge, which is
-* circular — the change is its own justification.
+* Its own step because the split is a fact the caller needs, not only a count in the text: an
+* update records as taken into account only what the model was actually shown, so a change held
+* back for length is still new to the next one. Whole lines only, and a line that does not fit does
+* not stop a shorter one after it from fitting.
+*/
+function fitDiscussionDelta(delta, budgetChars = DELTA_BUDGET_CHARS) {
+	const shown = emptyLike(delta);
+	const withheld = emptyLike(delta);
+	let spent = headerOf(delta).length;
+	for (const section of SECTIONS) {
+		const items = delta[section.list];
+		if (items.length === 0) continue;
+		const heading = section.heading(delta.baseline);
+		let opened = false;
+		for (const item of items) {
+			const cost = section.line(item).length + 1 + (opened ? 0 : heading.length + 2);
+			if (spent + cost > budgetChars) {
+				withheld[section.list].push(item);
+				continue;
+			}
+			spent += cost;
+			opened = true;
+			shown[section.list].push(item);
+		}
+	}
+	return {
+		shown,
+		withheld
+	};
+}
+/** How many changes a delta lists. */
+function changeCount(delta) {
+	return SECTIONS.reduce((total, section) => total + delta[section.list].length, 0);
+}
+/**
+* The delta as a prompt section, within a budget.
 *
-* So the conversation is framed as evidence about requirements, and explicitly not as something to
-* cite. The standard review tags threads so a finding can point at one; here a thread is a fact
-* about what was asked for, and "reviewer X said so" is not a reason to keep complexity.
+* Whole lines only, in the order a reader needs them: what was said, then what was rewritten or
+* withdrawn, then verdicts and resolution. Anything that did not fit is counted in a closing note,
+* because a delta that silently stops reads as a complete one.
 */
-var REQUIREMENTS_FROM_DISCUSSION = `How to use the conversation below:
-It is evidence about what was actually required, and that is the only thing you should take from it.
-A requirement stated in the conversation is a requirement: complexity the discussion explicitly asked for is justified, and you should say that it was asked for rather than recommending its removal.
-Silence is not agreement. Nobody objecting to an abstraction is not a requirement for it.
-Do not attribute recommendations to participants, do not quote or cite threads in your answer, and do not treat somebody's stated preference as a requirement. You are judging the change, not the discussion.`;
-var RUBRIC = `What to look at:
-- abstractions with one implementation and no boundary that presently needs one
-- interfaces, protocols, adapters or indirection created without a concrete need
-- factories, builders, managers, services, repositories or wrapper layers that do no work
-- file, class, type or module proliferation out of proportion to the change
-- generic solutions where the requirements are specific
-- extensibility and flexibility built for requirements that do not exist
-- optimisation with no measured constraint behind it
-- duplicated or redundant state machinery
-- lifecycle, state-machine, event-bus, observer or orchestration abstractions the flow does not need
-- defensive code for states that cannot occur at that boundary
-- the same validation repeated at several layers
-- configuration, flags, environment variables or options nobody asked for
-- third-party dependencies that earn less than they cost
-- pass-through layers adding vocabulary but no policy or isolation
-- indirection that makes the execution path materially harder to follow
-- error and retry machinery broader than the failures it faces
-- a large change where a materially smaller implementation looks feasible
-- repeated wrappers or conversions that could collapse
-- abstractions justified only by a hypothetical second implementation
-
-Fewer lines is evidence, not the objective. A twenty-line explicit implementation can be simpler than a five-line generic one. Judge simplicity by fewer concepts, fewer states, fewer sources of truth, fewer speculative abstractions, fewer indirections and less machinery needed to understand the behaviour.
-This is not a style review. Naming preferences, "extract this method", small tidy-ups and repetition that costs nobody any understanding are not recommendations.
-
-This is a list of things to look at, not a list of things to report. Every item here is sometimes exactly right. One implementation does not make an interface wrong: it may be a real external boundary, a testing seam, or a repository convention. More files do not make code worse. Judge what each thing is for and what it costs.`;
-var WORTH_KEEPING = `Complexity worth keeping:
-Look actively for complexity that is doing a job, and say so. This is not a politeness section — it is how the reader can tell you understood the change rather than counted its abstractions.
-Things that usually earn their keep: transaction boundaries protecting atomicity; write-and-rename protocols preventing corruption; security and permission boundaries; concurrency control; retry or idempotency logic against a boundary that has actually proven unreliable; compatibility adapters at a real external seam; validation at a trust boundary; abstractions with more than one real implementation, or that follow an established convention in this repository; anything an explicit requirement mandates.
-If nothing in this change needs the note, return an empty list. Do not pad it.`;
-var AUDIENCE_BLOCKS = {
-	author: `Who is reading this:
-The person who wrote this change, before they ask anyone to review it. They can act on what you say immediately.
-Be direct and specific. Say what to collapse, remove, inline, defer or replace. "Collapse these three classes into one" and "this abstraction has one implementation, remove it for now" are the register.
-Give enough of the trade-off that they do not flatten something that was load-bearing, and no more. They did not ask for diplomacy.
-Do not write draft pull request comments and do not set commentWorthiness. Nobody is being told anything by anyone here.`,
-	reviewer: `Who is reading this:
-Somebody reviewing another person's change. They are deciding what is worth raising, which is a different question from what is true.
-Explain why the implementation may be more complex than it needs to be, without asserting your judgement as fact. The author may know something you do not.
-Set commentWorthiness on every recommendation, and keep it separate from payoff: an observation can be entirely valid and still not be worth spending a review comment on.
-Where a comment is worth making, draft it. A good draft explains the concern, asks or recommends rather than instructs, and acknowledges the trade-off the author was probably making.
-Never write "bad code", "obvious", "over-engineered" or anything else that describes the author rather than the code.`
+function renderDiscussionDelta(delta, budgetChars = DELTA_BUDGET_CHARS) {
+	const header = headerOf(delta);
+	const partial = partialNote(delta);
+	if (changeCount(delta) === 0) return `${header}\n\nNothing in the conversation has changed since this review was made.${partial ? `\n\n${partial}` : ""}`;
+	const { shown, withheld } = fitDiscussionDelta(delta, budgetChars);
+	const parts = [header];
+	for (const section of SECTIONS) {
+		const items = shown[section.list];
+		if (items.length > 0) parts.push(`${section.heading(delta.baseline)}\n${items.map(section.line).join("\n")}`);
+	}
+	const omitted = changeCount(withheld);
+	if (omitted > 0) parts.push(`(${omitted} further change${omitted === 1 ? "" : "s"} omitted for length.)`);
+	if (partial) parts.push(partial);
+	return parts.join("\n\n");
+}
+var COLLECTION_NAMES = {
+	threads: "review threads",
+	conversation: "top-level comments",
+	reviews: "review submissions"
 };
+/** Said when part of the conversation was past what PR Review Buddy fetches, so the lists are not read as whole. */
+function partialNote(delta) {
+	if (delta.partial.length === 0) return "";
+	const names = delta.partial.map((collection) => COLLECTION_NAMES[collection]);
+	return `(This pull request has more ${names.length > 1 ? `${names.slice(0, -1).join(", ")} and ${names.at(-1)}` : names[0]} than PR Review Buddy fetches, so changes among the ones it did not fetch are not listed.)`;
+}
 /**
-* The shape of the answer, written out whole.
+* A ceiling, not a measurement: half the assistant's conversation budget, beside which this is
+* rendered. Overflow is counted in the text.
+*/
+var REVIEW_HISTORY_BUDGET_CHARS = 4e3;
+/**
+* Every review summary on the request, for a reader who may ask about any of them.
 *
-* Never abbreviated, and never described in prose instead. A field the model is not shown is a
-* field it does not reliably produce, and a field the parser reads but the prompt never named is
-* how a result arrives parsed into nothing.
+* The conversation block shows each reviewer's standing verdict, which is their latest review and
+* no other. An earlier summary appears in a delta only while it is new; once an analysis has taken
+* it into account it would otherwise be nowhere, and a reviewer asking "what did they say in their
+* first review?" would get a guess. So the history is stated here whole, within a budget.
+*
+* Reviews with no summary are counted rather than listed: their content is the comments they left
+* on lines, which the conversation already carries. Filled from the newest back, so a budget that
+* binds costs the oldest summaries, and shown oldest first, which is how a reader follows them.
 */
-var KISS_OUTPUT_INSTRUCTIONS = `Respond with a single JSON object, no markdown around it and no text before or after, matching exactly this shape:
+function renderReviewHistory(discussion, budgetChars = REVIEW_HISTORY_BUDGET_CHARS) {
+	const human = (discussion.reviews ?? []).filter((review) => !review.reviewerIsBot);
+	const summarised = human.filter((review) => review.body.trim());
+	if (summarised.length === 0) return "";
+	const heading = "## Review summaries, oldest first";
+	let spent = 33;
+	const kept = [];
+	for (const review of [...summarised].reverse()) {
+		const line = historyLine(review);
+		if (spent + line.length + 1 > budgetChars) continue;
+		spent += line.length + 1;
+		kept.unshift(review);
+	}
+	const notes = [];
+	const omitted = summarised.length - kept.length;
+	if (omitted > 0) notes.push(`(${omitted} earlier summar${omitted === 1 ? "y" : "ies"} omitted for length.)`);
+	const empty = human.length - summarised.length;
+	if (empty > 0) notes.push(`(${empty} further review${empty === 1 ? "" : "s"} had no summary; what they said is in the comments above.)`);
+	return [
+		heading,
+		...kept.map(historyLine),
+		...notes
+	].join("\n");
+}
+function historyLine(review) {
+	return `- @${review.reviewer} · ${VERDICT_LABELS[review.verdict]} · ${review.timestamp || "time unknown"}: ${body(review.body)}`;
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/ai_review/status_history.ts
+/** A comment as evidence, copied as it reads now. */
+function commentEvidence(threadId, comment) {
+	return {
+		kind: "comment",
+		threadId,
+		commentId: comment.id,
+		author: comment.author,
+		body: truncateBody(comment.body.trim(), 800),
+		...comment.url ? { url: comment.url } : {},
+		...comment.timestamp ? { writtenAt: comment.timestamp } : {},
+		...comment.editedAt ? { editedAt: comment.editedAt } : {}
+	};
+}
+function reviewEvidence(review) {
+	return {
+		kind: "review",
+		...review.id ? { reviewId: review.id } : {},
+		author: review.reviewer,
+		body: truncateBody(review.body.trim(), 800),
+		...review.timestamp ? { writtenAt: review.timestamp } : {}
+	};
+}
+/**
+* The comment a resolved finding rests on, when a comment is what resolved it. Only a comment: a
+* review summary cannot resolve a finding (`REVIEW_CITATION`), so no resolution rests on one.
+*/
+function conversationResolution(issue) {
+	if (issue.reconciliationStatus !== "resolved") return void 0;
+	const last = issue.statusHistory?.at(-1);
+	if (!last || last.status !== "resolved" || last.basis !== "conversation") return void 0;
+	return last.evidence?.kind === "comment" && last.evidence.commentId ? last.evidence : void 0;
+}
+/**
+* The findings, by index, whose resolving comment the delta edits or deletes.
+*
+* Pass the delta the model is actually shown, never the whole one: a finding flagged on an edit held
+* back for length would be judged again on evidence the model never saw.
+*/
+function reassessmentFlags(issues, delta) {
+	const flags = /* @__PURE__ */ new Map();
+	issues.forEach((issue, index) => {
+		const resolvedBy = conversationResolution(issue);
+		if (!resolvedBy) return;
+		const edited = delta.edited.find((entry) => entry.comment.id === resolvedBy.commentId);
+		if (edited) {
+			flags.set(index, {
+				change: "edited",
+				resolvedBy,
+				now: commentEvidence(edited.thread.id, edited.comment)
+			});
+			return;
+		}
+		if (delta.removed.some((entry) => entry.comment.id === resolvedBy.commentId) || delta.vanishedThreads.some((thread) => thread.id === resolvedBy.threadId)) flags.set(index, {
+			change: "deleted",
+			resolvedBy,
+			now: {
+				...resolvedBy,
+				body: "",
+				deleted: true
+			}
+		});
+	});
+	return flags;
+}
+function findComment(discussion, commentId) {
+	for (const thread of discussion.discussions) {
+		const comment = thread.comments.find((candidate) => candidate.id === commentId);
+		if (comment) return {
+			thread,
+			comment
+		};
+	}
+}
+function resolveCitation(citation, discussion) {
+	if (!discussion) return void 0;
+	if ("reviewId" in citation) {
+		const review = (discussion.reviews ?? []).find((candidate) => candidate.id === citation.reviewId);
+		return review ? reviewEvidence(review) : void 0;
+	}
+	const found = findComment(discussion, citation.commentId);
+	return found ? commentEvidence(found.thread.id, found.comment) : void 0;
+}
+/** Said, after the model's own note, when the harness would not let a resolution stand. */
+var UNFOUND_CITATION = "It cited a comment that is not in the pull request conversation, so it is marked for reassessment rather than resolved.";
+/**
+* A review summary may be cited, but not as what resolved a finding. Resolving is the one status a
+* later change to its evidence must be able to undo, and an edit to a review's summary is not yet
+* read, so a resolution resting on one could never be reassessed. Until it is, it is marked for
+* reassessment, with the review kept as its evidence.
+*/
+var REVIEW_CITATION = "It rests on a review summary, which can mark a finding for reassessment but not resolve it, so the reviewer should decide.";
+var NO_CITATION = "No commits were pushed and no comment was cited for it, so it is marked for reassessment rather than resolved.";
+function withSentence(note, sentence) {
+	return note ? `${note} ${sentence}` : sentence;
+}
+/**
+* The model's citations, checked against the conversation that exists and copied from it.
+*
+* A resolution that rests on the conversation has to rest on something real. One citing a comment
+* that is not there, or (with no commits pushed) citing nothing, is marked "affected" with the reason
+* said, never left standing as resolved. A citation on any other status is evidence for the record
+* only, and one that is not there is dropped.
+*
+* The one resolution that needs no citation with no commits pushed: a flagged finding the model
+* keeps resolved, whose evidence is then the edited comment it was asked to judge. A deleted one has
+* nothing left to rest on.
+*/
+function groundFindings(findings, discussion, context) {
+	return findings.map((finding) => {
+		const { cites, ...rest } = finding;
+		const evidence = cites ? resolveCitation(cites, discussion) : void 0;
+		if (finding.status !== "resolved") return evidence ? {
+			...rest,
+			evidence
+		} : rest;
+		if (cites && !evidence) return {
+			...rest,
+			status: "affected",
+			note: withSentence(finding.note, UNFOUND_CITATION)
+		};
+		if (evidence?.kind === "review") return {
+			...rest,
+			status: "affected",
+			note: withSentence(finding.note, REVIEW_CITATION),
+			evidence
+		};
+		if (evidence) return {
+			...rest,
+			evidence
+		};
+		if (context.codeChanged) return rest;
+		const flag = context.flags?.get(finding.sourceIndex);
+		if (flag?.change === "edited") return {
+			...rest,
+			evidence: flag.now
+		};
+		return {
+			...rest,
+			status: "affected",
+			note: withSentence(finding.note, NO_CITATION)
+		};
+	});
+}
+/** Statuses that all mean "open": a finding never judged, one raised by an update, and one judged still open. */
+function isOpen(status) {
+	return status === void 0 || status === "new" || status === "still-open";
+}
+/** Whether going from one status to the other is a change worth a history entry. */
+function isStatusChange(from, to) {
+	return from !== to && !(isOpen(from) && isOpen(to));
+}
+/**
+* The history with one more entry. A finding that had a status before history was kept starts from
+* that status, carried with the note it had, so the first recorded change has something to move from.
+*/
+function appendStatusChange(issue, entry) {
+	return [...issue.statusHistory ?? (issue.reconciliationStatus && !isOpen(issue.reconciliationStatus) ? [{
+		status: issue.reconciliationStatus,
+		carried: true,
+		...issue.reconciliationNote ? { reason: issue.reconciliationNote } : {}
+	}] : []), entry];
+}
+/**
+* The entry for a flagged finding, whatever the model said: still resolved, reopened, marked for
+* reassessment, or nothing, which is marked for reassessment. Recorded even when it stays resolved,
+* so the history shows the resolution survived the change and on what.
+*/
+function reassessedEntry(verdict, flag, record) {
+	const status = verdict?.status ?? "affected";
+	const byCode = status === "resolved" && !verdict?.evidence && record.basis === "code";
+	const evidence = byCode ? void 0 : verdict?.evidence ?? flag.now;
+	const reason = verdict?.note ?? (flag.change === "edited" ? "The comment that resolved this was edited, and the update did not say whether it still holds." : "The comment that resolved this was deleted, and the update did not say whether it still holds.");
+	return {
+		status,
+		at: record.at,
+		commitSha: record.commitSha,
+		basis: byCode ? "code" : "conversation",
+		reason,
+		...evidence ? { evidence } : {},
+		trigger: flag.change === "edited" ? "evidence-edited" : "evidence-deleted"
+	};
+}
+/** The entry for an ordinary change of status. */
+function changeEntry(status, verdict, record) {
+	return {
+		status,
+		at: record.at,
+		commitSha: record.commitSha,
+		basis: verdict?.evidence ? "conversation" : record.basis,
+		...verdict?.note ? { reason: verdict.note } : {},
+		...verdict?.evidence ? { evidence: verdict.evidence } : {}
+	};
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/discussion/prepared_conversation.ts
+/**
+* How long a question about the review waits for the conversation to be fetched again before it
+* answers from the copy it has, stated as possibly out of date. The same on every surface, so the
+* workspace's Ask and the extension's Chat are equally patient.
+*/
+var CONVERSATION_REREAD_CEILING_MS = 3e3;
+/** The state as a prompt block, headed the same way on every surface. */
+function conversationStateBlock(state) {
+	return `PR CONVERSATION\n${renderConversationState(state)}`;
+}
+/** Whether anything in the conversation is new to the analysis, which is what an update reconciles against. */
+function conversationMoved(conversation) {
+	return conversation.delta !== void 0 && hasDiscussionChanges(conversation.delta);
+}
+/**
+* The conversation block of an update prompt: the state always, and what changed only when
+* something did, so an update the conversation did not move reads as it always has plus one line.
+*/
+function updateConversationBlock(conversation) {
+	return [conversationStateBlock(conversation.state), ...conversationMoved(conversation) && conversation.delta ? [renderDiscussionDelta(conversation.delta)] : []].join("\n\n");
+}
+/**
+* The resolved findings an update judges again: those whose resolving comment the conversation it
+* shows edits or deletes. Read from the delta as fitted, the same split the prompt renders, so a
+* finding is never sent back on an edit the model was not shown. None when the conversation is only
+* stated, not reconciled against.
+*/
+function conversationReassessment(previous, conversation) {
+	const { delta } = conversation;
+	if (!delta || !previous || !hasDiscussionChanges(delta)) return /* @__PURE__ */ new Map();
+	return reassessmentFlags(previous.issues, fitDiscussionDelta(delta).shown);
+}
+/**
+* The conversation an update can claim to have taken into account: what it was shown, and no more.
+* A change held back for length, or a conversation that was stated but not reconciled against,
+* stays new to the next update rather than being recorded as seen.
+*
+* `baseline` is the one the delta was measured from, read before anything moves it.
+*/
+function conversationTakenIntoAccount(conversation, baseline) {
+	const { discussion, delta } = conversation;
+	if (!discussion || !delta) return discussion;
+	return deliveredSnapshot(discussion, baseline, hasDiscussionChanges(delta) ? fitDiscussionDelta(delta).withheld : delta);
+}
+/**
+* The conversation for a question about the review, stated whatever its state.
+*
+* Three parts: what PR Review Buddy has and how fresh it is; the conversation as it now stands; and
+* what changed in it since the analysis the reviewer is reading. The last only where there is a
+* recorded baseline to measure from. Without one, every comment would be listed twice, so the
+* conversation appears once and a sentence says why nothing is marked new.
+*/
+function chatConversationSection(conversation) {
+	const parts = [conversationStateBlock(conversation.state)];
+	if (conversation.discussion) {
+		const full = buildChatDiscussionSection(processDiscussion(conversation.discussion));
+		parts.push(full || "The pull request has no human comments or reviews.");
+		const history = renderReviewHistory(conversation.discussion);
+		if (history) parts.push(history);
+	}
+	if (conversation.delta) parts.push(conversation.delta.baseline === "recorded" ? renderDiscussionDelta(conversation.delta) : `WHAT IS NEW SINCE THIS REVIEW\n${baselineNote(conversation.delta.baseline)}`);
+	return parts.join("\n\n");
+}
+//#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:
 {
-  "assessment": string,
   "summary": string,
-  "recommendations": [{
+  "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,
+    "order": number,
     "title": string,
-    "payoff": "high_value" | "worth_considering" | "nit",
-    "gist": string,
-    "simplerDirection": string,
-    "gains": [string],
-    "reductionEstimate": string,
-    "caveat": string,
-    "evidence": string,
-    "whyNotJustified": string,
-    "payoffAndTradeoffs": string,
-    "commentWorthiness": "strong" | "consider" | "leave",
-    "draftComment": string,
-    "locations": [{ "path": string, "line": number, "primary": boolean }]
+    "oneLineSummary": string,
+    "purpose": string,
+    "files": [{ "path": string, "focus": string }],
+    "whyReview": string,
+    "checklist": string[],
+    "priority": "implementation" | "supporting" | "tests" | "documentation",
+    "reviewAttention": "high" | "medium" | "low",
+    "reviewWeight": 1 | 2 | 3 | 4 | 5,
+    "recommendedStartingPoint": boolean
   }],
-  "justifiedComplexity": [{
-    "id": string,
-    "title": string,
-    "reason": string,
-    "rationale": string,
-    "locations": [{ "path": string, "line": number, "primary": boolean }]
+  "issues": [{ "id": string, "severity": "critical" | "major" | "minor" | "nit", "title": string, "description": string, "file"?: string, "line"?: number, "sectionId"?: string, "confidence"?: "high" | "medium" | "low", "existingDiscussion"?: { "threadId": string, "relation": "same" | "related" } }],
+  "questions": [{ "id": string, "question": string, "importance"?: "high" | "medium" | "low", "whyThisMatters"?: string, "file"?: string, "sectionId"?: string }],
+  "recommendation": string,
+  "nextSteps": string[]
+}
+
+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.
+- "sectionId" on issues/questions: reference the "id" of the section that item belongs to. Omit it rather than guessing if an item doesn't clearly belong to one section.
+- "recommendation": a 1-2 sentence merge verdict aimed at the developer (e.g. "Approve" or "Request changes — fix the unhandled rejection before merging"). Do not just restate the risk level, and do not copy Guide section content verbatim into this field.
+- "nextSteps": concrete actions to take before merging (specific tests to run, files to double-check), not a restatement of the Guide.
+- "issues": report only issues worth the reviewer's attention — do not invent issues to fill out the array, and do not omit significant issues. Let the count reflect the actual PR (a trivial PR may have zero or one issue; a large or risky PR may have several).
+- "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", 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.`;
+function buildStructuredReviewPrompt(pr, options = {}) {
+	const { prompt, discussionOverflow, discussionThreadIds, partiallyReadFiles, partialFiles } = buildChatReviewPrompt(pr, [], {
+		discussionSummary: options.discussionSummary,
+		repositoryAccess: options.repositoryAccess,
+		changeInventory: options.changeInventory,
+		guideCoverage: options.guideCoverage
+	});
+	return {
+		prompt: `${prompt}\n\n---\n\n${STRUCTURED_OUTPUT_INSTRUCTIONS}`,
+		discussionOverflow: discussionOverflow ?? false,
+		discussionThreadIds: discussionThreadIds ?? [],
+		partiallyReadFiles: partiallyReadFiles ?? 0,
+		partialFiles: partialFiles ?? []
+	};
+}
+/**
+* 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 } : {}
+	};
+}
+/** What tells this reply's answer from a JSON example quoted in the prose before it. */
+var REVIEW_ANSWER = objectWithAnyOf("summary", "recommendation", "issues", "nextSteps");
+function parseUnchecked(raw) {
+	const jsonText = extractJsonText(raw, REVIEW_ANSWER);
+	let parsed;
+	try {
+		parsed = JSON.parse(jsonText);
+	} catch {
+		throw new Error("Could not parse the AI response as JSON.");
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("AI response JSON was not an object.");
+	const obj = parsed;
+	const summary = asString$1(obj.summary);
+	const recommendation = asString$1(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 {
+		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.";
+//#endregion
+//#region ../../packages/review-harness/src/domain/kiss/prompt.ts
+var SCOPE_BOUNDARY = `Scope:
+Judge the complexity this change introduces or materially expands. That is the whole of what you are reviewing.
+Pre-existing complexity around the change is context you may use to understand it, and is not a finding. Do not attribute it to this author.
+The one exception: where this change makes existing complexity worse, or where the work could not have been done without taking it on, that is in scope and you should say which of the two it is.
+Do not propose refactoring architecture the change merely touches.`;
+var EVIDENCE_THRESHOLD = `Evidence threshold:
+Emit a recommendation only when you can do all five of these. If you cannot, say nothing.
+1. Name the concrete complexity this change introduced. Not "this is complicated" — the actual types, layers, files, flags or machinery.
+2. Explain why the current requirements and this repository do not call for it.
+3. Describe a credible, materially simpler implementation. If you cannot say what to do instead, you do not have a recommendation.
+4. Point at the changed file or files where it was introduced.
+5. Say what acting on it is worth, and what it would cost.
+Never emit a recommendation resting on naming preference, personal taste, or a requirement nobody has yet.`;
+/**
+* The five checks above are how to reason, not how to write.
+*
+* Schema 1 gave each check its own output field, and the result was the reasoning printed five
+* times over: one argument restated under five headings, with the conclusion fourth. The checks stay
+* as the gate; this block asks for the conclusion first and keeps the checks as the audit trail.
+*/
+var DISTIL = `How to write a recommendation:
+Work through all five checks first. Then distil what you found. A reviewer should understand the recommendation from "title", "gist", "simplerDirection" and "gains" alone, in a few seconds, without reading anything else.
+"evidence", "whyNotJustified" and "payoffAndTradeoffs" are the audit trail for somebody who wants to check or challenge you. They carry the detail. They must not restate the gist. "evidence" and "whyNotJustified" are required: a recommendation without a basis somebody can check is withheld, however good its summary.
+Name each piece of machinery where it matters and do not repeat the same argument in every field. One argument, stated once, then supported.`;
+/**
+* How to read the pull request conversation, for a lens that is not attributing anything to it.
+*
+* KISS needs the conversation for one reason and it is the load-bearing one: `whyNotJustified`
+* asks whether the requirements call for the machinery, and a thread saying "please put this
+* behind a flag" is the difference between a flag nobody asked for and a flag that was required.
+* Without it the model infers the requirements from the code it is being asked to judge, which is
+* circular — the change is its own justification.
+*
+* So the conversation is framed as evidence about requirements, and explicitly not as something to
+* cite. The standard review tags threads so a finding can point at one; here a thread is a fact
+* about what was asked for, and "reviewer X said so" is not a reason to keep complexity.
+*/
+var REQUIREMENTS_FROM_DISCUSSION = `How to use the conversation below:
+It is evidence about what was actually required, and that is the only thing you should take from it.
+A requirement stated in the conversation is a requirement: complexity the discussion explicitly asked for is justified, and you should say that it was asked for rather than recommending its removal.
+Silence is not agreement. Nobody objecting to an abstraction is not a requirement for it.
+Do not attribute recommendations to participants, do not quote or cite threads in your answer, and do not treat somebody's stated preference as a requirement. You are judging the change, not the discussion.`;
+var RUBRIC = `What to look at:
+- abstractions with one implementation and no boundary that presently needs one
+- interfaces, protocols, adapters or indirection created without a concrete need
+- factories, builders, managers, services, repositories or wrapper layers that do no work
+- file, class, type or module proliferation out of proportion to the change
+- generic solutions where the requirements are specific
+- extensibility and flexibility built for requirements that do not exist
+- optimisation with no measured constraint behind it
+- duplicated or redundant state machinery
+- lifecycle, state-machine, event-bus, observer or orchestration abstractions the flow does not need
+- defensive code for states that cannot occur at that boundary
+- the same validation repeated at several layers
+- configuration, flags, environment variables or options nobody asked for
+- third-party dependencies that earn less than they cost
+- pass-through layers adding vocabulary but no policy or isolation
+- indirection that makes the execution path materially harder to follow
+- error and retry machinery broader than the failures it faces
+- a large change where a materially smaller implementation looks feasible
+- repeated wrappers or conversions that could collapse
+- abstractions justified only by a hypothetical second implementation
+
+Fewer lines is evidence, not the objective. A twenty-line explicit implementation can be simpler than a five-line generic one. Judge simplicity by fewer concepts, fewer states, fewer sources of truth, fewer speculative abstractions, fewer indirections and less machinery needed to understand the behaviour.
+This is not a style review. Naming preferences, "extract this method", small tidy-ups and repetition that costs nobody any understanding are not recommendations.
+
+This is a list of things to look at, not a list of things to report. Every item here is sometimes exactly right. One implementation does not make an interface wrong: it may be a real external boundary, a testing seam, or a repository convention. More files do not make code worse. Judge what each thing is for and what it costs.`;
+var WORTH_KEEPING = `Complexity worth keeping:
+Look actively for complexity that is doing a job, and say so. This is not a politeness section — it is how the reader can tell you understood the change rather than counted its abstractions.
+Things that usually earn their keep: transaction boundaries protecting atomicity; write-and-rename protocols preventing corruption; security and permission boundaries; concurrency control; retry or idempotency logic against a boundary that has actually proven unreliable; compatibility adapters at a real external seam; validation at a trust boundary; abstractions with more than one real implementation, or that follow an established convention in this repository; anything an explicit requirement mandates.
+If nothing in this change needs the note, return an empty list. Do not pad it.`;
+var AUDIENCE_BLOCKS = {
+	author: `Who is reading this:
+The person who wrote this change, before they ask anyone to review it. They can act on what you say immediately.
+Be direct and specific. Say what to collapse, remove, inline, defer or replace. "Collapse these three classes into one" and "this abstraction has one implementation, remove it for now" are the register.
+Give enough of the trade-off that they do not flatten something that was load-bearing, and no more. They did not ask for diplomacy.
+Do not write draft pull request comments and do not set commentWorthiness. Nobody is being told anything by anyone here.`,
+	reviewer: `Who is reading this:
+Somebody reviewing another person's change. They are deciding what is worth raising, which is a different question from what is true.
+Explain why the implementation may be more complex than it needs to be, without asserting your judgement as fact. The author may know something you do not.
+Set commentWorthiness on every recommendation, and keep it separate from payoff: an observation can be entirely valid and still not be worth spending a review comment on.
+Where a comment is worth making, draft it. A good draft explains the concern, asks or recommends rather than instructs, and acknowledges the trade-off the author was probably making.
+Never write "bad code", "obvious", "over-engineered" or anything else that describes the author rather than the code.`
+};
+/**
+* The shape of the answer, written out whole.
+*
+* Never abbreviated, and never described in prose instead. A field the model is not shown is a
+* field it does not reliably produce, and a field the parser reads but the prompt never named is
+* how a result arrives parsed into nothing.
+*/
+var KISS_OUTPUT_INSTRUCTIONS = `Respond with a single JSON object, no markdown around it and no text before or after, matching exactly this shape:
+{
+  "assessment": string,
+  "summary": string,
+  "recommendations": [{
+    "id": string,
+    "title": string,
+    "payoff": "high_value" | "worth_considering" | "nit",
+    "gist": string,
+    "simplerDirection": string,
+    "gains": [string],
+    "reductionEstimate": string,
+    "caveat": string,
+    "evidence": string,
+    "whyNotJustified": string,
+    "payoffAndTradeoffs": string,
+    "commentWorthiness": "strong" | "consider" | "leave",
+    "draftComment": string,
+    "locations": [{ "path": string, "line": number, "primary": boolean }]
+  }],
+  "justifiedComplexity": [{
+    "id": string,
+    "title": string,
+    "reason": string,
+    "rationale": string,
+    "locations": [{ "path": string, "line": number, "primary": boolean }]
   }],
   "aggregateEstimate": string
 }
@@ -11500,6 +12522,7 @@ ${diff}`;
 		prompt,
 		budget: buildPromptBudget(sections),
 		discussionOverflow: discussion.overflow,
+		discussionThreadIds: discussion.includedThreadIds,
 		partiallyReadFiles: budgeted.partialFiles.length,
 		partialFiles: budgeted.partialFiles
 	};
@@ -11553,143 +12576,655 @@ function selectInlineDiffs(files, budget = PLUGIN_DIFF_BUDGET_CHARS) {
 	const inventoryOnly = [];
 	files.forEach((file, index) => (chosen.has(index) ? inline : inventoryOnly).push(file));
 	return {
-		inline,
-		inventoryOnly,
-		usedChars: used,
-		budgetChars: budget
+		inline,
+		inventoryOnly,
+		usedChars: used,
+		budgetChars: budget
+	};
+}
+/**
+* Every file the change touches, whether or not its diff came with it.
+*
+* Deliberately never truncated, however many files there are. The inventory is the one thing that
+* makes the budget above a context decision rather than a coverage ceiling: the moment it starts
+* eliding files, the review is back to describing a change it has not been told the shape of.
+*/
+function renderChangeInventory(files, inlinePaths) {
+	return `CHANGE INVENTORY
+Every file this change touches, complete. The diffs further down cover only the files marked
+"diff inline below"; the rest are not hidden from you and were not judged unimportant — they
+simply did not fit the context budget, and you have the working tree.
+
+${files.map((file) => {
+		const churn = `+${file.additions}/-${file.deletions}`;
+		const rename = file.previousName ? ` (was ${file.previousName})` : "";
+		const availability = inlinePaths.has(file.name) ? "diff inline below" : "diff not inline — open it in the working tree if this review needs it";
+		return `- ${file.name}${rename} · ${file.status} · ${churn} · ${availability}`;
+	}).join("\n")}`;
+}
+//#endregion
+//#region ../../packages/review-harness/src/guide/review_context.ts
+/**
+* Turn a local git change into everything Claude Code needs to write a ReviewGuide.
+*
+* Three concerns kept apart, because the extension had to fuse them and this client does not:
+*
+*   inventory  every changed file is named, always — the harness's job, and never truncated
+*   priority   where to start is the guide's call, made after reading; no ranking happens here
+*   budget     `PLUGIN_DIFF_BUDGET_CHARS` decides whose patch rides along, and nothing more
+*
+* A provider API given a diff cannot fetch what it was not sent, so for the extension a budget
+* *is* a coverage ceiling and the two collapse into one number. Here they do not, and treating
+* them as one is what produced "3 changed files were not analysed at all" for a client that
+* could have opened all three.
+*
+* Note what this still does not do: there is no planning call, and no ranking of any kind.
+* `processPRData` is handed exactly the files the budget already settled, so its own cap and its
+* largest-diff-first fallback can never bind — a second selection here would be the harness
+* deciding what matters, which is the one thing it must never do.
+*/
+async function buildReviewContext(options) {
+	const changeSet = await buildChangeSet(options);
+	const budget = options.diffBudgetChars ?? 3e5;
+	const lens = options.lens ?? { type: "standard" };
+	return {
+		contextId: randomUUID(),
+		...await assemble(changeSet, budget, lens)
+	};
+}
+/**
+* The same context with the pull request's conversation folded in.
+*
+* A new context rather than a mutation of the old one, and rebuilt through the same assembly:
+* the model can only cite a thread whose `[T_...]` marker is in the prompt it was given, so the
+* prompt has to be produced again once the threads exist. Doing that through `assemble` rather
+* than by appending a discussion block is what keeps one prompt builder — a second, hand-written
+* copy is how two clients start disagreeing about what a review prompt contains.
+*
+* The change set is left exactly as git reported it. The pull request is a fact about a forge,
+* kept beside the change rather than written into it, so nothing downstream can mistake one for
+* the other.
+*/
+async function withPrContext(context, prContext) {
+	return {
+		...context,
+		...await assemble(context.changeSet, context.diffBudgetChars, context.lens, prContext),
+		contextId: context.contextId,
+		prContext
+	};
+}
+async function assemble(changeSet, budget, lens, prContext) {
+	const allFiles = changeSet.data.files;
+	const selection = selectInlineDiffs(allFiles, budget);
+	const inlinePaths = new Set(selection.inline.map((file) => file.name));
+	const processed = await processPRData({
+		...changeSet.data,
+		files: selection.inline,
+		changedFileCount: allFiles.length,
+		...prContext ? { pullRequest: pullRequestFor(changeSet.data.pullRequest, prContext) } : {},
+		discussion: prContext?.discussion
+	}, selection.inline.length, null);
+	const shared = {
+		repositoryAccess: "repository",
+		changeInventory: renderChangeInventory(allFiles, inlinePaths)
+	};
+	const { prompt, discussionOverflow, discussionThreadIds } = lens.type === "kiss" ? buildKissPrompt(processed, {
+		...shared,
+		audience: lens.audience
+	}) : buildStructuredReviewPrompt(processed, {
+		...shared,
+		guideCoverage: "review-path"
+	});
+	return {
+		lens,
+		instructions: prompt,
+		diff: buildDiffText(selection.inline),
+		changeSet,
+		processed,
+		fileCoverage: {
+			...processed.fileCoverage,
+			repositoryAvailable: true
+		},
+		inventoryOnlyFiles: selection.inventoryOnly.map((file) => file.name),
+		diffBudgetChars: budget,
+		discussionOverflow: discussionOverflow ?? false,
+		...prContext ? { deliveredDiscussion: withoutOmittedThreads(prContext.discussion, processed.discussion.all.map((thread) => thread.id), discussionThreadIds ?? []) } : {}
+	};
+}
+/**
+* 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
+* the same quantity is a number nobody can explain the day it binds.
+*/
+function buildDiffText(files) {
+	return files.map((file) => `--- ${file.name}\n${file.patch}`).join("\n\n");
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/agent_env.ts
+/**
+* The environment a review's later runs are pinned to: the job's, not the daemon's.
+*
+* A job records what it must run under at the moment it is created, and the analysis reads it back
+* from there. Every run that happens *after* the analysis read `captureEnv()` instead, which
+* answers a question about the daemon rather than about the review, and the daemon is the process
+* that happened to be started first by whichever shell got there first. Two things went wrong with
+* that. `CLAUDE_CONFIG_DIR` decides which account answers, so a review made under one and revisited
+* under another is served by a Claude that may not have access to the same models or settings. And
+* `agentId` decides which adapter runs at all, so a review made by one agent had its questions
+* answered, and its findings reconciled, by whichever is default today, silently, with the result
+* still shown as the review's.
+*
+* Three callers, and they are exactly the three things a reviewer can ask of a review after it is
+* written: a question in the Ask panel, bringing the analysis up to date, and re-reading the
+* conversation. All three put the answer on the page under the review's own name, so all three owe
+* the reader the review's own agent.
+*
+* Falling back to capturing now covers a workspace with no job and one whose job has aged out of
+* retention, and that fallback is not the rare path: jobs are finished business within hours and
+* reviews are kept for thirty days, so most questions asked of an older review find nothing here.
+*
+* Which is why it captures for *the review's own agent* rather than the default one. Capturing for
+* the default reintroduced the exact bug this module exists to fix, one retention period later and
+* far more quietly: a review made by Codex, asked a question a day after its job was swept, would
+* have been answered by Claude with the answer shown as the review's. The environment has to be
+* captured now, because it genuinely is all there is left to read. Who to capture it for is a fact
+* the review still holds.
+*/
+function agentEnvOf(workspace) {
+	const job = workspace.jobId ? loadJob(workspace.jobId) : null;
+	if (job?.env) return job.env;
+	const id = agentIdOf(workspace.session);
+	return (AGENT_IDS.includes(id) ? agentById(id) : defaultAgent()).captureEnv();
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/discussion/discussion_attribution.ts
+/**
+* Every surviving attribution has its author, status and link taken from the real thread — the
+* model's only contribution is which thread it points at. Anything it echoed back about who said
+* what is discarded, so a correct id can't smuggle a wrong attribution alongside it.
+*/
+function attributeIssuesToDiscussion(result, pd) {
+	let attributed = 0;
+	let rejected = 0;
+	const issues = result.issues.map((issue) => {
+		if (!issue.existingDiscussion) return issue;
+		const thread = pd.byId[issue.existingDiscussion.threadId];
+		if (!thread) {
+			rejected++;
+			const { existingDiscussion: _dropped, ...rest } = issue;
+			return rest;
+		}
+		attributed++;
+		return {
+			...issue,
+			existingDiscussion: {
+				threadId: thread.id,
+				raisedBy: thread.comments[0]?.author ?? "unknown",
+				status: thread.resolved ? "resolved" : "unresolved",
+				url: thread.comments[0]?.url || void 0,
+				relation: issue.existingDiscussion.relation === "related" ? "related" : "same"
+			}
+		};
+	});
+	return {
+		result: {
+			...result,
+			issues
+		},
+		attributed,
+		rejected
+	};
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/discussion_diff.ts
+/**
+* What moved in a pull request conversation between two imports.
+*
+* Pure, and deliberately only counting. The workspace's job here is to say what changed, not what
+* it means — "two threads were resolved since you last looked" is a fact; whether that settles the
+* findings attached to them is a judgement, and judgement belongs to the analyser.
+*
+* A projection of `diffDiscussion`, so the sentence a re-read shows and the delta an update reasons
+* from are one computation and cannot disagree about what moved. That brings its rules with it:
+* bots are not counted, and a thread or comment is called gone only where both imports prove they
+* held the whole of it.
+*/
+function diffDiscussions(before, after) {
+	return countsOf(diffDiscussion(before, after));
+}
+function countsOf(delta) {
+	return {
+		newThreads: new Set(delta.added.filter((entry) => entry.newThread).map((entry) => entry.thread.id)).size,
+		vanishedThreads: delta.vanishedThreads.length,
+		resolvedSince: delta.resolved.length,
+		reopenedSince: delta.reopened.length,
+		newComments: delta.added.length,
+		editedComments: delta.edited.length,
+		removedComments: delta.removed.length,
+		newReviews: delta.newReviews.length
+	};
+}
+/** Nothing moved. Worth its own answer: "checked, and nothing changed" is a useful thing to hear. */
+function isUnchanged(changes) {
+	return changes.newThreads === 0 && changes.vanishedThreads === 0 && changes.resolvedSince === 0 && changes.reopenedSince === 0 && changes.newComments === 0 && !changes.editedComments && !changes.removedComments && !changes.newReviews;
+}
+/**
+* The change, in a sentence, newest-mattering first.
+*
+* Resolutions lead because they are the ones that make a standing claim in this review false —
+* an "already raised … still unresolved" line that is no longer true is the reason this whole
+* re-check exists.
+*/
+function describeChanges(changes) {
+	if (isUnchanged(changes)) return "Nothing has changed in the conversation since it was imported.";
+	const parts = [];
+	const plural = (count, one, many) => `${count} ${count === 1 ? one : many}`;
+	if (changes.resolvedSince > 0) parts.push(`${plural(changes.resolvedSince, "thread", "threads")} resolved since`);
+	if (changes.reopenedSince > 0) parts.push(`${plural(changes.reopenedSince, "thread", "threads")} reopened`);
+	if (changes.newThreads > 0) parts.push(`${plural(changes.newThreads, "new thread", "new threads")}`);
+	if (changes.newComments > 0) parts.push(`${plural(changes.newComments, "new comment", "new comments")}`);
+	if (changes.newReviews) parts.push(`${plural(changes.newReviews, "new review", "new reviews")}`);
+	if (changes.editedComments) parts.push(`${plural(changes.editedComments, "comment", "comments")} edited`);
+	if (changes.removedComments) parts.push(`${plural(changes.removedComments, "comment", "comments")} deleted`);
+	if (changes.vanishedThreads > 0) parts.push(`${plural(changes.vanishedThreads, "thread", "threads")} no longer present`);
+	return `${parts.join(", ")}.`;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/pr_refresh.ts
+/**
+* Re-read the pull request conversation, without re-reviewing anything.
+*
+* The problem this solves is narrow and specific. Every "Already raised by @sarah · thread still
+* unresolved" line in a review is a fact that was true at import and is frozen. Nothing re-checks
+* it, so an hour after Sarah resolves that thread the workspace is still telling the reviewer she
+* is waiting on it: a confident, specific, wrong claim about what a named colleague thinks.
+*
+* **This is not a re-review, and the distinction is the whole design.** Re-reading the conversation
+* can only update the state of findings that already exist: who raised the thread, whether it is
+* open, where it links to. It cannot produce a new finding, and it must not try. Deciding that a
+* new comment invalidates a finding, or that a new commit introduced a bug, is judgement, and
+* judgement belongs to the analyser. `attributeIssuesToDiscussion` is what runs here, and it is
+* arithmetic: the model's only surviving contribution is which thread each finding points at.
+*
+* This used to spawn an agent in the reviewer's own checkout and ask it to fetch the conversation.
+* It now asks the forge adapter, which is a couple of subprocess calls and answers in seconds
+* rather than minutes. The daemon still reaches no forge itself and still holds no credential: the
+* adapter drives the CLI the developer has already signed in to, exactly as the review drives the
+* agent they have already signed in to.
+*/
+/**
+* Computes; does not persist. The route saves, so a test can run the whole thing without writing
+* into the reviewer's own store.
+*/
+async function refreshPrContext(workspace, fetch = refetchConversation) {
+	const startedAt = Date.now();
+	if (!workspace.prContext) return {
+		at: Date.now(),
+		startedAt,
+		ok: false,
+		message: "This review has no pull request conversation attached, so there is nothing to re-read."
+	};
+	const pr = workspace.prContext.pullRequest;
+	const outcome = await fetch(workspace.repoPath, {
+		url: pr.url,
+		number: pr.number
+	}, agentEnvOf(workspace));
+	if (outcome.kind !== "attached") return {
+		at: Date.now(),
+		startedAt,
+		ok: false,
+		message: `${whyNot(outcome)} Nothing here has changed, and the discussion shown is still the one that came with the review.`,
+		reason: outcome.kind
+	};
+	const fetched = outcome.context;
+	const before = workspace.prContext.discussion;
+	const changes = diffDiscussions(before, fetched.discussion);
+	const restated = reattribute(workspace, fetched.discussion);
+	workspace.prContext = {
+		pullRequest: {
+			...workspace.prContext.pullRequest,
+			...movable(fetched.pullRequest)
+		},
+		discussion: fetched.discussion
+	};
+	workspace.lastPrRefresh = {
+		at: Date.now(),
+		startedAt,
+		ok: true,
+		message: describeChanges(changes),
+		changes,
+		...restated
+	};
+	return workspace.lastPrRefresh;
+}
+/**
+* Why the re-check did not happen, in the tense a person clicking a button is standing in.
+*
+* The same closed union the review's own disclosure renders, and deliberately not the same
+* sentences. Those are written about a review that has already been made; these are written about
+* a button that has just been pressed and did nothing.
+*/
+function whyNot(outcome) {
+	switch (outcome.kind) {
+		case "no-request": return "The pull request this review is attached to could not be found.";
+		case "unsupported-forge": return outcome.host ? `PR Review Buddy does not read pull request conversation on ${outcome.host} yet.` : "This repository has no remote to look the pull request up on.";
+		case "cli-missing": return `\`${outcome.cli}\` is not installed here, so the pull request could not be re-read.`;
+		case "not-authenticated": return `\`${outcome.cli}\` is not signed in, so the pull request could not be re-read. Run \`${outcome.cli} auth login\` and try again.`;
+		case "failed": return `The pull request could not be re-read. ${outcome.detail}`;
+	}
+}
+/**
+* Which fields a re-read may update, and why these.
+*
+* The head SHA and title move on their own as the request gains commits, and the two link shapes
+* are how this product gets from a file here to the same file there. Number, url and provider are
+* identity and stay as attached: a re-read does not move a review onto a different pull request.
+*/
+function movable(fetched) {
+	const updates = {};
+	const copy = (field) => {
+		const value = fetched[field];
+		if (value !== void 0 && value !== "" && value !== null) updates[field] = value;
+	};
+	copy("headSha");
+	copy("title");
+	if (typeof fetched.body === "string") updates.body = fetched.body;
+	copy("filesUrl");
+	copy("fileUrlTemplate");
+	copy("author");
+	return updates;
+}
+/**
+* Re-derive every attribution from the threads as they now are.
+*
+* The same function the review's own attribution pass used, run again against fresh threads. It
+* rebuilds author, status and link from the real thread and drops any claim whose thread is no
+* longer there, so nothing the model once said can outlive the conversation that justified it.
+*/
+function reattribute(workspace, discussion) {
+	const result = workspace.session.result;
+	if (!result) return {
+		attributionsWithdrawn: 0,
+		attributionsRestated: 0
+	};
+	const before = new Map(result.issues.map((issue) => [issue.id, issue.existingDiscussion?.status]));
+	const outcome = attributeIssuesToDiscussion(result, processDiscussion(discussion));
+	workspace.session = {
+		...workspace.session,
+		result: outcome.result
+	};
+	const restated = outcome.result.issues.filter((issue) => issue.existingDiscussion && before.get(issue.id) !== issue.existingDiscussion.status).length;
+	return {
+		attributionsWithdrawn: outcome.rejected,
+		attributionsRestated: restated
 	};
 }
+//#endregion
+//#region ../../packages/review-harness/src/workspace/conversation_context.ts
 /**
-* Every file the change touches, whether or not its diff came with it.
+* The pull request conversation, prepared by the harness for a model to reason over.
 *
-* Deliberately never truncated, however many files there are. The inventory is the one thing that
-* makes the budget above a context decision rather than a coverage ceiling: the moment it starts
-* eliding files, the review is back to describing a change it has not been told the shape of.
+* Every model-facing path that can reason about a pull request starts here, so each of them gets
+* the same three facts the same way: whether there is a conversation, how fresh it is, and what in
+* it has changed since the analysis being built on. The harness answers those. What any of it
+* means for the review is the model's question, and nothing here tries to answer it.
+*
+* The fetch stays where it was, in the forge adapter, which returns a whole snapshot. "What
+* changed" is computed here between two snapshots, so no forge has to support asking for changes.
 */
-function renderChangeInventory(files, inlinePaths) {
-	return `CHANGE INVENTORY
-Every file this change touches, complete. The diffs further down cover only the files marked
-"diff inline below"; the rest are not hidden from you and were not judged unimportant — they
-simply did not fit the context budget, and you have the working tree.
-
-${files.map((file) => {
-		const churn = `+${file.additions}/-${file.deletions}`;
-		const rename = file.previousName ? ` (was ${file.previousName})` : "";
-		const availability = inlinePaths.has(file.name) ? "diff inline below" : "diff not inline — open it in the working tree if this review needs it";
-		return `- ${file.name}${rename} · ${file.status} · ${churn} · ${availability}`;
-	}).join("\n")}`;
-}
-//#endregion
-//#region ../../packages/review-harness/src/guide/review_context.ts
 /**
-* Turn a local git change into everything Claude Code needs to write a ReviewGuide.
-*
-* Three concerns kept apart, because the extension had to fuse them and this client does not:
+* The conversation the current analysis took into account, or why that cannot be known.
 *
-*   inventory  every changed file is named, always — the harness's job, and never truncated
-*   priority   where to start is the guide's call, made after reading; no ranking happens here
-*   budget     `PLUGIN_DIFF_BUDGET_CHARS` decides whose patch rides along, and nothing more
+* Recorded since this was introduced. For a review made before then, the stored conversation is
+* still exactly what the analysis was given provided nothing has re-read it since the analysis
+* was made, so it is used rather than discarded. Once a re-read has replaced it, what the analysis
+* saw is gone, and the answer is `unknown`: offered as possibly new rather than claimed as new.
 *
-* A provider API given a diff cannot fetch what it was not sent, so for the extension a budget
-* *is* a coverage ceiling and the two collapse into one number. Here they do not, and treating
-* them as one is what produced "3 changed files were not analysed at all" for a client that
-* could have opened all three.
+* A record naming a different session describes an analysis this review no longer holds, and is
+* unknown for the same reason. It is never taken as this one's.
+*/
+function analysedBaselineOf(workspace) {
+	const recorded = workspace.analysedConversation;
+	if (recorded) return recorded.sessionId === workspace.session.id ? recorded.discussion : "unknown";
+	if (!workspace.prContext) return null;
+	const generatedAt = workspace.session.metadata?.generatedAt;
+	const reread = workspace.lastPrRefresh;
+	if (typeof generatedAt !== "number") return "unknown";
+	if (reread && reread.ok && reread.at >= generatedAt) return "unknown";
+	return workspace.prContext.discussion;
+}
+/**
+* Record a legacy review's baseline before anything re-reads the conversation over it.
 *
-* Note what this still does not do: there is no planning call, and no ranking of any kind.
-* `processPRData` is handed exactly the files the budget already settled, so its own cap and its
-* largest-diff-first fallback can never bind — a second selection here would be the harness
-* deciding what matters, which is the one thing it must never do.
+* The derivation above holds only until the first re-read, which replaces the copy it reads. So
+* every path that re-reads calls this first, and the save that follows writes it with the re-read
+* (`saveRefresh`, or the update's own write). After that the review has a recorded baseline like any
+* other, and nothing is lost by the re-read. A no-op on a review that already has one, or whose
+* baseline is already unknowable.
 */
-async function buildReviewContext(options) {
-	const changeSet = await buildChangeSet(options);
-	const budget = options.diffBudgetChars ?? 3e5;
-	const lens = options.lens ?? { type: "standard" };
-	return {
-		contextId: randomUUID(),
-		...await assemble(changeSet, budget, lens)
+function adoptLegacyBaseline(workspace) {
+	if (workspace.analysedConversation) return;
+	const baseline = analysedBaselineOf(workspace);
+	if (baseline === "unknown" || !workspace.prContext) return;
+	workspace.analysedConversation = {
+		sessionId: workspace.session.id,
+		discussion: baseline
 	};
 }
+/** What a failed re-read can say about itself in a prompt. `no-request` there means the request vanished. */
+function rereadReasonOf(outcome) {
+	const reason = outcome.reason;
+	return reason === "unsupported-forge" || reason === "cli-missing" || reason === "not-authenticated" ? reason : "failed";
+}
 /**
-* The same context with the pull request's conversation folded in.
+* The conversation for one model run.
 *
-* A new context rather than a mutation of the old one, and rebuilt through the same assembly:
-* the model can only cite a thread whose `[T_...]` marker is in the prompt it was given, so the
-* prompt has to be produced again once the threads exist. Doing that through `assemble` rather
-* than by appending a discussion block is what keeps one prompt builder — a second, hand-written
-* copy is how two clients start disagreeing about what a review prompt contains.
+* With `reread`, the conversation is fetched again first, through the same re-read the Re-check
+* button uses, so a question about "the new comments" is answered from the request as it is now.
+* A re-read that fails leaves the stored copy in place and is stated as stale rather than hidden.
+* The re-read changes `workspace` in memory only; `refresh` is returned for the caller to save.
 *
-* The change set is left exactly as git reported it. The pull request is a fact about a forge,
-* kept beside the change rather than written into it, so nothing downstream can mistake one for
-* the other.
+* `rereadOutcome` is for a caller that has already re-read for reasons of its own (an update does,
+* before it decides anything): its outcome is stated rather than a second fetch made.
 */
-async function withPrContext(context, prContext) {
+async function prepareConversation(workspace, options) {
+	if (!workspace.prContext) return { prepared: { state: { kind: "not-attached" } } };
+	let refresh = options.rereadOutcome;
+	let reread = refresh ? refresh.ok ? "fresh" : "failed" : "skipped";
+	if (options.reread && !refresh) {
+		adoptLegacyBaseline(workspace);
+		const startedAt = Date.now();
+		try {
+			refresh = options.fetch ? await refreshPrContext(workspace, options.fetch) : await refreshPrContext(workspace);
+		} catch {
+			refresh = unforeseenFailure(startedAt);
+		}
+		reread = refresh.ok ? "fresh" : "failed";
+	}
 	return {
-		...context,
-		...await assemble(context.changeSet, context.diffBudgetChars, context.lens, prContext),
-		contextId: context.contextId,
-		prContext
+		prepared: storedConversation(workspace, reread, refresh && !refresh.ok ? rereadReasonOf(refresh) : void 0),
+		...refresh && !options.rereadOutcome ? { refresh } : {}
 	};
 }
-async function assemble(changeSet, budget, lens, prContext) {
-	const allFiles = changeSet.data.files;
-	const selection = selectInlineDiffs(allFiles, budget);
-	const inlinePaths = new Set(selection.inline.map((file) => file.name));
-	const processed = await processPRData({
-		...changeSet.data,
-		files: selection.inline,
-		changedFileCount: allFiles.length,
-		...prContext ? { pullRequest: pullRequestFor(changeSet.data.pullRequest, prContext) } : {},
-		discussion: prContext?.discussion
-	}, selection.inline.length, null);
-	const shared = {
-		repositoryAccess: "repository",
-		changeInventory: renderChangeInventory(allFiles, inlinePaths)
+/**
+* Every way the fetch can fail is an outcome rather than an exception, so a throw means something
+* unforeseen did. The honest thing to say about it is that nothing changed.
+*/
+function unforeseenFailure(startedAt) {
+	return {
+		at: Date.now(),
+		startedAt,
+		ok: false,
+		message: "The pull request could not be re-read. Nothing here has changed.",
+		reason: "failed"
 	};
-	const { prompt, discussionOverflow } = lens.type === "kiss" ? buildKissPrompt(processed, {
-		...shared,
-		audience: lens.audience
-	}) : buildStructuredReviewPrompt(processed, {
-		...shared,
-		guideCoverage: "review-path"
+}
+/**
+* The longest a Buddy AI turn waits for the conversation before it answers without the re-read.
+*
+* A product decision, not a measurement (2026-10-11): about two seconds is the aim and three the
+* hard ceiling, because an assistant that pauses before every answer feels broken however fresh
+* its facts. Measured against it: a small request re-reads in 0.6 to 0.75 seconds; one with
+* hundreds of threads and reviews takes 3.4 to 4, and so answers from the stored copy, stated as
+* stale, while the re-read finishes and is saved for the next turn.
+*/
+var ASK_REREAD_CEILING_MS = CONVERSATION_REREAD_CEILING_MS;
+/**
+* `prepareConversation` with a re-read that may take no longer than `ceilingMs`.
+*
+* The re-read runs on a copy of the review, so one that misses the ceiling cannot change the
+* review in memory while the turn is built from it. One that lands in time is taken over onto the
+* review and returned for the caller to save. One that lands late is saved by itself when it does,
+* through the same guarded save, so the next turn has it.
+*/
+async function prepareConversationWithin(workspace, ceilingMs, fetch) {
+	if (!workspace.prContext) return { prepared: { state: { kind: "not-attached" } } };
+	adoptLegacyBaseline(workspace);
+	const reattributing = JSON.stringify(workspace.session.result);
+	const copy = structuredClone(workspace);
+	const startedAt = Date.now();
+	const reread = (async () => {
+		try {
+			return fetch ? await refreshPrContext(copy, fetch) : await refreshPrContext(copy);
+		} catch {
+			return unforeseenFailure(startedAt);
+		}
+	})();
+	let timer;
+	const late = new Promise((resolve) => {
+		timer = setTimeout(() => resolve("late"), ceilingMs);
 	});
+	const first = await Promise.race([reread, late]);
+	clearTimeout(timer);
+	if (first === "late") {
+		reread.then((outcome) => saveRefresh(copy, outcome, reattributing)).catch(() => void 0);
+		return { prepared: storedConversation(workspace, "failed", "too-slow") };
+	}
+	workspace.prContext = copy.prContext;
+	workspace.session = copy.session;
 	return {
-		lens,
-		instructions: prompt,
-		diff: buildDiffText(selection.inline),
-		changeSet,
-		processed,
-		fileCoverage: {
-			...processed.fileCoverage,
-			repositoryAvailable: true
-		},
-		inventoryOnlyFiles: selection.inventoryOnly.map((file) => file.name),
-		diffBudgetChars: budget,
-		discussionOverflow: discussionOverflow ?? false
+		prepared: storedConversation(workspace, first.ok ? "fresh" : "failed", first.ok ? void 0 : rereadReasonOf(first)),
+		refresh: first
 	};
 }
 /**
-* 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.
+* The conversation as the review holds it, with no fetch: what `prepareConversation` returns once
+* any re-read is done, and what a prompt builder states when nobody prepared one for it.
 */
-function pullRequestFor(local, prContext) {
-	const body = prContext.pullRequest.body;
-	if (!body) return local;
-	const { bodySource: _commits, ...rest } = local;
+function storedConversation(workspace, reread = "skipped", rereadReason) {
+	if (!workspace.prContext) return { state: { kind: "not-attached" } };
+	const discussion = workspace.prContext.discussion;
 	return {
-		...rest,
-		body
+		state: {
+			kind: "attached",
+			fetchedAt: discussion.fetchedAt,
+			reread,
+			...reread === "failed" && rereadReason ? { rereadReason } : {}
+		},
+		discussion,
+		delta: diffDiscussion(analysedBaselineOf(workspace), discussion)
 	};
 }
 /**
-* The inline patches as one blob, for grounding the assistant.
+* Put a re-read on disk: the one save the Re-check button and the assistant both make.
 *
-* No ceiling of its own. `selectInlineDiffs` already bounded this, and a second constant guarding
-* the same quantity is a number nobody can explain the day it binds.
+* Re-reads overlap. A Buddy AI turn's can miss its ceiling and land seconds later, after the next
+* turn or the Re-check button has saved a newer one, so this save checks what is on disk before
+* writing anything over it:
+*
+* - A re-read that failed never writes the conversation or the pull request. It holds only the
+*   copy it started from, and writing that back would restore an older conversation over a newer
+*   one. It is recorded as the latest attempt only if it is: nothing on disk began after it did.
+* - A re-read that worked writes only if its fetch began no earlier than the one on disk did. A
+*   slow one that finishes after a quicker, later one saved is older, however late it finished,
+*   and is dropped whole. When it began is `requestedAt`; see `orderOf`.
+*
+* Its findings go only if they are still the findings on disk: an update that landed meanwhile
+* wrote a newer analysis, and putting these back would undo it. That update re-read the
+* conversation for itself, so nothing is lost by leaving its findings alone.
+*
+* `reattributing` is the findings as they stood before the re-read began, serialised.
 */
-function buildDiffText(files) {
-	return files.map((file) => `--- ${file.name}\n${file.patch}`).join("\n\n");
+function saveRefresh(workspace, outcome, reattributing) {
+	workspace.lastPrRefresh = outcome;
+	mutateWorkspace(workspace.id, (current) => {
+		const adopted = workspace.analysedConversation;
+		if (!current.analysedConversation && adopted && adopted.sessionId === current.session.id) current.analysedConversation = adopted;
+		if (!outcome.ok) {
+			if (!overtaken(current, outcome)) current.lastPrRefresh = outcome;
+			return;
+		}
+		if (workspace.prContext) {
+			if (!atLeastAsNew(workspace.prContext.discussion, current)) return;
+			current.prContext = workspace.prContext;
+		}
+		current.lastPrRefresh = outcome;
+		if (JSON.stringify(current.session.result) === reattributing) current.session = {
+			...current.session,
+			result: workspace.session.result
+		};
+	});
+}
+/** Whether something on disk is newer than a failed attempt: another attempt begun after it, or a conversation fetched after it began. */
+function overtaken(current, outcome) {
+	const began = outcome.startedAt ?? outcome.at;
+	const recorded = current.lastPrRefresh;
+	if (recorded && (recorded.startedAt ?? recorded.at) > began) return true;
+	const onDisk = current.prContext ? orderOf(current.prContext.discussion) : void 0;
+	return onDisk !== void 0 && onDisk > began;
+}
+/**
+* Where a snapshot falls in time: when its fetch began. A snapshot from before that was recorded
+* has only when it finished, which is no earlier than when it began, so it is never taken as older
+* than it is.
+*/
+function orderOf(discussion) {
+	const at = discussion.requestedAt ?? discussion.fetchedAt;
+	return typeof at === "number" && Number.isFinite(at) ? at : void 0;
+}
+function atLeastAsNew(discussion, current) {
+	const onDisk = current.prContext ? orderOf(current.prContext.discussion) : void 0;
+	const ours = orderOf(discussion);
+	return onDisk === void 0 || ours === void 0 || ours >= onDisk;
+}
+/**
+* What a review's own fetch came to, as the state its prompt states.
+*
+* The outcome is the job's record of the `conversation` phase. `attached` is dated by the copy the
+* prompt was actually built from, which a re-read may have replaced since the phase ran.
+*/
+function stateOfOutcome(outcome, prContext) {
+	switch (outcome.kind) {
+		case "attached": return prContext ? {
+			kind: "attached",
+			fetchedAt: prContext.discussion.fetchedAt,
+			reread: "skipped"
+		} : { kind: "not-attached" };
+		case "no-request": return { kind: "no-request" };
+		case "unsupported-forge":
+		case "cli-missing":
+		case "not-authenticated":
+		case "failed": return {
+			kind: "unavailable",
+			reason: outcome.kind
+		};
+	}
 }
 //#endregion
 //#region ../../packages/review-harness/src/domain/kiss/parse.ts
@@ -11932,45 +13467,6 @@ async function validateKiss(raw, changedPaths, existingPaths) {
 	};
 }
 //#endregion
-//#region ../../packages/review-harness/src/domain/discussion/discussion_attribution.ts
-/**
-* Every surviving attribution has its author, status and link taken from the real thread — the
-* model's only contribution is which thread it points at. Anything it echoed back about who said
-* what is discarded, so a correct id can't smuggle a wrong attribution alongside it.
-*/
-function attributeIssuesToDiscussion(result, pd) {
-	let attributed = 0;
-	let rejected = 0;
-	const issues = result.issues.map((issue) => {
-		if (!issue.existingDiscussion) return issue;
-		const thread = pd.byId[issue.existingDiscussion.threadId];
-		if (!thread) {
-			rejected++;
-			const { existingDiscussion: _dropped, ...rest } = issue;
-			return rest;
-		}
-		attributed++;
-		return {
-			...issue,
-			existingDiscussion: {
-				threadId: thread.id,
-				raisedBy: thread.comments[0]?.author ?? "unknown",
-				status: thread.resolved ? "resolved" : "unresolved",
-				url: thread.comments[0]?.url || void 0,
-				relation: issue.existingDiscussion.relation === "related" ? "related" : "same"
-			}
-		};
-	});
-	return {
-		result: {
-			...result,
-			issues
-		},
-		attributed,
-		rejected
-	};
-}
-//#endregion
 //#region ../../packages/review-harness/src/git/tree.ts
 /**
 * Which of these paths the commit actually holds.
@@ -14734,14 +16230,14 @@ async function drive(jobId, workspaceId, runners, driver, signal) {
 		signal?.throwIfAborted();
 		job = update(job, "analysing", "Analysing the change");
 		let observedModel;
-		const payload = await runAnalysisFor(job, workspaceId, runners, signal, (model) => {
+		const { payload, delivered } = await runAnalysisFor(job, workspaceId, runners, signal, (model) => {
 			observedModel = model;
 		});
 		signal?.throwIfAborted();
 		if (!commitJob(job.id)) throw new AgentCancelledError("Cancelled from the workspace page.");
 		const versionOf = runners.agentVersion ?? installedAgentVersion$1;
 		if (job.reviewType === "kiss") await applyKiss(job, workspaceId, payload, versionOf, observedModel);
-		else await applyGuide(job, workspaceId, payload, versionOf, () => measurementOf(from, startedAt, now()), observedModel);
+		else await applyGuide(job, workspaceId, payload, delivered, versionOf, () => measurementOf(from, startedAt, now()), observedModel);
 		job = update(job, "done");
 		const completedAt = now();
 		recordAnalysisRuntime(job, workspaceId, from, completedAt - startedAt, completedAt, observedModel);
@@ -14946,7 +16442,13 @@ async function contextFor(job, workspaceId) {
 		...baseFor(job.target),
 		...expectedFor(job.target)
 	});
-	return stored.prContext ? withPrContext(base, stored.prContext) : base;
+	const context = stored.prContext ? await withPrContext(base, stored.prContext) : base;
+	if (!job.conversation) return context;
+	const state = stateOfOutcome(job.conversation, stored.prContext);
+	return {
+		...context,
+		instructions: `${context.instructions}\n\n---\n\n${conversationStateBlock(state)}`
+	};
 }
 /** As `contextFor`, starting from the workspace alone by way of the job it belongs to. */
 async function contextOf(stored) {
@@ -14954,6 +16456,7 @@ async function contextOf(stored) {
 }
 async function runAnalysisFor(job, workspaceId, runners, signal, onObservedModel) {
 	const context = await contextFor(job, workspaceId);
+	const delivered = context.deliveredDiscussion ?? null;
 	const onProgress = (text) => {
 		const current = loadJob(job.id);
 		if (current) saveJob({
@@ -14962,26 +16465,32 @@ async function runAnalysisFor(job, workspaceId, runners, signal, onObservedModel
 			updatedAt: Date.now()
 		});
 	};
-	if (runners.analyse) return runners.analyse({
-		prompt: context.instructions,
-		cwd: job.worktreePath,
-		onProgress,
-		...onObservedModel ? { onObservedModel } : {},
-		signal
-	});
+	if (runners.analyse) return {
+		payload: await runners.analyse({
+			prompt: context.instructions,
+			cwd: job.worktreePath,
+			onProgress,
+			...onObservedModel ? { onObservedModel } : {},
+			signal
+		}),
+		delivered
+	};
 	const kissRunId = job.reviewType === "kiss" ? (loadWorkspace(workspaceId)?.kissRuns ?? []).find((run) => run.jobId === job.id)?.id : void 0;
-	return withUsageRecorded(workspaceId, job.reviewType === "kiss" ? "kiss" : "analysis", job.env, (onUsage) => agentFor(job.env).run({
-		capability: "read-code",
-		prompt: context.instructions,
-		cwd: job.worktreePath,
-		originRepoPath: job.target.originRepoPath,
-		env: job.env,
-		...job.requestedModel ? { requestedModel: job.requestedModel } : {},
-		onProgress,
-		onUsage,
-		...onObservedModel ? { onObservedModel } : {},
-		signal
-	}), kissRunId, job.requestedModel);
+	return {
+		payload: await withUsageRecorded(workspaceId, job.reviewType === "kiss" ? "kiss" : "analysis", job.env, (onUsage) => agentFor(job.env).run({
+			capability: "read-code",
+			prompt: context.instructions,
+			cwd: job.worktreePath,
+			originRepoPath: job.target.originRepoPath,
+			env: job.env,
+			...job.requestedModel ? { requestedModel: job.requestedModel } : {},
+			onProgress,
+			onUsage,
+			...onObservedModel ? { onObservedModel } : {},
+			signal
+		}), kissRunId, job.requestedModel),
+		delivered
+	};
 }
 /**
 * Write a finished KISS analysis onto the run that asked for it.
@@ -15030,7 +16539,7 @@ function failCurrentKissRun(workspaceId, job, reason, kind, rejectedAnswer) {
 		failKissRun(stored, run.id, reason, kind, rejectedAnswer);
 	});
 }
-async function applyGuide(job, workspaceId, payload, versionOf, measure, observedModel) {
+async function applyGuide(job, workspaceId, payload, delivered, versionOf, measure, observedModel) {
 	const stored = loadWorkspace(workspaceId);
 	const context = await contextOf(stored);
 	let applied;
@@ -15055,7 +16564,11 @@ async function applyGuide(job, workspaceId, payload, versionOf, measure, observe
 		...fresh,
 		session: keepReviewerFields(fresh, session),
 		audit: applied.audit,
-		referencedFiles: applied.referencedFiles
+		referencedFiles: applied.referencedFiles,
+		analysedConversation: {
+			sessionId: session.id,
+			discussion: delivered
+		}
 	}));
 }
 /**
@@ -16096,64 +17609,27 @@ async function recordKissRun(input) {
 			...requestedModel ? { requestedModel } : {}
 		});
 		mutateWorkspace(workspace.id, (current) => {
-			current.kissRuns = [...current.kissRuns ?? [], run];
-			current.latestKissRunId = run.id;
-		});
-		return job;
-	});
-	if (isBusy(started)) throw new ReviewBeingDeletedError();
-	return started;
-}
-/**
-* Record the run and drive it to its end.
-*
-* The lock is released before the analysis begins, exactly as `reanalyseReview` does, so a deletion
-* during the twenty minutes that follow is refused by the live job claim rather than made to wait
-* for it.
-*
-* Counted by `track` from the first await, so a restart is refused for the whole of the run rather
-* than only once a caller remembered to count it. Only the server calls this; the CLI records the
-* run and drives it in its own process.
-*/
-function startKissJob(input, runners = {}) {
-	return track(recordKissRun(input).then((job) => runJob(job.workspaceId, runners, "kiss")));
-}
-//#endregion
-//#region ../../packages/review-harness/src/workspace/agent_env.ts
-/**
-* The environment a review's later runs are pinned to: the job's, not the daemon's.
-*
-* A job records what it must run under at the moment it is created, and the analysis reads it back
-* from there. Every run that happens *after* the analysis read `captureEnv()` instead, which
-* answers a question about the daemon rather than about the review, and the daemon is the process
-* that happened to be started first by whichever shell got there first. Two things went wrong with
-* that. `CLAUDE_CONFIG_DIR` decides which account answers, so a review made under one and revisited
-* under another is served by a Claude that may not have access to the same models or settings. And
-* `agentId` decides which adapter runs at all, so a review made by one agent had its questions
-* answered, and its findings reconciled, by whichever is default today, silently, with the result
-* still shown as the review's.
-*
-* Three callers, and they are exactly the three things a reviewer can ask of a review after it is
-* written: a question in the Ask panel, bringing the analysis up to date, and re-reading the
-* conversation. All three put the answer on the page under the review's own name, so all three owe
-* the reader the review's own agent.
+			current.kissRuns = [...current.kissRuns ?? [], run];
+			current.latestKissRunId = run.id;
+		});
+		return job;
+	});
+	if (isBusy(started)) throw new ReviewBeingDeletedError();
+	return started;
+}
+/**
+* Record the run and drive it to its end.
 *
-* Falling back to capturing now covers a workspace with no job and one whose job has aged out of
-* retention, and that fallback is not the rare path: jobs are finished business within hours and
-* reviews are kept for thirty days, so most questions asked of an older review find nothing here.
+* The lock is released before the analysis begins, exactly as `reanalyseReview` does, so a deletion
+* during the twenty minutes that follow is refused by the live job claim rather than made to wait
+* for it.
 *
-* Which is why it captures for *the review's own agent* rather than the default one. Capturing for
-* the default reintroduced the exact bug this module exists to fix, one retention period later and
-* far more quietly: a review made by Codex, asked a question a day after its job was swept, would
-* have been answered by Claude with the answer shown as the review's. The environment has to be
-* captured now, because it genuinely is all there is left to read. Who to capture it for is a fact
-* the review still holds.
+* Counted by `track` from the first await, so a restart is refused for the whole of the run rather
+* than only once a caller remembered to count it. Only the server calls this; the CLI records the
+* run and drives it in its own process.
 */
-function agentEnvOf(workspace) {
-	const job = workspace.jobId ? loadJob(workspace.jobId) : null;
-	if (job?.env) return job.env;
-	const id = agentIdOf(workspace.session);
-	return (AGENT_IDS.includes(id) ? agentById(id) : defaultAgent()).captureEnv();
+function startKissJob(input, runners = {}) {
+	return track(recordKissRun(input).then((job) => runJob(job.workspaceId, runners, "kiss")));
 }
 //#endregion
 //#region ../../packages/review-harness/src/domain/ai_review/reconciliation.ts
@@ -16195,17 +17671,29 @@ function priorVerdict(item) {
 	return ` [previously: ${status}]`;
 }
 /**
+* A finding a comment resolved says which comment, so the model can tell it from one the code
+* resolved. And one whose comment has changed since says that too: it is the one settled finding
+* the model is asked to judge again. Every other finding reads exactly as `priorVerdict` has it.
+*/
+function priorFindingVerdict(issue, flag) {
+	const resolvedBy = conversationResolution(issue);
+	if (!resolvedBy) return priorVerdict(issue);
+	const cite = `@${resolvedBy.author} in [${resolvedBy.threadId}] [comment ${resolvedBy.commentId}]`;
+	if (!flag) return ` [previously: resolved by ${cite}]`;
+	return ` [previously: resolved by ${cite}; that comment has since been ${flag.change}. Reassess this finding]`;
+}
+/**
 * Each serialiser below states a finding's grade as the review now holds it, through `assess`: the
 * reviewer may have moved it, and a model told only the analysis's grade would re-judge from where
 * the review no longer stands. A caller with no ledger passes `ANALYSIS_ONLY`.
 */
-function formatPriorFindings(issues, assess) {
+function formatPriorFindings(issues, assess, reassess = /* @__PURE__ */ new Map()) {
 	if (!issues.length) return "(The previous analysis raised no issues.)";
 	return issues.map((issue, index) => {
 		const related = (issue.relatedFiles ?? []).map((file) => ` [related: ${file}, not changed]`).join("");
 		const location = (issue.file ? ` [${issue.file}${issue.line ? `:${issue.line}` : ""}]` : "") + related;
 		const description = issue.description.trim();
-		return `${index}. (${promptGrade(assess("issue", issue))})${location}${priorVerdict(issue)} ${issue.title.trim()}${description ? `\n   ${description}` : ""}`;
+		return `${index}. (${promptGrade(assess("issue", issue))})${location}${priorFindingVerdict(issue, reassess.get(index))} ${issue.title.trim()}${description ? `\n   ${description}` : ""}`;
 	}).join("\n");
 }
 /**
@@ -16241,9 +17729,10 @@ var RECONCILIATION_SHAPE = `{
 * part of the job. Built rather than kept as two constants: two hand-maintained copies of a schema
 * is how the one that is edited less often quietly stops matching the parser.
 */
-function reconciliationShape(includeQuestions) {
-	if (!includeQuestions) return RECONCILIATION_SHAPE;
-	const lines = RECONCILIATION_SHAPE.split("\n");
+function reconciliationShape(includeQuestions, withDiscussion = false) {
+	const shape = withDiscussion ? RECONCILIATION_SHAPE.replace("\"confidence\"?: \"high\" | \"medium\" | \"low\" }]", `"confidence"?: "high" | "medium" | "low"${DISCUSSION_ISSUE_FIELD} }]`).replace("\"severityReason\"?: string }]", `"severityReason"?: string${DISCUSSION_EVIDENCE_FIELD} }]`) : RECONCILIATION_SHAPE;
+	if (!includeQuestions) return shape;
+	const lines = shape.split("\n");
 	const findingsLine = lines.findIndex((line) => line.includes("\"findings\""));
 	return [
 		...lines.slice(0, findingsLine + 1),
@@ -16270,6 +17759,41 @@ function formatPriorQuestions(questions, assess) {
 	}).join("\n");
 }
 /**
+* The shape again, with the one field a discussion-aware run may also set on a new issue. The
+* parser has always accepted it; it is shown only where the prompt holds threads to cite.
+*/
+var DISCUSSION_ISSUE_FIELD = ", \"existingDiscussion\"?: { \"threadId\": string, \"relation\": \"same\" | \"related\" }";
+/** The comment or review a finding's status rests on, on the same discussion-aware runs. */
+var DISCUSSION_EVIDENCE_FIELD = ", \"evidence\"?: { \"threadId\": string, \"commentId\": string } | { \"reviewId\": string }";
+/**
+* The conversation as evidence: what it may settle, what it may not, and how to say which.
+*
+* The line this draws is between evidence about reality and claims about code. A maintainer saying
+* the service a finding worries about is deleted next week changes the finding's premise, and may
+* settle it with no commit at all. Someone saying a bug is fixed is a claim about code the model
+* can read, and only the code settles that.
+*/
+var DISCUSSION_RULES = `THE CONVERSATION AS EVIDENCE
+
+The changes in the pull request's conversation are listed above. Treat them as context, not ground truth: reviewers can be wrong, or writing about an older revision.
+- A comment may settle or reclassify a finding when it gives evidence that invalidates or materially changes the premise the finding rested on: for example a maintainer establishing that the code concerned is being removed, or that an assumption the finding made is false. Then "resolved" (or "affected", where it changes the finding without settling it) is right, and the note must cite that comment.
+- A comment saying a defect is fixed, or will be, is a claim about the code and not evidence. Without the fixing change in code you can read, that finding stays "still-open" or becomes "affected", never "resolved".
+- In "note" and "answer", name a comment by its author and what it establishes, for example "@sam confirms the job is being retired". Write no ids in them: the reviewer reads those sentences, and ids belong only in "evidence".
+- Whenever a comment or a review is the reason for a finding's status, also name it in that finding's "evidence": "threadId" and "commentId" from the comment's line (its "[T_123]" and "[comment C_9]" markers, without the brackets or the word "comment"), or "reviewId" from a review's "[review R_1]" marker. Only a comment can be the evidence for "resolved": a review summary may support "affected" or "still-open", and a resolution resting on one is marked for reassessment. A resolution that rests on the conversation without valid evidence is marked for reassessment too. Copy every id verbatim from the list above, and never invent one.
+- A question the conversation answers may be "answered": put the answer in "answer", naming the comment the same way.
+- A concern raised in the conversation that the earlier analysis did not cover belongs in "newIssues" only if you confirm it by reading the code. Then set "existingDiscussion" on it: "threadId" copied verbatim from that thread's marker, "relation" "same" when the thread makes this exact point or "related" when it is only near it. Omit the field if no listed thread matches.
+- A severity or importance suggestion may rest on the conversation; say which comment in the reason.`;
+/**
+* The one exception to "resolved stays resolved", stated only when a finding needs it: a resolution
+* that rested on a comment the conversation has since edited or deleted. Three answers, kept apart,
+* because "cannot tell" is not "reopened": the reviewer decides on a finding marked affected.
+*/
+var REASSESS_TASK = `   The one exception: a finding marked "that comment has since been edited" or "deleted" was resolved by a comment that has changed since. For that finding alone, judge again from the comment as it now reads; the change, and what the comment said before, are listed above.
+   - "resolved": it remains resolved despite the change. Name in "evidence" what it now rests on.
+   - "still-open": the change establishes that the original finding is valid again.
+   - "affected": the evidence changed and you cannot establish whether the finding is still valid. Use this, not "still-open", whenever you are unsure.
+   Keep it as this entry. Do not raise it again in "newIssues" unless the problem is now materially different.`;
+/**
 * The one optional judgement about a grade: a suggestion the reviewer answers, separate from the
 * status, reasoned from the grade the review holds now (each list states it), and only where the
 * new changes move it. Unasked for, a model restates every grade it was shown, and each would reach
@@ -16297,33 +17821,42 @@ var GRADE_TASK = {
 */
 function buildReconciliationInstructions(input, options = {}) {
 	const { previous, totalCommits, changedFiles, possiblyTruncated } = input;
+	const reassess = input.reassess ?? /* @__PURE__ */ new Map();
 	const includeQuestions = options.includeQuestions === true;
 	const commitCount = totalCommits === 1 ? "1 new commit" : `${totalCommits} new commits`;
 	const fileCount = changedFiles === 1 ? "1 file" : `${changedFiles} files`;
+	const discussion = options.discussion;
+	const conversationOnly = discussion !== void 0 && !discussion.codeChanged;
 	const truncationWarning = possiblyTruncated ? `\n\nIMPORTANT: the list of changes above is INCOMPLETE — more files changed than could be retrieved. Do not mark a previous finding "resolved" on the strength of absence: a file you cannot see may or may not contain the fix. Prefer "still-open" or "affected" where you cannot see the relevant code, and say so in the note.` : "";
 	const questionList = includeQuestions ? `\n\nPrevious open questions, numbered — refer to each by its number in "sourceIndex":\n${formatPriorQuestions(previous.questions, input.assess)}` : "";
 	const tasks = [
-		`For EVERY numbered finding above, decide what the new changes did to it:
+		`${discussion ? `For EVERY numbered finding above, decide what ${conversationOnly ? "the changes in the conversation" : "the new commits and the changes in the conversation"} did to it:
+   - "resolved": ${conversationOnly ? "" : "the new commits fix it, and you can point at the change that does so; or "}the conversation gives evidence that invalidates its premise, under the rules below.
+   - "still-open": nothing since settles it. This includes findings nothing since touches.
+   - "affected": ${conversationOnly ? "a comment bears on it" : "the code it concerns changed, or a comment bears on it,"} without clearly settling it either way. The reviewer needs to look again.` : `For EVERY numbered finding above, decide what the new changes did to it:
    - "resolved" — the new changes appear to fix it. Only when you can point at the change that does so.
    - "still-open" — the new changes do not address it. This includes findings the changes never touch.
-   - "affected" — the code it concerns changed, but not in a way that clearly settles it either way. The reviewer needs to look again.
+   - "affected" — the code it concerns changed, but not in a way that clearly settles it either way. The reviewer needs to look again.`}
    You MUST return one entry per numbered finding. If you are unsure, return "still-open" or "affected" with a note — do NOT omit the finding. Omitting a finding does not make it go away; it will be reported as still open regardless, without your reasoning attached.
-   A finding marked [previously: resolved] was already fixed by an earlier commit on this branch, which is code you are NOT being shown a diff of. It stays resolved, and "still-open" is not an available answer for it — these changes not being where the fix was says nothing about whether it holds. If you can see that later code has undone that fix, report it in "newIssues" with what you saw; do not reopen the old entry.
+   A finding marked [previously: resolved] was already fixed by an earlier commit on this branch, which is code you are NOT being shown a diff of. It stays resolved, and "still-open" is not an available answer for it — these changes not being where the fix was says nothing about whether it holds. If you can see that later code has undone that fix, report it in "newIssues" with what you saw; do not reopen the old entry.${reassess.size > 0 ? `
+${REASSESS_TASK}` : ""}
    ${GRADE_TASK.issue}`,
 		...includeQuestions ? [`For EVERY numbered question above, decide what the new changes did to it:
-   - "answered" — the changes settle it. Put the answer in "answer", in a sentence or two, and name what in the code establishes it.
+   - "answered" — the changes settle it. Put the answer in "answer", in a sentence or two, and name what in the code establishes it.${discussion ? " A comment in the conversation that answers it counts too: name it as the rules below say." : ""}
    - "still-open" — the changes do not settle it. This includes questions the changes never touch, and questions only the author can answer.
    - "affected" — the code the question is about changed without answering it. The reviewer should read the question again before asking it.
    A question marked [previously: answered] was already settled by an earlier commit on this branch, which is code you are NOT being shown a diff of. It stays answered, and "still-open" is not an available answer for it.
    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.
    ${GRADE_TASK.question}`] : [],
-		`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.`,
+		conversationOnly ? `No commits were pushed, so there is no new code to review. Report a problem in "newIssues" only where the conversation points at something in the code the earlier analysis missed and you have confirmed it by reading the code. Do NOT repeat a previous finding here: if it still stands, that is what "still-open" is for.` : `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. ${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.
+	return `${conversationOnly ? `You are RECONCILING an earlier analysis of this pull request against what has changed in its conversation since that analysis was made.
+
+No commits have been pushed since: the code is exactly what the earlier analysis read. What has changed is the discussion, listed above.` : `You are RECONCILING an earlier analysis of this pull request against the changes pushed since that analysis was made${discussion ? ", and against what has changed in its conversation since" : ""}.
 
-The diff above is NOT the whole pull request. It is only what changed in the ${commitCount} (${fileCount}) pushed after the earlier analysis. The earlier analysis already covered everything before that point.
+The diff above is NOT the whole pull request. It is only what changed in the ${commitCount} (${fileCount}) pushed after the earlier analysis. The earlier analysis already covered everything before that point.`}
 
 PREVIOUS ANALYSIS
 
@@ -16332,16 +17865,16 @@ Overall risk: ${previous.overallRisk}
 Recommendation: ${previous.recommendation}
 
 Previous findings, numbered — refer to each by its number in "sourceIndex":
-${formatPriorFindings(previous.issues, input.assess)}${questionList}${truncationWarning}
-
+${formatPriorFindings(previous.issues, input.assess, reassess)}${questionList}${truncationWarning}
+${discussion ? `\n${DISCUSSION_RULES}\n` : ""}
 YOUR TASK
 
 ${tasks}
 
 Respond with a single JSON object (no markdown, no surrounding text) matching exactly this shape:
-${reconciliationShape(includeQuestions)}
+${reconciliationShape(includeQuestions, discussion !== void 0)}
 
-"note" is one short sentence on *why* the status is what it is — name the change that resolved it, or what leaves it standing. Omit it rather than restating the finding.
+"note" is one short sentence on *why* the status is what it is — name the change that resolved it, or what leaves it standing.${discussion ? " Where a comment is the reason, name its author." : ""} Omit it rather than restating the finding.
 
 "severity" on a new issue is how much it would matter if real; "confidence" is how sure you are that it is real. Separate axes — do not let one stand in for the other, and omit "confidence" rather than guessing a middle. Report only what is worth the reviewer's attention: empty arrays are valid answers and are far better than padded ones.`;
 }
@@ -16392,6 +17925,19 @@ function reconciliationGradeSuggestions(previous, reconciled, assess) {
 	}
 	return suggestions;
 }
+/** A citation as the reply gave it: a comment by thread and comment id, or a review by its id. Anything else is no citation. */
+function parseCitation(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const item = value;
+	const threadId = asString$1(item.threadId).trim();
+	const commentId = asString$1(item.commentId).trim();
+	if (threadId && commentId) return {
+		threadId,
+		commentId
+	};
+	const reviewId = asString$1(item.reviewId).trim();
+	return reviewId ? { reviewId } : void 0;
+}
 function asStatus(value, allowed) {
 	return allowed.includes(value) ? value : null;
 }
@@ -16424,6 +17970,7 @@ function parseReconciliationResult(raw, priorCount, options = {}) {
 		seen.add(sourceIndex);
 		const note = asString$1(item.note).trim();
 		const grade = parseGrade("issue", item.severity, item.severityReason);
+		const cites = parseCitation(item.evidence);
 		findings.push({
 			sourceIndex,
 			status,
@@ -16431,7 +17978,8 @@ function parseReconciliationResult(raw, priorCount, options = {}) {
 			...grade ? { grade: {
 				to: grade.to,
 				reason: grade.reason
-			} } : {}
+			} } : {},
+			...cites ? { cites } : {}
 		});
 	}
 	return {
@@ -16461,15 +18009,30 @@ function parseReconciliationResult(raw, priorCount, options = {}) {
 * Every prior finding therefore survives into the new result, in its original order, carrying its
 * original id, severity and text. Only the status is added.
 */
-function reconcileIssues(prior, findings) {
+function reconcileIssues(prior, findings, record) {
 	const byIndex = new Map(findings.map((f) => [f.sourceIndex, f]));
 	return prior.map((issue, index) => {
-		if (issue.reconciliationStatus === "resolved") return issue;
 		const verdict = byIndex.get(index);
+		const flag = issue.reconciliationStatus === "resolved" ? record?.flags?.get(index) : void 0;
+		if (flag && record) {
+			const entry = reassessedEntry(verdict, flag, record);
+			return {
+				...issue,
+				reconciliationStatus: entry.status,
+				...entry.reason ? { reconciliationNote: entry.reason } : {},
+				statusHistory: appendStatusChange(issue, entry),
+				...record.against ? { reconciledAgainst: entry.basis === "code" ? "commits" : "conversation" } : {}
+			};
+		}
+		if (issue.reconciliationStatus === "resolved") return issue;
+		const status = verdict?.status ?? "still-open";
+		const recorded = record && isStatusChange(issue.reconciliationStatus, status) ? { statusHistory: appendStatusChange(issue, changeEntry(status, verdict, record)) } : {};
 		return {
 			...issue,
-			reconciliationStatus: verdict?.status ?? "still-open",
-			...verdict?.note ? { reconciliationNote: verdict.note } : {}
+			reconciliationStatus: status,
+			...verdict?.note ? { reconciliationNote: verdict.note } : {},
+			...recorded,
+			...record?.against ? { reconciledAgainst: verdict?.evidence ? "conversation" : record.against } : {}
 		};
 	});
 }
@@ -16534,7 +18097,8 @@ function parseQuestions(value, priorCount) {
 function alreadyAnswered(question) {
 	return question.reconciliationStatus === "answered" || question.reconciliationAnswer !== void 0;
 }
-function reconcileQuestions(prior, reconciled) {
+function reconcileQuestions(prior, reconciled, against) {
+	const recorded = against ? { reconciledAgainst: against } : {};
 	const byIndex = new Map(reconciled.map((entry) => [entry.sourceIndex, entry]));
 	return prior.map((question, index) => {
 		if (alreadyAnswered(question)) return {
@@ -16544,7 +18108,8 @@ function reconcileQuestions(prior, reconciled) {
 		const verdict = byIndex.get(index);
 		if (!verdict) return {
 			...question,
-			reconciliationStatus: "still-open"
+			reconciliationStatus: "still-open",
+			...recorded
 		};
 		const answered = verdict.status === "answered" && verdict.answer !== void 0;
 		const status = verdict.status !== "answered" ? verdict.status : answered ? "answered" : "affected";
@@ -16552,15 +18117,17 @@ function reconcileQuestions(prior, reconciled) {
 			...question,
 			reconciliationStatus: status,
 			...verdict.note ? { reconciliationNote: verdict.note } : {},
-			...answered ? { reconciliationAnswer: verdict.answer } : {}
+			...answered ? { reconciliationAnswer: verdict.answer } : {},
+			...recorded
 		};
 	});
 }
 /** Marks a reconciliation's own findings as new, so the UI can tell them from carried-forward ones. */
-function markNewIssues(issues) {
+function markNewIssues(issues, against) {
 	return issues.map((issue) => ({
 		...issue,
-		reconciliationStatus: "new"
+		reconciliationStatus: "new",
+		...against ? { reconciledAgainst: against } : {}
 	}));
 }
 /**
@@ -16589,16 +18156,93 @@ function composeSections(parent, added) {
 	}));
 }
 //#endregion
-//#region ../../packages/review-harness/src/domain/ui/components/pr_update_notice.ts
-function countByStatus(issues) {
+//#region ../../packages/review-harness/src/domain/ai_review/update_counts.ts
+/**
+* What an update did to a review, counted by comparing each finding and question with what it was
+* before. Shared by the workspace's update and the extension's, so both announce the same numbers.
+*/
+/**
+* Paired by position: `reconcileIssues` and `reconcileQuestions` return the previous ones in their
+* order, and what the update added comes after them.
+*/
+function countUpdateChanges(previous, result) {
 	const counts = {
 		resolved: 0,
-		"still-open": 0,
+		stillOpen: 0,
 		affected: 0,
-		new: 0
+		newIssues: 0,
+		questionsAnswered: 0
+	};
+	let byConversation = 0;
+	let reopened = 0;
+	result.issues.forEach((issue, index) => {
+		const before = previous.issues[index]?.reconciliationStatus;
+		const now = issue.reconciliationStatus;
+		if (now === "new") counts.newIssues++;
+		else if (now === "resolved") {
+			if (before === "resolved") return;
+			counts.resolved++;
+			if (issue.statusHistory?.at(-1)?.basis === "conversation") byConversation++;
+		} else if (before === "resolved" && now === "still-open") reopened++;
+		else if (now === "affected" && before !== "affected") counts.affected++;
+		else counts.stillOpen++;
+	});
+	counts.questionsAnswered = result.questions.filter((question, index) => {
+		const before = previous.questions[index];
+		return question.reconciliationStatus === "answered" && !(before && alreadyAnswered(before));
+	}).length;
+	return {
+		...counts,
+		...byConversation ? { resolvedByConversation: byConversation } : {},
+		...reopened ? { reopened } : {}
+	};
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/ai_review/update_reconciliation.ts
+function reconciledAgainstOf(basis) {
+	return basis.code ? basis.discussion ? "commits-and-conversation" : "commits" : "conversation";
+}
+function applyReconciliation(previous, parsed, context) {
+	const { conversation } = context;
+	const basis = {
+		code: context.codeChanged,
+		discussion: conversationMoved(conversation)
+	};
+	const against = reconciledAgainstOf(basis);
+	const flags = conversationReassessment(previous, conversation);
+	const findings = groundFindings(parsed.findings, conversation.discussion, {
+		codeChanged: context.codeChanged,
+		flags
+	});
+	const suggestions = reconciliationGradeSuggestions(previous, {
+		...parsed,
+		findings
+	}, context.assess);
+	const issues = [...reconcileIssues(previous.issues, findings, {
+		at: context.at,
+		commitSha: context.commitSha,
+		basis: context.codeChanged ? "code" : "conversation",
+		flags,
+		against
+	}), ...markNewIssues(parsed.newIssues, against)];
+	const questions = reconcileQuestions(previous.questions, parsed.questions, against);
+	const { motivation } = context;
+	const composed = {
+		schemaVersion: 1,
+		summary: parsed.summary || previous.summary,
+		...motivation ? { motivation } : {},
+		overallRisk: parsed.overallRisk ?? previous.overallRisk,
+		recommendation: parsed.recommendation || previous.recommendation,
+		nextSteps: parsed.nextSteps.length ? parsed.nextSteps : previous.nextSteps,
+		sections: composeSections(previous.sections, parsed.newSections),
+		issues,
+		questions: motivation === previous.motivation ? questions : withIntentQuestion(questions, motivation)
+	};
+	return {
+		result: conversation.discussion ? attributeIssuesToDiscussion(composed, processDiscussion(conversation.discussion)).result : composed,
+		suggestions,
+		basis
 	};
-	for (const issue of issues) if (issue.reconciliationStatus) counts[issue.reconciliationStatus] += 1;
-	return counts;
 }
 //#endregion
 //#region ../../packages/review-harness/src/workspace/running_jobs.ts
@@ -16795,178 +18439,6 @@ async function askCheckout(workspace) {
 	return path;
 }
 //#endregion
-//#region ../../packages/review-harness/src/workspace/discussion_diff.ts
-function diffDiscussions(before, after) {
-	const oldThreads = new Map(before.discussions.map((thread) => [thread.id, thread]));
-	const newIds = new Set(after.discussions.map((thread) => thread.id));
-	const oldComments = new Set(before.discussions.flatMap((thread) => thread.comments.map((comment) => comment.id)));
-	let newThreads = 0;
-	let resolvedSince = 0;
-	let reopenedSince = 0;
-	let newComments = 0;
-	for (const thread of after.discussions) {
-		const previous = oldThreads.get(thread.id);
-		if (!previous) newThreads++;
-		else if (thread.resolved && !previous.resolved) resolvedSince++;
-		else if (!thread.resolved && previous.resolved) reopenedSince++;
-		for (const comment of thread.comments) if (!oldComments.has(comment.id)) newComments++;
-	}
-	return {
-		newThreads,
-		vanishedThreads: [...oldThreads.keys()].filter((id) => !newIds.has(id)).length,
-		resolvedSince,
-		reopenedSince,
-		newComments
-	};
-}
-/** Nothing moved. Worth its own answer: "checked, and nothing changed" is a useful thing to hear. */
-function isUnchanged(changes) {
-	return changes.newThreads === 0 && changes.vanishedThreads === 0 && changes.resolvedSince === 0 && changes.reopenedSince === 0 && changes.newComments === 0;
-}
-/**
-* The change, in a sentence, newest-mattering first.
-*
-* Resolutions lead because they are the ones that make a standing claim in this review false —
-* an "already raised … still unresolved" line that is no longer true is the reason this whole
-* re-check exists.
-*/
-function describeChanges(changes) {
-	if (isUnchanged(changes)) return "Nothing has changed in the conversation since it was imported.";
-	const parts = [];
-	const plural = (count, one, many) => `${count} ${count === 1 ? one : many}`;
-	if (changes.resolvedSince > 0) parts.push(`${plural(changes.resolvedSince, "thread", "threads")} resolved since`);
-	if (changes.reopenedSince > 0) parts.push(`${plural(changes.reopenedSince, "thread", "threads")} reopened`);
-	if (changes.newThreads > 0) parts.push(`${plural(changes.newThreads, "new thread", "new threads")}`);
-	if (changes.newComments > 0) parts.push(`${plural(changes.newComments, "new comment", "new comments")}`);
-	if (changes.vanishedThreads > 0) parts.push(`${plural(changes.vanishedThreads, "thread", "threads")} no longer present`);
-	return `${parts.join(", ")}.`;
-}
-//#endregion
-//#region ../../packages/review-harness/src/workspace/pr_refresh.ts
-/**
-* Re-read the pull request conversation, without re-reviewing anything.
-*
-* The problem this solves is narrow and specific. Every "Already raised by @sarah · thread still
-* unresolved" line in a review is a fact that was true at import and is frozen. Nothing re-checks
-* it, so an hour after Sarah resolves that thread the workspace is still telling the reviewer she
-* is waiting on it: a confident, specific, wrong claim about what a named colleague thinks.
-*
-* **This is not a re-review, and the distinction is the whole design.** Re-reading the conversation
-* can only update the state of findings that already exist: who raised the thread, whether it is
-* open, where it links to. It cannot produce a new finding, and it must not try. Deciding that a
-* new comment invalidates a finding, or that a new commit introduced a bug, is judgement, and
-* judgement belongs to the analyser. `attributeIssuesToDiscussion` is what runs here, and it is
-* arithmetic: the model's only surviving contribution is which thread each finding points at.
-*
-* This used to spawn an agent in the reviewer's own checkout and ask it to fetch the conversation.
-* It now asks the forge adapter, which is a couple of subprocess calls and answers in seconds
-* rather than minutes. The daemon still reaches no forge itself and still holds no credential: the
-* adapter drives the CLI the developer has already signed in to, exactly as the review drives the
-* agent they have already signed in to.
-*/
-/**
-* Computes; does not persist. The route saves, so a test can run the whole thing without writing
-* into the reviewer's own store.
-*/
-async function refreshPrContext(workspace, fetch = refetchConversation) {
-	if (!workspace.prContext) return {
-		at: Date.now(),
-		ok: false,
-		message: "This review has no pull request conversation attached, so there is nothing to re-read."
-	};
-	const pr = workspace.prContext.pullRequest;
-	const outcome = await fetch(workspace.repoPath, {
-		url: pr.url,
-		number: pr.number
-	}, agentEnvOf(workspace));
-	if (outcome.kind !== "attached") return {
-		at: Date.now(),
-		ok: false,
-		message: `${whyNot(outcome)} Nothing here has changed, and the discussion shown is still the one that came with the review.`
-	};
-	const fetched = outcome.context;
-	const before = workspace.prContext.discussion;
-	const changes = diffDiscussions(before, fetched.discussion);
-	const restated = reattribute(workspace, fetched.discussion);
-	workspace.prContext = {
-		pullRequest: {
-			...workspace.prContext.pullRequest,
-			...movable(fetched.pullRequest)
-		},
-		discussion: fetched.discussion
-	};
-	workspace.lastPrRefresh = {
-		at: Date.now(),
-		ok: true,
-		message: describeChanges(changes),
-		changes,
-		...restated
-	};
-	return workspace.lastPrRefresh;
-}
-/**
-* Why the re-check did not happen, in the tense a person clicking a button is standing in.
-*
-* The same closed union the review's own disclosure renders, and deliberately not the same
-* sentences. Those are written about a review that has already been made; these are written about
-* a button that has just been pressed and did nothing.
-*/
-function whyNot(outcome) {
-	switch (outcome.kind) {
-		case "no-request": return "The pull request this review is attached to could not be found.";
-		case "unsupported-forge": return outcome.host ? `PR Review Buddy does not read pull request conversation on ${outcome.host} yet.` : "This repository has no remote to look the pull request up on.";
-		case "cli-missing": return `\`${outcome.cli}\` is not installed here, so the pull request could not be re-read.`;
-		case "not-authenticated": return `\`${outcome.cli}\` is not signed in, so the pull request could not be re-read. Run \`${outcome.cli} auth login\` and try again.`;
-		case "failed": return `The pull request could not be re-read. ${outcome.detail}`;
-	}
-}
-/**
-* Which fields a re-read may update, and why these.
-*
-* The head SHA and title move on their own as the request gains commits, and the two link shapes
-* are how this product gets from a file here to the same file there. Number, url and provider are
-* identity and stay as attached: a re-read does not move a review onto a different pull request.
-*/
-function movable(fetched) {
-	const updates = {};
-	const copy = (field) => {
-		const value = fetched[field];
-		if (value !== void 0 && value !== "" && value !== null) updates[field] = value;
-	};
-	copy("headSha");
-	copy("title");
-	if (typeof fetched.body === "string") updates.body = fetched.body;
-	copy("filesUrl");
-	copy("fileUrlTemplate");
-	copy("author");
-	return updates;
-}
-/**
-* Re-derive every attribution from the threads as they now are.
-*
-* The same function the review's own attribution pass used, run again against fresh threads. It
-* rebuilds author, status and link from the real thread and drops any claim whose thread is no
-* longer there, so nothing the model once said can outlive the conversation that justified it.
-*/
-function reattribute(workspace, discussion) {
-	const result = workspace.session.result;
-	if (!result) return {
-		attributionsWithdrawn: 0,
-		attributionsRestated: 0
-	};
-	const before = new Map(result.issues.map((issue) => [issue.id, issue.existingDiscussion?.status]));
-	const outcome = attributeIssuesToDiscussion(result, processDiscussion(discussion));
-	workspace.session = {
-		...workspace.session,
-		result: outcome.result
-	};
-	const restated = outcome.result.issues.filter((issue) => issue.existingDiscussion && before.get(issue.id) !== issue.existingDiscussion.status).length;
-	return {
-		attributionsWithdrawn: outcome.rejected,
-		attributionsRestated: restated
-	};
-}
-//#endregion
 //#region ../../packages/review-harness/src/workspace/review_update.ts
 /**
 * Make this review describe the code that is on the ref it follows.
@@ -17156,34 +18628,44 @@ async function bringForward(workspace, runners, reviewedSha, held, step, signal,
 	const remote = await remoteHead(workspace, signal, runners);
 	signal.throwIfAborted();
 	if (!remote.sha) return refuse(reviewedSha, remote.fetchFailed, remote.refusal ?? noRemoteHeadMessage(workspace));
+	adoptLegacyBaseline(workspace);
 	if (workspace.prContext) step("conversation");
 	const conversationOk = await reReadConversation(workspace, runners.runRefresh);
 	signal.throwIfAborted();
+	const { prepared } = await prepareConversation(workspace, {
+		reread: false,
+		...conversationOk !== null && workspace.lastPrRefresh ? { rereadOutcome: workspace.lastPrRefresh } : {}
+	});
+	const discussionMoved = conversationMoved(prepared);
 	if (reviewedSha && !await commitPresent(workspace.repoPath, reviewedSha)) return settled(reviewedSha, remote.sha, remote.fetchFailed, conversationOk, "baseline-gone", BASELINE_GONE_MESSAGE);
-	if (!reviewedSha || reviewedSha === remote.sha) return settled(reviewedSha, remote.sha, remote.fetchFailed, conversationOk, "already-current", alreadyCurrentMessage(conversationOk));
+	if (!reviewedSha || reviewedSha === remote.sha && !discussionMoved) return settled(reviewedSha, remote.sha, remote.fetchFailed, conversationOk, "already-current", alreadyCurrentMessage(conversationOk));
 	step("context");
 	let worktreePath;
 	try {
 		({path: worktreePath} = await pinCheckout(workspace, remote.sha, held));
 	} catch (error) {
 		if (error instanceof ReviewBeingDeletedError) throw error;
-		return settled(reviewedSha, remote.sha, remote.fetchFailed, conversationOk, "analysis-failed", "A checkout of the new commits could not be prepared, so nothing was reassessed.");
+		return settled(reviewedSha, remote.sha, remote.fetchFailed, conversationOk, "analysis-failed", "A checkout of the latest commit could not be prepared, so nothing was reassessed.");
 	}
 	signal.throwIfAborted();
-	return reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, held.job.id, signal, clock);
+	return reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, held.job.id, signal, clock, prepared, discussionMoved);
 }
-async function reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, jobId, signal, clock) {
+async function reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, jobId, signal, clock, prepared, discussionMoved) {
 	const newHead = remote.sha;
-	let delta;
-	try {
+	let delta = null;
+	if (reviewedSha !== newHead) try {
 		delta = await buildReviewContext({
 			repoPath: worktreePath,
 			base: reviewedSha
 		});
 	} catch (error) {
-		if (error instanceof EmptyChangeError) return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "already-current", alreadyCurrentMessage(conversationOk));
-		return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "baseline-gone", BASELINE_GONE_MESSAGE);
+		if (!(error instanceof EmptyChangeError)) return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "baseline-gone", BASELINE_GONE_MESSAGE);
 	}
+	if (!delta && !discussionMoved) return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "already-current", alreadyCurrentMessage(conversationOk));
+	const basis = {
+		code: delta !== null,
+		discussion: discussionMoved
+	};
 	const previous = workspace.session.result;
 	if (!previous) return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "no-result", "This review has no analysis to bring up to date.");
 	step("analysing");
@@ -17202,50 +18684,45 @@ async function reconcile(workspace, runners, reviewedSha, remote, conversationOk
 	const requestedModel = resolveModel({ review: { session: workspace.session } }) ?? void 0;
 	let raw;
 	try {
-		const prompt = buildUpdatePrompt(workspace, delta, reviewedSha, newHead, worktreePath);
+		const prompt = buildUpdatePrompt(workspace, delta, prepared, reviewedSha, newHead, worktreePath);
 		raw = runners.run ? await runners.run(prompt, worktreePath, agentEnvOf(workspace), onProgress, onObservedModel, signal) : await runUpdate(workspace.id, prompt, worktreePath, workspace.repoPath, agentEnvOf(workspace), onProgress, requestedModel, onObservedModel, signal);
 	} catch (error) {
 		return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "analysis-failed", explainUpdateFailure(error, agentEnvOf(workspace), requestedModel));
 	}
 	const parsed = parseReconciliationResult(raw, previous.issues.length, { priorQuestionCount: previous.questions.length });
 	if (!parsed) return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "analysis-failed", "The reassessment came back in a form this could not read, so nothing was changed.");
-	const suggestions = reconciliationGradeSuggestions(previous, parsed, assessmentLookup(workspace.session));
-	const issues = [...reconcileIssues(previous.issues, parsed.findings), ...markNewIssues(parsed.newIssues)];
 	const motivation = carryMotivation(previous.motivation, workspace.session.metadata?.authorDescription, workspace.prContext?.pullRequest.body);
-	const questions = reconcileQuestions(previous.questions, parsed.questions);
-	const result = {
-		schemaVersion: 1,
-		summary: parsed.summary || previous.summary,
-		...motivation ? { motivation } : {},
-		overallRisk: parsed.overallRisk ?? previous.overallRisk,
-		recommendation: parsed.recommendation || previous.recommendation,
-		nextSteps: parsed.nextSteps.length ? parsed.nextSteps : previous.nextSteps,
-		sections: composeSections(previous.sections, parsed.newSections),
-		issues,
-		questions: motivation === previous.motivation ? questions : withIntentQuestion(questions, motivation)
-	};
+	const { result, suggestions } = applyReconciliation(previous, parsed, {
+		at: clock.now(),
+		commitSha: newHead,
+		codeChanged: delta !== null,
+		conversation: prepared,
+		assess: assessmentLookup(workspace.session),
+		motivation
+	});
 	signal.throwIfAborted();
 	cancellers.delete(jobId);
 	const gradeChanges = await applyUpdate(workspace, result, previous, newHead, worktreePath, {
 		...requestedModel ? { requestedModel } : {},
 		...observedModel ? { observedModel } : {},
 		...await (runners.agentVersion ?? installedAgentVersion)(agentEnvOf(workspace))
-	}, clock, remote.base, suggestions);
+	}, clock, remote.base, suggestions, conversationTakenIntoAccount(prepared, analysedBaselineOf(workspace)));
 	const counts = {
-		...summariseCounts(result),
+		...countUpdateChanges(previous, result),
 		...gradeChanges ? { gradeChanges } : {}
 	};
 	return {
 		at: Date.now(),
 		ok: true,
-		message: describeUpdate(counts, newHead),
+		message: describeUpdate(counts, newHead, basis),
 		stop: null,
 		fetchFailed: remote.fetchFailed,
 		moved: reviewedSha !== newHead,
 		...conversationOk === null ? {} : { conversationOk },
 		fromSha: reviewedSha,
 		toSha: newHead,
-		counts
+		counts,
+		reassessed: basis
 	};
 }
 var BASELINE_GONE_MESSAGE = "The commit this review was made from is no longer in this repository, so there is nothing to measure the new code against. This one needs starting fresh: run `prreviewbuddy review --fresh`.";
@@ -17398,6 +18875,7 @@ var UPDATE_OWNED_FIELDS = [
 	"reviewedPaths",
 	"previousResult",
 	"prContext",
+	"analysedConversation",
 	"lastPrRefresh",
 	"dismissedFreshnessSha",
 	"lastUpdate",
@@ -17460,7 +18938,7 @@ function carryUpdateSuggestions(merged, updated) {
 	merged.lastUpdate = {
 		...outcome,
 		counts,
-		message: describeUpdate(counts, outcome.toSha)
+		message: describeUpdate(counts, outcome.toSha, outcome.reassessed)
 	};
 }
 /**
@@ -17471,8 +18949,9 @@ function carryUpdateSuggestions(merged, updated) {
 * to browse the review's past. There is no restore button yet, and that is fine. Insurance that is
 * only written once somebody has already built the claim form is not insurance.
 */
-async function applyUpdate(workspace, result, replaced, newHead, worktreePath, run, clock, freshBase, suggestions = []) {
+async function applyUpdate(workspace, result, replaced, newHead, worktreePath, run, clock, freshBase, suggestions = [], conversation) {
 	workspace.previousResult = {
+		...workspace.analysedConversation ? { analysedConversation: workspace.analysedConversation } : {},
 		result: replaced,
 		commitSha: workspace.session.metadata?.commitSha ?? "",
 		replacedAt: Date.now(),
@@ -17505,6 +18984,10 @@ async function applyUpdate(workspace, result, replaced, newHead, worktreePath, r
 		}
 	});
 	delete workspace.dismissedFreshnessSha;
+	workspace.analysedConversation = {
+		sessionId: workspace.session.id,
+		discussion: conversation ?? null
+	};
 	return proposeGradeSuggestions(workspace.session, suggestions, {
 		kind: "update",
 		commitSha: newHead
@@ -17599,11 +19082,13 @@ function legacyBaseCandidates(recorded) {
 /** Null when there is no conversation attached, which is neither success nor failure. */
 async function reReadConversation(workspace, fetch) {
 	if (!workspace.prContext) return null;
+	const startedAt = Date.now();
 	try {
 		const outcome = fetch ? await refreshPrContext(workspace, fetch) : await refreshPrContext(workspace);
 		workspace.lastPrRefresh = outcome;
 		return outcome.ok;
 	} catch {
+		workspace.lastPrRefresh = unforeseenFailure(startedAt);
 		return false;
 	}
 }
@@ -17625,16 +19110,6 @@ function alreadyCurrentMessage(conversationOk) {
 	if (conversationOk === null) return code;
 	return conversationOk ? `${code} The pull request conversation was re-read.` : `${code} The pull request conversation could not be re-read, so the notes about who raised what are unchanged.`;
 }
-function summariseCounts(result) {
-	const byStatus = countByStatus(result.issues);
-	return {
-		resolved: byStatus.resolved,
-		stillOpen: byStatus["still-open"],
-		affected: byStatus.affected,
-		newIssues: byStatus.new,
-		questionsAnswered: result.questions.filter((question) => question.reconciliationStatus === "answered").length
-	};
-}
 /**
 * What happened, in the order the reviewer cares about.
 *
@@ -17642,18 +19117,35 @@ function summariseCounts(result) {
 * they need. Still-present is the number that is usually largest and almost never interesting, so
 * it goes last and only when there is something to sit beside.
 */
-function describeUpdate(counts, sha) {
+function describeUpdate(counts, sha, basis = {
+	code: true,
+	discussion: false
+}) {
 	const parts = [];
-	if (counts.resolved) parts.push(`${counts.resolved} fixed`);
+	const byConversation = counts.resolvedByConversation ?? 0;
+	const fixed = counts.resolved - byConversation;
+	if (fixed) parts.push(`${fixed} fixed`);
+	if (byConversation) parts.push(`${byConversation} resolved by the conversation`);
+	if (counts.reopened) parts.push(`${counts.reopened} reopened`);
 	if (counts.newIssues) parts.push(`${counts.newIssues} new`);
 	if (counts.affected) parts.push(`${counts.affected} to look at again`);
 	if (counts.questionsAnswered) parts.push(`${counts.questionsAnswered} question${counts.questionsAnswered === 1 ? "" : "s"} answered`);
 	if (counts.stillOpen && parts.length) parts.push(`${counts.stillOpen} still present`);
 	const grades = counts.gradeChanges ? ` ${counts.gradeChanges} grade ${counts.gradeChanges === 1 ? "change" : "changes"} suggested.` : "";
-	const at = `Updated to ${sha.slice(0, 7)}`;
-	if (!parts.length) return `${at}. The new commits changed nothing about the findings: all ${counts.stillOpen} are still present.${grades}`;
+	if (!basis.code) {
+		const at = "Reassessed against the pull request conversation; no new commits";
+		if (!parts.length) return `${at}. The conversation changed nothing about the findings${stillPresent(counts)}.${grades}`;
+		return `${at}: ${parts.join(", ")}.${grades}`;
+	}
+	const at = `Updated to ${sha.slice(0, 7)}${basis.discussion ? ", with the conversation" : ""}`;
+	if (!parts.length) return `${at}. The new commits${basis.discussion ? " and comments" : ""} changed nothing about the findings${stillPresent(counts)}.${grades}`;
 	return `${at}: ${parts.join(", ")}.${grades}`;
 }
+/** The open findings an update left as they were, after a sentence saying it changed nothing. */
+function stillPresent(counts) {
+	if (!counts.stillOpen) return "";
+	return `: ${counts.stillOpen} ${counts.stillOpen === 1 ? "is" : "are"} still present`;
+}
 /**
 * The reconciliation, asked for as a review of new code rather than as a tidy-up of an old list.
 *
@@ -17663,19 +19155,26 @@ function describeUpdate(counts, sha) {
 * Everything after it is the shared builder, so the two clients cannot drift into asking for
 * different shapes.
 */
-function buildUpdatePrompt(workspace, delta, reviewedSha, newHead, worktreePath) {
-	const files = delta.changeSet.data.files;
+function buildUpdatePrompt(workspace, delta, conversation, reviewedSha, newHead, worktreePath) {
 	const previous = workspace.session.result;
-	const commits = (delta.changeSet.authors ?? []).reduce((total, author) => total + author.commits, 0);
-	return `An earlier review of this branch is being brought up to date with the commits pushed since it was written.
+	const discussionChanged = conversationMoved(conversation);
+	const conversationBlock = updateConversationBlock(conversation);
+	const opening = delta ? `An earlier review of this branch is being brought up to date with the commits pushed since it was written${discussionChanged ? ", and with what has changed in its pull request conversation since" : ""}.` : "An earlier review of this branch is being brought up to date with what has changed in its pull request conversation since it was written. No commits have been pushed since.";
+	const code = delta ? `The change below is what happened between ${reviewedSha} and ${newHead}. It is not the whole branch: the earlier review already covered everything up to ${reviewedSha}.
+
+${renderChangeInventory(delta.changeSet.data.files, inlinePathsOf(delta))}
+
+${delta.diff}` : `The code is unchanged since the earlier review: ${newHead} is the commit it read.`;
+	const commits = delta ? (delta.changeSet.authors ?? []).reduce((total, author) => total + author.commits, 0) : 0;
+	return `${opening}
 
 The working tree at ${worktreePath} is checked out at ${newHead}, which is the code as it now stands. You may read any file in it, and you should: the point of doing this here rather than from a diff alone is that you can open the code and see whether a fix actually holds. Read only. Change nothing, commit nothing, and run no command that writes.
 
-The change below is what happened between ${reviewedSha} and ${newHead}. It is not the whole branch: the earlier review already covered everything up to ${reviewedSha}.
+${code}
 
-${renderChangeInventory(files, new Set(files.map((file) => file.name).filter((name) => !delta.inventoryOnlyFiles.includes(name))))}
+---
 
-${delta.diff}
+${conversationBlock}
 
 ---
 
@@ -17685,9 +19184,17 @@ ${buildReconciliationInstructions({
 		fromSha: reviewedSha,
 		toSha: newHead,
 		totalCommits: commits,
-		changedFiles: files.length,
-		possiblyTruncated: false
-	}, { includeQuestions: true })}`;
+		changedFiles: delta ? delta.changeSet.data.files.length : 0,
+		possiblyTruncated: false,
+		reassess: conversationReassessment(previous, conversation)
+	}, {
+		includeQuestions: true,
+		...discussionChanged ? { discussion: { codeChanged: delta !== null } } : {}
+	})}`;
+}
+/** The files whose patch travelled inline, as against those only named in the inventory. */
+function inlinePathsOf(delta) {
+	return new Set(delta.changeSet.data.files.map((file) => file.name).filter((name) => !delta.inventoryOnlyFiles.includes(name)));
 }
 /**
 * The production run: a `read-code` run standing in the pinned worktree.
@@ -17906,4 +19413,4 @@ function lineageIds(id) {
 	return [.../* @__PURE__ */ new Set([id, ...lineage.map((review) => review.id)])];
 }
 //#endregion
-export { MAX_WORKSPACE_PORT as $, decideKissRecommendation as $n, findingIn as $r, markReadForReview as $t, relativeTime as A, AgentCancelledError as Ai, describeMovement as An, sectionOf as Ar, partFiles as At, readIndexToken as B, allJobs as Bn, questionsOutstanding as Br, isArchitectureId as Bt, track as C, writeAgentPreference as Ci, MANAGED_ROOT as Cn, activityLabel as Cr, mapRuntimes as Ct, endRun as D, agentById as Di, readMarker as Dn, lifecyclePill as Dr, ARCHITECTURE_DIR as Dt, completeRun as E, AGENT_IDS as Ei, isWorktreeHeld as En, lifecycleItemLabel as Er, describeRuntimes as Et, runBatch as F, followedBranch as Fn, readQueue as Fr, trackedFiles as Ft, reviewsUrl as G, saveJob as Gn, explanationOf as Gr, categoryOf as Gt, clearServerRecordOwnedBy as H, fail as Hn, processDiscussion as Hr, announceJob as Ht, activateQueued as I, reviewedShaOf as In, doneVerb as Ir, ownersOf as It, stopChild as J, phasesFor as Jn, ANALYSIS_ONLY as Jr, createPrUpdate as Jt, serverEntryExists as K, PHASES as Kn, isExplanationAction as Kr, createArchitectureNotification as Kt, compactQueue as L, fetchHead as Ln, isIssueOutstanding as Lr, QUOTE_LIMITS as Lt, extractPullRequestLinks as M, findExistingReview as Mn, queueAddMany as Mr, repositoryKey as Mt, parsePullRequestLink as N, checkCodeFreshness as Nn, queueRemove as Nr, storeArchitecture as Nt, reportRun as O, agentFor as Oi, removeWorktree as On, offersLifecycle as Or, checkArchitecture as Ot, unsupportedReason as P, checkReview as Pn, queueStamp as Pr, storedScopes as Pt, DEFAULT_WORKSPACE_PORT as Q, isClaimed as Qn, findingAssessment as Qr, markRead as Qt, queueForReview as R, forgeResolver as Rn, isQuestionOutstanding as Rr, REPOSITORY_SCOPE as Rt, isDriving as S, readAgentPreference as Si, ReviewBeingDeletedError as Sn, activityAttributes as Sr, waitingHistory as St, beginRun as T, STORE_ROOT as Ti, holdWorktree as Tn, lifecycleChip as Tr, RUNTIME_WORDS as Tt, ensureServer as U, isTerminal as Un, recommendationsOf as Ur, branchOf as Ut, bootstrapUrl as V, endedAt as Vn, reviewerDispositions as Vr, writeJsonAtomically as Vt, readServerRecord as W, loadJob as Wn, explanationActionOf as Wr, subjectOf as Wt, workspaceUrl as X, purposeOf as Xn, assessmentLookup as Xr, listNotifications as Xt, stopServer as Y, progressSteps as Yn, analysisRefOf as Yr, eventName as Yt, writeServerRecord as Z, clearClaim as Zn, currentGradeIn as Zr, markAllRead as Zt, liveUpdateFor as _, resolveBase as _i, CODE_BLOCK_CLASS as _n, summarise as _r, telemetryUploadConsent as _t, wasBlocked as a, wasReassessed as ai, retireNotification as an, kissDecisionsOf as ar, failureOf as at, recordKissRun as b, resolveModel as bi, renderInlineText as bn, workspaceStamps as br, PACKAGE_NAME as bt, RefreshUnavailableError as c, extractJsonText as ci, unreadCount as cn, loadWorkspace as cr, reanalyseReview as ct, mergeUpdateInto as d, WITHHELD_REASON as di, EXPLAIN_SIMPLY_PROMPT as dn, positionInLineage as dr, append as dt, gradeScale as ei, moveIds as en, followedRefName as er, MIN_WORKSPACE_PORT as et, updateReview as f, kissOutcome as fi, UNESTABLISHED_MOTIVATION as fn, presentedKissRunOf as fr, readEvents as ft, UpdateAlreadyRunningError as g, isCommitReview as gi, renderMarkdown as gn, reviewedRepositories as gr, recordTelemetryUploadConsent as gt, askCheckout as h, DetachedHeadError as hi, GITHUB_MARKDOWN as hn, reviewedCommit as hr, deliver as ht, liveJobsFor as i, sourcePhrase as ii, removeNotification as in, kissDecisionRefusal as ir, writePortPreference as it, batchIdentity as j, AgentUnavailableError as ji, describeSubject as jn, queueAdd as jr, readArchitecture as jt, stopRun as k, detectAgents as ki, requestJobStop as kn, parseLifecycle as kr, loadArchitecture as kt, cancelUpdate as l, objectWithAnyOf as li, withUsageRecorded as ln, matchingWorkspaceIds as lr, runJob as lt, isUnchanged as m, originRemote as mi, hasAuthorContent as mn, recentWorkspaces as mr, stamp as mt, deleteReview as n, promptGrade as ni, readNotification as nn, indexKeptIds as nr, resolveWorkspacePort as nt, discardJob as o, followUpFindingId as oi, toneOf as on, latestKissRun as or, prepareReview as ot, refreshPrContext as p, resolveTarget as pi, authorPreview as pn, previousKissResult as pr, record as pt, spawnServer as q, isLiveJob as qn, withExplanation as qr, createPrState as qt, lineageIds as r, reassessIn as ri, readStateOf as rn, indexReviewGroups as rr, statedWorkspacePort as rt, FETCH_TIMEOUT_MS as s, asString$1 as si, unreadAround as sn, lineagePosition as sr, settleReview as st, deleteLineage as t, isGradeFor as ti, pruneNotifications as tn, groupByLineage as tr, parseWorkspacePort as tt, cancellableHere as u, describeAuthorship as ui, existingPaths as un, mutateWorkspace as ur, startJob as ut, runningJobs as v, git as vi, CODE_COPY_CLASS as vn, touchWorkspace as vr, telemetryUploadEnabled as vt, RUN_KINDS as w, CONFIG_PATH as wi, createWorktree as wn, isLifecycle as wr, recordRuntimeBestEffort as wt, startKissJob as x, clearAgentPreference as xi, modelHelpLines as xn, LIFECYCLES as xr, feedbackUrl as xt, agentEnvOf as y, resolveAgent as yi, escapeHtml as yn, workspaceRevision as yr, BUILD_VERSION as yt, settleQueue as z, fillFileUrlTemplate as zn, issuesOutstanding as zr, ancestorsOf as zt };
+export { resolveWorkspacePort as $, PHASES as $n, explanationOf as $r, readNotification as $t, parsePullRequestLink as A, readAgentPreference as Ai, MANAGED_ROOT as An, activityLabel as Ar, storeArchitecture as At, ensureServer as B, checkCodeFreshness as Bn, queueRemove as Br, branchOf as Bt, completeRun as C, DetachedHeadError as Ci, renderMarkdown as Cn, reviewedRepositories as Cr, describeRuntimes as Ct, relativeTime as D, resolveAgent as Di, renderInlineText as Dn, workspaceStamps as Dr, partFiles as Dt, stopRun as E, git as Ei, escapeHtml as En, workspaceRevision as Er, loadArchitecture as Et, queueForReview as F, agentById as Fi, removeWorktree as Fn, offersLifecycle as Fr, REPOSITORY_SCOPE as Ft, stopChild as G, forgeResolver as Gn, isQuestionOutstanding as Gr, createPrUpdate as Gt, reviewsUrl as H, followedBranch as Hn, readQueue as Hr, categoryOf as Ht, settleQueue as I, agentFor as Ii, requestJobStop as In, parseLifecycle as Ir, ancestorsOf as It, writeServerRecord as J, endedAt as Jn, resolvedByConversation as Jr, markAllRead as Jt, stopServer as K, fillFileUrlTemplate as Kn, issuesOutstanding as Kr, eventName as Kt, readIndexToken as L, detectAgents as Li, describeMovement as Ln, sectionOf as Lr, isArchitectureId as Lt, runBatch as M, CONFIG_PATH as Mi, holdWorktree as Mn, lifecycleChip as Mr, trackedFiles as Mt, activateQueued as N, STORE_ROOT as Ni, isWorktreeHeld as Nn, lifecycleItemLabel as Nr, ownersOf as Nt, batchIdentity as O, resolveModel as Oi, modelHelpLines as On, LIFECYCLES as Or, readArchitecture as Ot, compactQueue as P, AGENT_IDS as Pi, readMarker as Pn, lifecyclePill as Pr, QUOTE_LIMITS as Pt, parseWorkspacePort as Q, saveJob as Qn, explanationActionOf as Qr, pruneNotifications as Qt, bootstrapUrl as R, AgentCancelledError as Ri, describeSubject as Rn, queueAdd as Rr, writeJsonAtomically as Rt, beginRun as S, originRemote as Si, GITHUB_MARKDOWN as Sn, reviewedCommit as Sr, RUNTIME_WORDS as St, reportRun as T, resolveBase as Ti, CODE_COPY_CLASS as Tn, touchWorkspace as Tr, checkArchitecture as Tt, serverEntryExists as U, reviewedShaOf as Un, doneVerb as Ur, createArchitectureNotification as Ut, readServerRecord as V, checkReview as Vn, queueStamp as Vr, subjectOf as Vt, spawnServer as W, fetchHead as Wn, isIssueOutstanding as Wr, createPrState as Wt, MAX_WORKSPACE_PORT as X, isTerminal as Xn, processDiscussion as Xr, markReadForReview as Xt, DEFAULT_WORKSPACE_PORT as Y, fail as Yn, reviewerDispositions as Yr, markRead as Yt, MIN_WORKSPACE_PORT as Z, loadJob as Zn, recommendationsOf as Zr, moveIds as Zt, recordKissRun as _, objectWithAnyOf as _i, EXPLAIN_SIMPLY_PROMPT as _n, mutateWorkspace as _r, PACKAGE_NAME as _t, wasBlocked as a, currentGradeIn as ai, unreadCount as an, isClaimed as ar, reanalyseReview as at, track as b, kissOutcome as bi, authorPreview as bn, previousKissResult as br, mapRuntimes as bt, RefreshUnavailableError as c, gradeScale as ci, ASK_REREAD_CEILING_MS as cn, groupByLineage as cr, append as ct, mergeUpdateInto as d, reassessIn as di, saveRefresh as dn, kissDecisionRefusal as dr, stamp as dt, isExplanationAction as ei, readStateOf as en, isLiveJob as er, statedWorkspacePort as et, updateReview as f, sourcePhrase as fi, storedConversation as fn, kissDecisionsOf as fr, deliver as ft, runningJobs as g, extractJsonText as gi, agentEnvOf as gn, matchingWorkspaceIds as gr, BUILD_VERSION as gt, liveUpdateFor as h, asString$1 as hi, isUnchanged as hn, loadWorkspace as hr, telemetryUploadEnabled as ht, liveJobsFor as i, assessmentLookup as ii, unreadAround as in, clearClaim as ir, settleReview as it, unsupportedReason as j, writeAgentPreference as ji, createWorktree as jn, isLifecycle as jr, storedScopes as jt, extractPullRequestLinks as k, clearAgentPreference as ki, ReviewBeingDeletedError as kn, activityAttributes as kr, repositoryKey as kt, cancelUpdate as l, isGradeFor as li, adoptLegacyBaseline as ln, indexKeptIds as lr, readEvents as lt, UpdateAlreadyRunningError as m, followUpFindingId as mi, refreshPrContext as mn, lineagePosition as mr, telemetryUploadConsent as mt, deleteReview as n, ANALYSIS_ONLY as ni, retireNotification as nn, progressSteps as nr, failureOf as nt, discardJob as o, findingAssessment as oi, withUsageRecorded as on, decideKissRecommendation as or, runJob as ot, askCheckout as p, wasReassessed as pi, unforeseenFailure as pn, latestKissRun as pr, recordTelemetryUploadConsent as pt, workspaceUrl as q, allJobs as qn, questionsOutstanding as qr, listNotifications as qt, lineageIds as r, analysisRefOf as ri, toneOf as rn, purposeOf as rr, prepareReview as rt, FETCH_TIMEOUT_MS as s, findingIn as si, existingPaths as sn, followedRefName as sr, startJob as st, deleteLineage as t, withExplanation as ti, removeNotification as tn, phasesFor as tr, writePortPreference as tt, cancellableHere as u, promptGrade as ui, prepareConversationWithin as un, indexReviewGroups as ur, record as ut, startKissJob as v, describeAuthorship as vi, chatConversationSection as vn, positionInLineage as vr, feedbackUrl as vt, endRun as w, isCommitReview as wi, CODE_BLOCK_CLASS as wn, summarise as wr, ARCHITECTURE_DIR as wt, RUN_KINDS as x, resolveTarget as xi, hasAuthorContent as xn, recentWorkspaces as xr, recordRuntimeBestEffort as xt, isDriving as y, WITHHELD_REASON as yi, UNESTABLISHED_MOTIVATION as yn, presentedKissRunOf as yr, waitingHistory as yt, clearServerRecordOwnedBy as z, AgentUnavailableError as zi, findExistingReview as zn, queueAddMany as zr, announceJob as zt };