prreviewbuddy 0.12.0

package/dist/server.js

@@ -0,0 +1,3849 @@
+import { B as lineagePosition, C as clearClaim, D as removeWorktree, E as readMarker, F as loadJob, G as saveWorkspace, I as saveJob, J as processDiscussion, M as deleteJob, N as fail, O as relativeTime$1, P as isTerminal, R as STORE_ROOT, S as fillFileUrlTemplate, T as MANAGED_ROOT, U as recentReviewGroups, V as loadWorkspace, Y as describeAuthorship, _ as feedbackUrl, a as refreshPrContext, b as EXPLAIN_SIMPLY_PROMPT, c as agentEnvOf, et as agentFor, g as BUILD_VERSION, h as writeServerRecord, i as updateReview, j as allJobs, k as checkFreshness, n as record, nt as AgentUnavailableError, o as isUnchanged, q as touchWorkspace, r as RefreshUnavailableError, s as askCheckout, t as readEvents, u as clearServerRecord, v as runJob, w as isClaimed } from "./log-DdPaO6Wo.js";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:http";
+//#region ../../packages/review-harness/src/domain/ai_review/review_composition.ts
+/**
+* What a follow-up actually reviewed — the files it wrote about, not the files it was handed.
+*
+* This distinction is the whole of a bug found on a live run. Composing from `scope.paths` made
+* the Overview claim "480 of 482 reviewed in depth" while the card beside it read `20 / 482`: the
+* card counts files the model sectioned, and a follow-up given 467 files had sectioned seven of
+* them. The runbook's phase 2 rule is explicit — the numerator is what the model sectioned, and
+* crossing it with what we sent produces a confidently wrong number, which is worse than the
+* missing one it replaced.
+*
+* Being handed a file is not evidence it was read. Only the model's own output is.
+*/
+function coveredByRun(run) {
+	return [...run.result.sections.flatMap((section) => section.files.map((file) => file.path)), ...run.result.fileNotes.map((note) => note.path)];
+}
+var RISK_RANK = {
+	low: 0,
+	medium: 1,
+	high: 2
+};
+/**
+* Risk after follow-ups, derived from the model's own severity rather than from coverage.
+*
+* Only ever escalates, and only on a `critical` finding. Two things this deliberately is not:
+* it is not a fresh verdict from a second model (nobody asked for one), and it is not a coverage
+* heuristic — "more files reviewed means lower risk" would fire on every large PR and is exactly
+* the kind of threshold rule invariant 0 rejects. A follow-up that finds a critical problem has
+* demonstrably raised the stakes; a follow-up that finds nothing has not lowered them, because
+* absence of a finding in one area says nothing about the areas still unread.
+*/
+function deriveOverallRisk(primary, followUpIssues) {
+	return followUpIssues.some((issue) => issue.severity === "critical") && RISK_RANK[primary] < RISK_RANK.high ? "high" : primary;
+}
+/**
+* Namespaces a follow-up's ids so they can never collide with the primary's — or each other's.
+*
+* Primary ids are never renumbered, in any circumstance, for any reason: that is the invariant
+* `completedSectionIds` and `answeredQuestionIds` depend on. Models also reuse obvious ids like
+* "s1" across runs, so without a per-run prefix a second follow-up would silently overwrite the
+* first in every id-keyed lookup.
+*/
+function namespaced(runId, id) {
+	return `${runId}:${id}`;
+}
+function composeSections(primary, runs, notesBySection) {
+	const composed = primary.map((section) => {
+		const notes = notesBySection.get(section.id);
+		if (!notes) return { ...section };
+		const files = section.files.map((file) => {
+			const focus = notes.get(file.path);
+			return focus ? {
+				...file,
+				focus
+			} : file;
+		});
+		const reassessed = section.files.some((file) => notes.has(file.path));
+		return {
+			...section,
+			files,
+			reassessed
+		};
+	});
+	const primaryCount = composed.length;
+	for (const run of runs) for (const section of run.result.sections) composed.push({
+		...section,
+		id: namespaced(run.id, section.id),
+		fromFollowUpId: run.id,
+		recommendedStartingPoint: false
+	});
+	return [...composed.slice(0, primaryCount).sort((a, b) => a.order - b.order), ...composed.slice(primaryCount)].map((section, index) => ({
+		...section,
+		order: index + 1
+	}));
+}
+/**
+* Suggested areas with anything a follow-up has since reviewed removed.
+*
+* Without this the card that just ran stays on screen offering to run again — and clicking it
+* would re-review the same files and bill for it twice. An area is a claim about work still
+* outstanding, so it has to be derived from current coverage rather than frozen at plan time.
+*
+* A partially covered area keeps its card with a reduced count, which is honest: the rest of it
+* genuinely has not been read. An area with nothing left disappears entirely.
+*/
+function composeSuggestedAreas(session, reviewedPaths) {
+	return (session.metadata.suggestedAreas ?? []).map((area) => {
+		if (!area.paths?.length) return area;
+		const remaining = area.paths.filter((path) => !reviewedPaths.has(path));
+		return {
+			...area,
+			paths: remaining,
+			fileCount: remaining.length
+		};
+	}).filter((area) => area.paths === void 0 || area.paths.length > 0);
+}
+/**
+* Coverage after follow-ups, so the Overview's count climbs as more of the PR gets read.
+*
+* Only recomputed when the primary recorded `reviewedPaths`. Without that list there is no way to
+* union anything — adding the follow-up's file count to the stored total would double-count every
+* file both runs saw, and a coverage number that overstates itself is the exact bug phase 2
+* existed to kill.
+*/
+function composeCoverage(session, reviewedPaths, runs) {
+	const coverage = session.metadata.fileCoverage;
+	if (!coverage?.reviewedPaths) return coverage;
+	const partialFiles = composePartialFiles(coverage.partialFiles, runs);
+	return {
+		...coverage,
+		reviewedFiles: reviewedPaths.size,
+		reviewedPaths: [...reviewedPaths],
+		...partialFiles ? {
+			partialFiles,
+			partiallyReadFiles: partialFiles.length
+		} : {}
+	};
+}
+/**
+* How far each file has been read, after replaying the follow-up runs over the primary's answer.
+*
+* The rule is "the last run to touch a file is the one that knows": a run is given the file's
+* outstanding remainder, so whatever it reports back supersedes what it was told. A file the run
+* covered and did *not* report as partial has been read to the end and leaves the list — that
+* absence is the only signal that anything ever completes, which is why `FollowUpRun.partialFiles`
+* being `[]` and being `undefined` have to stay distinguishable.
+*
+* Returns `undefined` when nothing can be said: a primary that predates the field, with no run
+* carrying the information either. `[]` is a real answer and means everything has been read whole.
+*/
+function composePartialFiles(primary, runs) {
+	if (primary === void 0 && runs.every((r) => r.partialFiles === void 0)) return void 0;
+	const outstanding = new Map((primary ?? []).map((p) => [p.path, p]));
+	for (const run of runs) {
+		if (run.partialFiles === void 0) continue;
+		for (const path of run.scope.paths) outstanding.delete(path);
+		for (const partial of run.partialFiles) outstanding.set(partial.path, partial);
+	}
+	return [...outstanding.values()];
+}
+/**
+* Composes a session's primary result with its follow-up runs. Pure, deterministic, total.
+*
+* Returns `null` only when there is no primary result — a session that has not produced one has
+* nothing for follow-ups to attach to.
+*/
+function composeReview(session) {
+	const primary = session.result;
+	if (!primary) return null;
+	const runs = [...session.followUps ?? []].sort((a, b) => a.generatedAt - b.generatedAt);
+	const notesBySection = /* @__PURE__ */ new Map();
+	for (const run of runs) for (const note of run.result.fileNotes) {
+		const forSection = notesBySection.get(note.sectionId) ?? /* @__PURE__ */ new Map();
+		forSection.set(note.path, note.focus);
+		notesBySection.set(note.sectionId, forSection);
+	}
+	const alreadyRead = new Set(session.metadata.fileCoverage?.reviewedPaths ?? []);
+	const issues = primary.issues.map((issue) => ({ ...issue }));
+	const questions = primary.questions.map((question) => ({ ...question }));
+	const followUpIssues = [];
+	for (const run of runs) {
+		for (const issue of run.result.issues) {
+			followUpIssues.push(issue);
+			issues.push({
+				...issue,
+				id: namespaced(run.id, issue.id),
+				sectionId: issue.sectionId ? resolveSectionId(run, issue.sectionId) : void 0,
+				fromFollowUpId: run.id,
+				reassessment: issue.file !== void 0 && alreadyRead.has(issue.file) ? true : void 0
+			});
+		}
+		for (const question of run.result.questions) questions.push({
+			...question,
+			id: namespaced(run.id, question.id),
+			sectionId: question.sectionId ? resolveSectionId(run, question.sectionId) : void 0
+		});
+	}
+	const overallRisk = deriveOverallRisk(primary.overallRisk, followUpIssues);
+	const reviewedPaths = /* @__PURE__ */ new Set([...session.metadata.fileCoverage?.reviewedPaths ?? [], ...runs.flatMap(coveredByRun)]);
+	return {
+		schemaVersion: 1,
+		summary: primary.summary,
+		recommendation: primary.recommendation,
+		nextSteps: primary.nextSteps,
+		overallRisk,
+		riskEscalated: overallRisk !== primary.overallRisk,
+		sections: composeSections(primary.sections, runs, notesBySection),
+		issues,
+		questions,
+		reviewedPaths: [...reviewedPaths],
+		suggestedAreas: composeSuggestedAreas(session, reviewedPaths),
+		fileCoverage: composeCoverage(session, reviewedPaths, runs),
+		runs
+	};
+}
+/**
+* An item's sectionId may point at a section the same run created (namespaced along with it) or
+* at an existing primary section (left alone). Getting this backwards would orphan every issue a
+* follow-up raised against the guide it was reviewing.
+*/
+function resolveSectionId(run, sectionId) {
+	return run.result.sections.some((section) => section.id === sectionId) ? namespaced(run.id, sectionId) : sectionId;
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/utils/html.ts
+function escapeHtml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderInlineText(value) {
+	return escapeHtml(value).replace(/`([^`\n]+)`/g, "<code>$1</code>");
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/utils/file_path.ts
+/**
+* Splits a repo-relative path for display, so the filename can be shown prominently and the
+* directory demoted to context. Deep monorepo paths are mostly prefix — rendering them at equal
+* weight buries the one part that identifies the file.
+*/
+function splitFilePath(path) {
+	const lastSlash = path.lastIndexOf("/");
+	if (lastSlash === -1) return {
+		dir: "",
+		name: path
+	};
+	return {
+		dir: path.slice(0, lastSlash),
+		name: path.slice(lastSlash + 1)
+	};
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/ai_review/review_metrics.ts
+/**
+* Overview counts, derived entirely from the review content the user actually reads.
+*
+* These were previously read straight off the model's output — in particular `files` used
+* `result.files.length`, a top-level per-file summary list that the model was free to omit and
+* routinely did on larger PRs, so the Overview reported "0 Files" on a 29-file review. Nothing
+* was broken; the count simply measured a field the model had declined to fill in. That field no
+* longer exists (see types.ts) and sections are now the single source of truth for files.
+*
+* The rule this encodes: the AI generates content, the extension counts it. Any metric that can
+* be computed from content the user can see should be, so a number in the UI can never disagree
+* with the thing it claims to be counting.
+*/
+function deriveReviewMetrics(result) {
+	return {
+		files: new Set(result.sections.flatMap((s) => s.files.map((f) => f.path))).size,
+		sections: result.sections.length,
+		issues: result.issues.length,
+		questions: result.questions.length
+	};
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/utils/relative_time.ts
+function formatRelativeTime(ts, now = Date.now()) {
+	const diffMs = Math.max(0, now - ts);
+	const minute = 6e4;
+	const hour = 60 * minute;
+	const day = 24 * hour;
+	if (diffMs < minute) return "Just now";
+	if (diffMs < hour) {
+		const mins = Math.floor(diffMs / minute);
+		return `${mins} min${mins === 1 ? "" : "s"} ago`;
+	}
+	if (diffMs < day) {
+		const hours = Math.floor(diffMs / hour);
+		return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+	}
+	const days = Math.floor(diffMs / day);
+	return `${days} day${days === 1 ? "" : "s"} ago`;
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/utils/code_block.ts
+var CODE_BLOCK_CLASS = "pr-helper-code-block";
+var CODE_COPY_CLASS = "pr-helper-code-copy";
+//#endregion
+//#region ../../packages/review-harness/src/domain/utils/markdown.ts
+var BLOCK_MARKER = "\0";
+var INLINE_MARKER = "
";
+var BLOCK_TOKEN = /\u0000(\d+)\u0000/g;
+var BLOCK_TOKEN_LINE = /^\u0000\d+\u0000$/;
+var INLINE_TOKEN = /\u0001(\d+)\u0001/g;
+var SAFE_HREF = /^(?:https?:\/\/|#)/i;
+function renderMarkdown(value) {
+	const { text, blocks } = extractFencedBlocks(value.replace(/[\u0000\u0001]/g, ""));
+	return restoreFencedBlocks(renderBlocks(text), blocks);
+}
+function extractFencedBlocks(value) {
+	const blocks = [];
+	const lines = value.split("\n");
+	const out = [];
+	let i = 0;
+	while (i < lines.length) {
+		const opening = lines[i].match(/^\s*(`{3,}|~{3,})\s*[\w+#.-]*\s*$/);
+		if (!opening) {
+			out.push(lines[i]);
+			i += 1;
+			continue;
+		}
+		const closing = new RegExp(`^\\s*${opening[1][0]}{3,}\\s*$`);
+		const body = [];
+		i += 1;
+		while (i < lines.length && !closing.test(lines[i])) {
+			body.push(lines[i]);
+			i += 1;
+		}
+		i += 1;
+		out.push(`${BLOCK_MARKER}${blocks.length}${BLOCK_MARKER}`);
+		blocks.push(body.join("\n"));
+	}
+	return {
+		text: out.join("\n"),
+		blocks
+	};
+}
+function restoreFencedBlocks(html, blocks) {
+	return html.replace(BLOCK_TOKEN, (_match, index) => `<div class="${CODE_BLOCK_CLASS}"><pre><code>${escapeHtml(blocks[Number(index)])}</code></pre><button type="button" class="${CODE_COPY_CLASS}" aria-label="Copy code">Copy</button></div>`);
+}
+function renderBlocks(text) {
+	const out = [];
+	let paragraph = [];
+	let quote = [];
+	let list = null;
+	const flush = () => {
+		if (paragraph.length) out.push(`<p>${renderInline(paragraph.join(" "))}</p>`);
+		if (quote.length) out.push(`<blockquote>${renderInline(quote.join(" "))}</blockquote>`);
+		if (list) out.push(`<${list.tag}>${list.items.map((item) => `<li>${renderInline(item)}</li>`).join("")}</${list.tag}>`);
+		paragraph = [];
+		quote = [];
+		list = null;
+	};
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (!line) {
+			flush();
+			continue;
+		}
+		if (BLOCK_TOKEN_LINE.test(line)) {
+			flush();
+			out.push(line);
+			continue;
+		}
+		if (/^(?:-{3,}|\*{3,}|_{3,})$/.test(line)) {
+			flush();
+			out.push("<hr>");
+			continue;
+		}
+		const heading = line.match(/^(#{1,6})\s+(.+)$/);
+		if (heading) {
+			flush();
+			const level = Math.min(heading[1].length, 3) + 3;
+			out.push(`<h${level}>${renderInline(heading[2])}</h${level}>`);
+			continue;
+		}
+		const bullet = line.match(/^[-*+]\s+(.+)$/);
+		if (bullet) {
+			if (list?.tag !== "ul") {
+				flush();
+				list = {
+					tag: "ul",
+					items: []
+				};
+			}
+			list.items.push(bullet[1]);
+			continue;
+		}
+		const ordered = line.match(/^\d{1,9}[.)]\s+(.+)$/);
+		if (ordered) {
+			if (list?.tag !== "ol") {
+				flush();
+				list = {
+					tag: "ol",
+					items: []
+				};
+			}
+			list.items.push(ordered[1]);
+			continue;
+		}
+		const quoted = line.match(/^>\s?(.*)$/);
+		if (quoted) {
+			if (!quote.length) flush();
+			quote.push(quoted[1]);
+			continue;
+		}
+		if (list && list.items.length) {
+			list.items[list.items.length - 1] += ` ${line}`;
+			continue;
+		}
+		if (quote.length) {
+			quote[quote.length - 1] += ` ${line}`;
+			continue;
+		}
+		paragraph.push(line);
+	}
+	flush();
+	return out.join("");
+}
+function renderInline(value) {
+	const codeSpans = [];
+	return escapeHtml(value).replace(/`([^`\n]+)`/g, (_match, code) => {
+		codeSpans.push(code);
+		return `${INLINE_MARKER}${codeSpans.length - 1}${INLINE_MARKER}`;
+	}).replace(/(?<!!)\[([^\]\n]+)\]\(([^)\s]+)\)/g, (match, label, href) => SAFE_HREF.test(href) ? `<a href="${href}" target="_blank" rel="noopener noreferrer">${label}</a>` : match).replace(/\*\*([^*\n]+)\*\*/g, "<strong>$1</strong>").replace(/__([^_\n]+)__/g, "<strong>$1</strong>").replace(/(^|[^*\w])\*([^*\n]+)\*/g, "$1<em>$2</em>").replace(/(^|[^_\w])_([^_\n]+)_(?![\w_])/g, "$1<em>$2</em>").replace(INLINE_TOKEN, (_match, index) => `<code>${codeSpans[Number(index)]}</code>`);
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/utils/model_label.ts
+var KNOWN_BRANDS = {
+	gpt: "GPT",
+	claude: "Claude"
+};
+var isNumericToken = (token) => /^\d+(\.\d+)?$/.test(token);
+function titleCase$1(token) {
+	return token.charAt(0).toUpperCase() + token.slice(1);
+}
+function humanizeModelId(id) {
+	const tokens = id.split("-").filter(Boolean);
+	if (tokens.length === 0) return id;
+	const [brandToken, ...rest] = tokens;
+	let display = KNOWN_BRANDS[brandToken.toLowerCase()] ?? titleCase$1(brandToken);
+	let prevWasNumeric = false;
+	rest.forEach((token, index) => {
+		const numeric = isNumericToken(token);
+		if (numeric && prevWasNumeric) display += `.${token}`;
+		else if (numeric && index === 0) display += `-${token}`;
+		else display += ` ${numeric ? token : titleCase$1(token)}`;
+		prevWasNumeric = numeric;
+	});
+	return display;
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/ui/components/pill_tooltips.ts
+/**
+* What every pill in the sidebar actually means, in one place.
+*
+* A pill is a single uppercase word standing in for a whole axis of judgement, and the axes are
+* not self-evident: MAJOR and "medium confidence" sit side by side on the same card and answer
+* completely different questions. Severity is how much the finding would matter *if it is real*;
+* confidence is how sure the analysis is that it *is* real. A reviewer who has collapsed those
+* into one mental "how bad is this" scale is reading the card wrong, and no amount of colour
+* fixes that — only words do.
+*
+* The wording is derived from the field guidance the model is actually given (see
+* STRUCTURED_OUTPUT_INSTRUCTIONS in ai_review/pipeline.ts). This file must not invent a richer
+* taxonomy than the prompt asks for: if the prompt does not define what separates "major" from
+* "minor", neither does the tooltip. It names the axis and where the value sits on it, and
+* leaves the grading to the model that did the grading.
+*
+* House style, because a tooltip is read once at a glance and never studied:
+*
+* 1. Open with the concept, not a sentence the reader has to parse into one. "PR risk — the
+*    overall risk level assigned to this pull request" lands before the clause finishes;
+*    "Overall risk this analysis assigned the pull request" makes them unpick the grammar first.
+* 2. Describe what the thing *is*, never how the extension builds it. A follow-up "builds on the
+*    original analysis" — that it is composed into the stored session is our problem, not theirs.
+* 3. Plain reviewer's English over product vocabulary. "During your review", not "before you
+*    sign off"; "the section of the Guide", not the section's own title read back at them.
+*/
+/** Ordered worst-first, matching how the prompt lists the enum. */
+var SEVERITY_SCALE = [
+	"critical",
+	"major",
+	"minor",
+	"nit"
+];
+var ATTENTION_SCALE = [
+	"high",
+	"medium",
+	"low"
+];
+/**
+* "2 of 4: critical → major → minor → nit" — the value's rank and the whole scale it sits on.
+*
+* Both halves earn their place: the rank alone leaves the reader guessing what the other steps
+* are, and the scale alone makes them count. An arrow rather than a bullet or comma, so the
+* ordering is visible rather than something the reader has to already know.
+*/
+function position(value, scale) {
+	const index = scale.indexOf(value);
+	if (index === -1) return scale.join(" → ");
+	return `${index + 1} of ${scale.length}: ${scale.join(" → ")}`;
+}
+function severityTip(severity) {
+	return `Severity — how much this would matter if it turns out to be real. ${position(severity, SEVERITY_SCALE)}.`;
+}
+/**
+* Only medium and low ever reach the screen (renderIssueConfidence suppresses "high"), but all
+* three are worded here so the copy does not depend on that rendering decision staying put.
+*
+* The second sentence is the one that matters. Confidence and severity sit side by side on the
+* same card, and a reader who has not been told otherwise will assume they are the same scale
+* read twice — so the tooltip says they are not, in as many words.
+*/
+function confidenceTip(confidence) {
+	return `Confidence — how sure the analysis is that this issue is real. This is separate from how serious it would be. ${{
+		high: "High means the analysis is confident it’s real.",
+		medium: "Medium means it’s worth confirming in the code before acting on it.",
+		low: "Low means it was likely reasoned from the diff alone, so check the surrounding code first."
+	}[confidence]}`;
+}
+function importanceTip(importance) {
+	return `Importance — how much attention this question deserves during your review. ${position(importance, ATTENTION_SCALE)}.`;
+}
+/**
+* The four statuses an "Analyse new changes" pass assigns to a finding.
+*
+* Each says what the *product* concluded and, where it matters, how much to trust it. "Still open"
+* carries the load: it is both a real judgement ("the changes do not address this") and the safe
+* default applied when the analysis said nothing about a finding at all, and the reviewer cannot
+* tell those apart from the badge — so the copy commits to the weaker of the two readings rather
+* than claiming a judgement that may not have been made.
+*/
+function findingStatusTip(status) {
+	return {
+		resolved: "Resolved — the new commits appear to address this finding. Worth a glance to confirm before you close it out.",
+		"still-open": "Still open — the new commits do not address this finding. Findings the analysis did not comment on are shown this way too, so this never disappears on its own.",
+		affected: "Affected — the code this finding concerns has changed, but not in a way that settles it. Re-read this one.",
+		new: "New — introduced by the changes pushed since your previous analysis."
+	}[status];
+}
+/** The reviewer-facing label for a status. Kept beside the tooltips so the two cannot drift. */
+function findingStatusLabel(status) {
+	return {
+		resolved: "Resolved",
+		"still-open": "Still open",
+		affected: "Affected",
+		new: "New"
+	}[status];
+}
+/**
+* What the commits pushed since did to an open question.
+*
+* "Still open" carries the same double load it does on a finding: a real judgement, and the default
+* for a question the reassessment never mentioned. The copy commits to the weaker reading, because
+* the reviewer must not read silence as an answer.
+*/
+function questionStatusTip(status) {
+	return {
+		answered: "Answered — the new commits settle this, and the answer is below. Worth a glance to confirm before you drop it.",
+		"still-open": "Still open — the new commits do not settle this. Questions the reassessment did not comment on are shown this way too, so this never disappears on its own.",
+		affected: "Affected — the code this question is about has changed without answering it. Read the question again before you ask it."
+	}[status];
+}
+/** The reviewer-facing label for a question status. Kept beside the tooltip so the two cannot drift. */
+function questionStatusLabel(status) {
+	return {
+		answered: "Answered",
+		"still-open": "Still open",
+		affected: "Affected"
+	}[status];
+}
+/**
+* The four impacts a repository investigation assigns to a finding.
+*
+* Every one of these says the evidence came from *outside* the diff, because that is the whole
+* reason to trust them more than the analysis they revise — and equally the reason to say where
+* they came from. "A coding agent read the repository" is the qualification, and a reviewer who
+* does not know that cannot weigh it.
+*
+* "Investigated" carries the same load "Still open" does on the other axis: it is both a real
+* judgement ("this evidence does not bear on that finding") and the default applied when the
+* reassessment said nothing about a finding at all. The copy commits to the weaker reading rather
+* than claiming a judgement that may not have been made.
+*/
+function investigationImpactTip(impact) {
+	return {
+		confirmed: "Confirmed — a repository investigation found evidence supporting this finding. It no longer rests on the diff alone.",
+		refuted: "Refuted — a repository investigation found evidence that this concern does not hold. Kept on the list, with the reasoning, rather than removed.",
+		revised: "Revised — a repository investigation changed what this finding says. Where its severity or confidence moved, the previous value is shown alongside.",
+		unchanged: "Investigated — this finding was reassessed against a repository investigation and stands as it was. Findings the reassessment did not comment on are shown this way too."
+	}[impact];
+}
+/**
+* The reviewer-facing label. Note `unchanged` → "Investigated": the reviewer's world contains a
+* finding that was looked into and survived, which is information. "Unchanged" describes our
+* bookkeeping — what the field did — and says nothing about the code.
+*/
+function investigationImpactLabel(impact) {
+	return {
+		confirmed: "Confirmed",
+		refuted: "Refuted",
+		revised: "Revised",
+		unchanged: "Investigated"
+	}[impact];
+}
+var SECTION_TAG_TIP = "Guide section — the section of the Guide this finding belongs to. Click to open it in the Guide tab.";
+/**
+* Builds a pill's `class` and `data-tip` attributes together.
+*
+* They are emitted as one string rather than left to the call site because they are useless
+* apart: `data-tip` without `pr-helper-tip` never renders, and `pr-helper-tip` without a tip
+* renders an empty black rectangle on hover. Taking the pill's own classes as an argument means
+* there is no way to add the tooltip and clobber the styling, which is what a bare
+* `class="pr-helper-tip"` helper would have invited.
+*
+* Emits a leading space so it drops straight in after a tag name.
+*/
+function pillAttrs(classNames, tip) {
+	return ` class="${escapeHtml(classNames)} pr-helper-tip" data-tip="${escapeHtml(tip)}"`;
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/ai_review/investigation_record.ts
+/**
+* The records for one finding, oldest first. Records accumulate: every "Investigate Again" appends.
+*/
+function investigationsForFinding(records, findingKind, findingId) {
+	return (records ?? []).filter((r) => r.findingKind === findingKind && r.findingId === findingId);
+}
+/**
+* The record that decides which buttons a finding shows — the newest, because a reviewer who has
+* just asked again is mid-investigation regardless of what earlier rounds concluded.
+*/
+function newestInvestigationForFinding(records, findingKind, findingId) {
+	const matches = investigationsForFinding(records, findingKind, findingId);
+	return matches.length ? matches[matches.length - 1] : null;
+}
+//#endregion
+//#region ../../packages/review-harness/src/domain/ui/components/review_tabs.ts
+function emptyState(message) {
+	return `<p class="pr-helper-review-empty">${escapeHtml(message)}</p>`;
+}
+function renderNoReviewState(iconUrl) {
+	return `
+    <div class="pr-helper-review-intro">
+      ${iconUrl ? `<img src="${escapeHtml(iconUrl)}" class="pr-helper-intro-mark" alt="" />` : ""}
+      <p class="pr-helper-intro-brand">PR Review Buddy</p>
+      <h3 class="pr-helper-intro-title">No analysis yet</h3>
+      <p class="pr-helper-intro-body">Analyse this pull request to unlock summaries, issues, questions and the Assistant.</p>
+      <button type="button" class="pr-helper-generate-review-button">Generate Analysis</button>
+    </div>
+  `;
+}
+function titleCase(value) {
+	return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function hasExplainedSimply(session) {
+	return session.chat.some((m) => m.kind === "explain-simply");
+}
+var PROVIDER_DISPLAY_NAME = {
+	anthropic: "Claude",
+	openai: "GPT",
+	gemini: "Gemini",
+	openai_compatible: "the model"
+};
+var THINKING_PHRASES = [
+	"Buddy is reading the changes…",
+	"Buddy is connecting the dots…",
+	"Buddy is gathering context…",
+	"Buddy is preparing your analysis…"
+];
+var THINKING_PHRASE_CYCLE_SECONDS = 15;
+function renderThinkingPhrases() {
+	const phrases = [...THINKING_PHRASES];
+	for (let i = phrases.length - 1; i > 0; i--) {
+		const j = Math.floor(Math.random() * (i + 1));
+		[phrases[i], phrases[j]] = [phrases[j], phrases[i]];
+	}
+	const segment = THINKING_PHRASE_CYCLE_SECONDS / phrases.length;
+	return phrases.map((phrase, i) => `<p class="pr-helper-thinking-phrase" style="animation-delay:${(i * segment).toFixed(2)}s">${escapeHtml(phrase)}</p>`).join("");
+}
+var CANCEL_BUTTON = `<button type="button" class="pr-helper-cancel-button">Cancel</button>`;
+function renderGeneratingOverview(session, iconUrl) {
+	const activeIndex = session.progress.findIndex((step) => !step.done);
+	const brandMark = iconUrl ? `<img src="${escapeHtml(iconUrl)}" class="pr-helper-brand-mark" alt="" />` : "";
+	const poweredByName = session.provider === "openai_compatible" ? humanizeModelId(session.model) : PROVIDER_DISPLAY_NAME[session.provider];
+	const isThinking = activeIndex === 2;
+	return `
+    <div class="pr-helper-generating pr-helper-generating-focused">
+      <div class="pr-helper-generating-body">
+        ${brandMark}
+        ${isThinking ? `<div class="pr-helper-thinking-phrases">${renderThinkingPhrases()}</div>
+          <p class="pr-helper-generating-title pr-helper-direct-headline" hidden>This is taking longer than usual.</p>` : `<p class="pr-helper-generating-title">${activeIndex >= 0 && activeIndex < 2 ? "Preparing analysis" : "Finalizing analysis"}</p>`}
+        <div class="pr-helper-thinking-dots"><span></span><span></span><span></span></div>
+        <div class="pr-helper-progress-bar pr-helper-progress-bar-shimmer"></div>
+        ${isThinking ? `<p class="pr-helper-generating-elapsed"></p>
+        <p class="pr-helper-escalation-hint" hidden>AI providers occasionally experience delays.</p>` : ""}
+      </div>
+      <div class="pr-helper-generating-footer">
+        <p class="pr-helper-generating-powered-by">Powered by ${escapeHtml(poweredByName)}</p>
+        ${CANCEL_BUTTON}
+      </div>
+    </div>
+  `;
+}
+function renderFailedOverview(session) {
+	return `
+    <div class="pr-helper-generating-error">
+      <p class="pr-helper-generating-error-text">${escapeHtml(session.error ?? "The AI analysis failed.")}</p>
+      <button type="button" class="pr-helper-retry-button">Retry</button>
+    </div>
+  `;
+}
+function renderOverviewStat(value, label, tab, options = {}) {
+	const { info, ariaLabel } = options;
+	const wide = typeof value === "string" ? " pr-helper-overview-stat-value-wide" : "";
+	const icon = info ? `<span class="pr-helper-overview-stat-info" data-overview-info data-tip="${escapeHtml(info)}" aria-hidden="true"><svg viewBox="0 0 16 16" width="12" height="12" fill="currentColor"><path d="M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg></span>` : "";
+	return `<button type="button" class="pr-helper-overview-stat" data-overview-nav="${tab}"${ariaLabel ? ` aria-label="${escapeHtml(ariaLabel)}"` : ""}><span class="pr-helper-overview-stat-value${wide}">${escapeHtml(String(value))}</span><span class="pr-helper-overview-stat-label">${icon}${escapeHtml(label)}<span class="pr-helper-overview-stat-arrow" aria-hidden="true">→</span></span></button>`;
+}
+function renderCoverageStat(session, reviewedFiles) {
+	const coverage = composeReview(session)?.fileCoverage;
+	if (!coverage || coverage.totalChangedFiles <= reviewedFiles) return renderOverviewStat(reviewedFiles, "Files", "files");
+	if (coverage.repositoryAvailable) return renderOverviewStat(coverage.totalChangedFiles, "Files", "files");
+	return renderOverviewStat(`${reviewedFiles} / ${coverage.totalChangedFiles}`, "Files", "files", {
+		info: `All ${coverage.totalChangedFiles} changed files were triaged. ${coverage.unplanned ? "No analysis plan was produced, so the files analysed in depth were chosen by size of change." : "An analysis plan selected these for in-depth analysis; the rest are accounted for in the Guide and the Files tab."}`,
+		ariaLabel: `Analysis coverage: ${reviewedFiles} of ${coverage.totalChangedFiles} changed files analysed`
+	});
+}
+/**
+* Provenance — how the review was produced, as opposed to what it found.
+*
+* These facts used to sit as two paragraphs in the middle of the Overview, between the summary
+* and the suggested path. That was the wrong place: the Overview answers what the risk is, what
+* is changing, where to start and what to watch for, and none of this answers any of them. It is
+* the reviewer's right to audit how the review was made, but not at the cost of the four
+* questions they came for — so it collapses, and becomes the home for any future metadata.
+*/
+function coverageDetails(session) {
+	const coverage = composeReview(session)?.fileCoverage;
+	if (!coverage) return [];
+	const details = [];
+	const skipped = coverage.totalChangedFiles - coverage.reviewedFiles;
+	if (coverage.repositoryAvailable) {
+		const inline = coverage.reviewedPaths?.length;
+		details.push(inline === void 0 ? `All ${coverage.totalChangedFiles} changed files were named for the analysis, which had the repository open and could read any of them.` : `All ${coverage.totalChangedFiles} changed files were named for the analysis, which had the repository open: ${inline} arrived with ${inline === 1 ? "its diff" : "their diffs"} inline and it could read the rest directly.`);
+		return details;
+	}
+	details.push(skipped > 0 ? `All ${coverage.totalChangedFiles} changed files were triaged; ${coverage.reviewedFiles} ${coverage.reviewedFiles === 1 ? "was" : "were"} analysed in depth. Generated, vendored and lockfile changes were excluded, and the remaining files are available in the Files tab for your own review.` : `All ${coverage.totalChangedFiles} changed files were triaged and analysed in depth.`);
+	if (coverage.unplanned && skipped > 0) details.push("No analysis plan was produced for this PR, so the files analysed in depth were chosen by size of change.");
+	if (coverage.capBound) details.push(`The analysis plan identified more files than one pass can cover, so it was cut off at ${coverage.reviewedFiles}; the areas it ranked lowest were not reached.`);
+	const outstanding = coverage.partialFiles;
+	if (outstanding?.length) {
+		const n = outstanding.length;
+		const scale = n === 1 ? `${outstanding[0].path} (${outstanding[0].linesRead} of ${outstanding[0].linesTotal} diff lines read)` : `${n} files`;
+		details.push(`A further pass read on from where the first stopped, and ${n === 1 ? "one file is" : `${n} files are`} still larger than that could cover: ${scale}. The analysis was told exactly which lines it had seen, and asked to qualify anything it concluded from them.`);
+	} else if (outstanding === void 0 && coverage.partiallyReadFiles) {
+		const n = coverage.partiallyReadFiles;
+		details.push(`${n} ${n === 1 ? "file was" : "files were"} too large for the whole diff to fit in one pass, so ${n === 1 ? "it was" : "they were"} read in part. The analysis was told which, and asked to qualify anything it concluded from them.`);
+	}
+	return details;
+}
+function renderReviewDetails(session) {
+	const items = [...discussionDetails(session), ...coverageDetails(session)];
+	if (items.length === 0) return "";
+	return `
+    <details class="pr-helper-review-details">
+      <summary class="pr-helper-review-details-summary">Analysis details</summary>
+      <ul class="pr-helper-review-details-list">
+        ${items.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}
+      </ul>
+    </details>
+  `;
+}
+/**
+* The risk verdict, qualified when the review could not see enough to give one outright.
+*
+* The trap this avoids: "coverage below some percentage means provisional" fires on every large
+* PR, which makes it noise, and it is a threshold rule of exactly the kind invariant 0 rejects.
+* The gate is instead the plan's *own* stated priority — an area the model itself called high
+* priority, which the review then did not cover. The model supplied the judgement; the extension
+* only checked it against what actually happened.
+*
+* Two badges would be one too many, so the qualifier sits inline with the risk label rather than
+* competing with it: the verdict is still the headline, it just no longer claims to be final.
+*/
+function renderProvisionalBadge(session) {
+	if ((session.metadata.unreviewedHighPriority ?? []).length === 0) return "";
+	return `<span class="pr-helper-risk-provisional">Provisional</span>`;
+}
+function renderProvisionalReason(session) {
+	const areas = session.metadata.unreviewedHighPriority ?? [];
+	if (areas.length === 0) return "";
+	const named = areas.map((a) => escapeHtml(a)).join(", ");
+	return `<p class="pr-helper-risk-provisional-reason">The analysis plan called ${areas.length === 1 ? "this area" : "these areas"} high priority but ${areas.length === 1 ? "it was" : "they were"} not analysed in depth: ${named}. Treat the verdict above as provisional until ${areas.length === 1 ? "it has" : "they have"} been looked at.</p>`;
+}
+function renderOverviewTab(session, iconUrl = "") {
+	if (!session) return renderNoReviewState(iconUrl);
+	if (session.status === "generating") return renderGeneratingOverview(session, iconUrl);
+	if (session.status === "failed") return renderFailedOverview(session);
+	const result = composeReview(session);
+	if (!result) return emptyState("No analysis yet.");
+	const nextSteps = result.nextSteps.map((step) => `<li class="pr-helper-markdown">${renderMarkdown(step)}</li>`).join("") || "<li>None</li>";
+	const metrics = deriveReviewMetrics(result);
+	return `
+    <div class="pr-helper-risk-headline">
+      <div class="pr-helper-risk-headline-top">
+        <span class="pr-helper-risk-dot pr-helper-risk-dot-${result.overallRisk}"></span>
+        <span class="pr-helper-risk-headline-label">${escapeHtml(titleCase(result.overallRisk))} Risk</span>
+        ${renderProvisionalBadge(session)}
+      </div>
+      ${renderProvisionalReason(session)}
+      ${result.recommendation ? `<div class="pr-helper-risk-headline-takeaway pr-helper-markdown">${renderMarkdown(result.recommendation)}</div>` : ""}
+    </div>
+    <div class="pr-helper-overview-stats">
+      ${renderOverviewStat(metrics.sections, "Themes", "guide")}
+      ${renderOverviewStat(metrics.issues, "Issues", "issues")}
+      ${renderOverviewStat(metrics.questions, "Questions", "questions")}
+      ${renderCoverageStat(session, metrics.files)}
+    </div>
+    <div class="pr-helper-review-summary pr-helper-markdown">${renderMarkdown(result.summary)}</div>
+    ${renderSuggestedPath(result.sections, "Suggested review path")}
+    ${hasExplainedSimply(session) ? `<p class="pr-helper-explain-simply-done">Explained in simple terms. See the Assistant tab.</p>` : `<button type="button" class="pr-helper-explain-simply-button">Explain in simple terms</button>`}
+    ${renderReviewDetails(session)}
+    <h4>Next steps</h4>
+    <ul>${nextSteps}</ul>
+  `;
+}
+function renderFileLocation(file, className, line) {
+	if (!file) return "";
+	const { dir, name } = splitFilePath(file);
+	const suffix = line ? `:${line}` : "";
+	const dirLine = dir ? `<span class="pr-helper-path-dir">${escapeHtml(dir)}</span>` : "";
+	const lineAttr = line ? ` data-line="${line}"` : "";
+	return `<span class="${className}" data-file="${escapeHtml(file)}"${lineAttr} title="${escapeHtml(file + suffix)}">${dirLine}<span class="pr-helper-path-name">${escapeHtml(name + suffix)}</span></span>`;
+}
+function discussionDetails(session) {
+	const stats = session.metadata.discussionStats;
+	if (!stats) return [];
+	const conversation = stats.conversationComments ?? 0;
+	const decisions = stats.reviewDecisions ?? 0;
+	const reviewThreads = stats.resolvedThreads === void 0 ? Math.max(0, stats.totalThreads - conversation) : stats.unresolvedThreads + stats.resolvedThreads;
+	const parts = [];
+	if (reviewThreads > 0) {
+		const outdated = stats.outdatedThreads ?? 0;
+		const state = stats.unresolvedThreads > 0 ? `${stats.unresolvedThreads} unresolved${outdated > 0 ? `, ${outdated} on outdated lines` : ""}` : "all resolved";
+		parts.push(`${reviewThreads} ${plural(reviewThreads, "review thread")} (${state})`);
+	}
+	if (conversation > 0) parts.push(`${conversation} ${plural(conversation, "conversation comment")}`);
+	if (decisions > 0) parts.push(`${decisions} ${plural(decisions, "review decision")}`);
+	return parts;
+}
+function plural(count, word) {
+	return count === 1 ? word : `${word}s`;
+}
+function renderExistingDiscussion(ref) {
+	if (!ref) return "";
+	const state = ref.status === "resolved" ? "thread since marked resolved" : "thread still unresolved";
+	const label = `<strong class="pr-helper-issue-discussion-lead">${escapeHtml(ref.relation === "related" ? "Related discussion" : "Already raised")}</strong>${escapeHtml(` by @${ref.raisedBy} · ${state}`)}`;
+	const body = ref.url ? `<a class="pr-helper-issue-discussion-link" href="${escapeHtml(ref.url)}" data-discussion-url="${escapeHtml(ref.url)}" rel="noopener noreferrer">${label}</a>` : label;
+	return `<p class="pr-helper-issue-discussion pr-helper-issue-discussion-${escapeHtml(ref.status)}">${body}</p>`;
+}
+function buildSectionLookup(result) {
+	const map = /* @__PURE__ */ new Map();
+	for (const section of result?.sections ?? []) map.set(section.id, section);
+	return map;
+}
+var SECTION_ATTENTION_LABELS = {
+	high: "High Priority",
+	medium: "Medium Priority",
+	low: "Low Priority"
+};
+var WEIGHT_MINUTE_RANGES = {
+	1: [2, 4],
+	2: [4, 7],
+	3: [7, 12],
+	4: [12, 18],
+	5: [18, 25]
+};
+function estimateMinutesForWeight(weight) {
+	return WEIGHT_MINUTE_RANGES[weight];
+}
+function roundedMinutes(sections) {
+	const total = sections.reduce((sum, s) => {
+		const [min, max] = estimateMinutesForWeight(s.reviewWeight);
+		return sum + (min + max) / 2;
+	}, 0);
+	return Math.round(total / 5) * 5;
+}
+function estimateTotalMinutes(sections) {
+	return Math.max(5, roundedMinutes(sections));
+}
+function nextRecommendedSection(sections, completed) {
+	const outstanding = sections.filter((s) => !completed.has(s.id));
+	if (outstanding.length === 0) return null;
+	return outstanding.find((s) => s.recommendedStartingPoint) ?? outstanding[0];
+}
+function deriveSectionStatuses(sections, completed) {
+	const active = nextRecommendedSection(sections, completed);
+	return new Map(sections.map((s) => [s.id, completed.has(s.id) ? "completed" : s.id === active?.id ? "active" : "pending"]));
+}
+function remainingMinutes(sections, completed) {
+	const outstanding = sections.filter((s) => !completed.has(s.id));
+	if (outstanding.length === 0) return 0;
+	return Math.max(1, roundedMinutes(outstanding));
+}
+var GUIDE_PATH_HEADING = "Buddy's suggested review path";
+function renderSuggestedPath(sections, heading) {
+	if (sections.length === 0) return "";
+	const items = sections.map((s) => `<li>${escapeHtml(s.title)}</li>`).join("");
+	return `
+    <div class="pr-helper-suggested-path">
+      <h4 class="pr-helper-suggested-path-title">${escapeHtml(heading)}</h4>
+      <ol class="pr-helper-suggested-path-list">${items}</ol>
+      <p class="pr-helper-suggested-path-time">Estimated review time ≈${estimateTotalMinutes(sections)} minutes</p>
+    </div>
+  `;
+}
+function renderGuideProgressSummary(sections, completed) {
+	const total = sections.length;
+	const done = sections.filter((s) => completed.has(s.id)).length;
+	if (done === 0) return renderSuggestedPath(sections, GUIDE_PATH_HEADING);
+	const counter = `<p class="pr-helper-progress-counter"><span class="pr-helper-progress-check" aria-hidden="true">✓</span>${done} of ${total} theme${total === 1 ? "" : "s"} completed</p>`;
+	const bar = `
+    <div class="pr-helper-progress-bar" role="progressbar" aria-valuenow="${done}" aria-valuemin="0" aria-valuemax="${total}">
+      <div class="pr-helper-progress-bar-fill" style="width: ${Math.round(done / total * 100)}%"></div>
+    </div>
+  `;
+	const next = nextRecommendedSection(sections, completed);
+	if (!next) return `
+      <div class="pr-helper-suggested-path pr-helper-suggested-path-complete">
+        <h4 class="pr-helper-suggested-path-title">Review complete</h4>
+        ${counter}
+        ${bar}
+        <p class="pr-helper-suggested-path-time">Every theme reviewed. Check the Issues tab before you submit.</p>
+      </div>
+    `;
+	return `
+    <div class="pr-helper-suggested-path">
+      <h4 class="pr-helper-suggested-path-title">${escapeHtml(GUIDE_PATH_HEADING)}</h4>
+      ${counter}
+      ${bar}
+      <p class="pr-helper-progress-next"><span class="pr-helper-progress-next-label">Next recommended:</span> ${escapeHtml(next.title)}</p>
+      <p class="pr-helper-suggested-path-time">Estimated remaining ≈${remainingMinutes(sections, completed)} minutes</p>
+    </div>
+  `;
+}
+function renderGuideSectionCard(section, counts, activeGuidedSectionId, status, activeBadgeLabel) {
+	const files = section.files.map((f) => {
+		const focus = f.focus ? `<div class="pr-helper-guide-file-focus">${renderInlineText(f.focus)}</div>` : "";
+		const { dir, name } = splitFilePath(f.path);
+		const dirLine = dir ? `<span class="pr-helper-path-dir">${escapeHtml(dir)}</span>` : "";
+		return `<li class="pr-helper-guide-file" data-file="${escapeHtml(f.path)}" data-guide-section="${escapeHtml(section.id)}" title="${escapeHtml(f.path)}">${dirLine}<span class="pr-helper-path-name">${escapeHtml(name)}</span>${focus}</li>`;
+	}).join("") || "<li class=\"pr-helper-review-empty\">No files listed.</li>";
+	const checklist = section.checklist.map((item) => `<li>${renderInlineText(item)}</li>`).join("") || "<li>None</li>";
+	const [minMinutes, maxMinutes] = estimateMinutesForWeight(section.reviewWeight);
+	const statParts = [`${section.files.length} file${section.files.length === 1 ? "" : "s"}`];
+	if (counts.issues > 0) statParts.push(`${counts.issues} issue${counts.issues === 1 ? "" : "s"}`);
+	if (counts.questions > 0) statParts.push(`${counts.questions} question${counts.questions === 1 ? "" : "s"}`);
+	statParts.push(`~${minMinutes}-${maxMinutes} min`);
+	const isActive = activeGuidedSectionId === section.id;
+	const isCompleted = status === "completed";
+	const check = isCompleted ? `<span class="pr-helper-guide-check" aria-hidden="true">✓</span>` : "";
+	const statusBadge = isCompleted ? `<span class="pr-helper-guide-badge pr-helper-completed-badge">Completed</span>` : status === "active" ? `<span class="pr-helper-guide-badge pr-helper-start-here-badge">${escapeHtml(activeBadgeLabel)}</span>` : "";
+	const undo = isCompleted ? `<button type="button" class="pr-helper-guide-uncomplete" data-guide-uncomplete="${escapeHtml(section.id)}">Mark as not reviewed</button>` : "";
+	return `
+    <section class="pr-helper-guide-section${isCompleted ? " pr-helper-guide-section-completed" : ""}" id="pr-helper-guide-section-${escapeHtml(section.id)}" data-guide-section-card="${escapeHtml(section.id)}">
+      <button type="button" class="pr-helper-guide-section-header" data-guide-toggle="${escapeHtml(section.id)}">
+        <div class="pr-helper-guide-section-badges">
+          ${check}
+          ${statusBadge}
+          <span class="pr-helper-guide-badge pr-helper-attention-badge pr-helper-attention-${section.reviewAttention}">${escapeHtml(SECTION_ATTENTION_LABELS[section.reviewAttention])}</span>
+        </div>
+        <div class="pr-helper-guide-section-header-top">
+          <span class="pr-helper-guide-disclosure">▼</span>
+          <span class="pr-helper-guide-section-title">${escapeHtml(section.title)}</span>
+        </div>
+        <div class="pr-helper-guide-meta-row" title="Review weight ${section.reviewWeight}/5">${escapeHtml(statParts.join(" · "))}</div>
+      </button>
+      <div class="pr-helper-guide-section-body">
+        <p class="pr-helper-guide-summary">${renderInlineText(section.oneLineSummary)}</p>
+        ${section.purpose ? `<p class="pr-helper-guide-purpose">${renderInlineText(section.purpose)}</p>` : ""}
+        <h5>Files</h5>
+        <ul class="pr-helper-guide-files">${files}</ul>
+        ${section.whyReview ? `<h5>Why review this</h5><p class="pr-helper-guide-why">${renderInlineText(section.whyReview)}</p>` : ""}
+        <h5>Review checklist</h5>
+        <ul class="pr-helper-guide-checklist">${checklist}</ul>
+        <div class="pr-helper-guide-section-actions">
+          <button type="button" class="pr-helper-guide-start-cta" data-guide-start="${escapeHtml(section.id)}">
+            ${isActive ? "Resume guided review →" : isCompleted ? "Review again →" : "Start guided review →"}
+          </button>
+          ${undo}
+        </div>
+      </div>
+    </section>
+  `;
+}
+/**
+* Areas the plan named but did not read — the Guide's second half, and deliberately not mixed
+* into its first.
+*
+* The invariant this renders: **Guide themes are based on reviewed code; suggested themes
+* are identified from the manifest only.** A section can tell the reviewer what a change does
+* because the model read it. These cannot — nobody read them — so they carry a heading that says
+* so, no findings, and no implication that they have been assessed.
+*
+* They exist because the alternative is worse. A capped review used to end with 432 files simply
+* absent; naming what was left and why is what turns the end of the review into the start of the
+* reviewer's own work.
+*/
+/**
+* The action that turns a suggested area into an analysed one.
+*
+* Phrased as work the product does — "Analyse Infrastructure changes" — never as a place the
+* analysis stopped. The label names the area rather than a count, because "analyse 18 files" is a
+* chore and "analyse the deployment configuration" is a decision the reviewer can actually make.
+*
+* Offered only when `paths` is present. Sessions stored before that field carry a file count but
+* nothing to scope a follow-up with, and an action that cannot run is worse than no action.
+*/
+function renderAreaAction(area, busyLabel) {
+	if (!area.paths?.length) return "";
+	if (busyLabel === area.title) return `
+      <div class="pr-helper-suggested-area-running">
+        <span class="pr-helper-suggested-area-busy">Analysing…</span>
+        <button class="pr-helper-suggested-area-cancel" data-follow-up-cancel>Cancel</button>
+      </div>
+    `;
+	const disabled = busyLabel !== null;
+	return `
+    <button class="pr-helper-suggested-area-action" data-follow-up-area="${escapeHtml(area.title)}"${disabled ? " disabled" : ""}>
+      ${area.partiallyAnalysed ? "Analyse the rest of" : "Analyse"} ${escapeHtml(area.title)}
+    </button>
+  `;
+}
+function renderSuggestedAreas(session, busyLabel) {
+	const areas = composeReview(session)?.suggestedAreas ?? [];
+	const notNamed = session.metadata.fileCoverage?.notNamedCount ?? 0;
+	if (areas.length === 0 && notNamed === 0) return "";
+	const card = (area) => `
+    <div class="pr-helper-suggested-area">
+      <div class="pr-helper-suggested-area-head">
+        <span class="pr-helper-suggested-area-title">${escapeHtml(area.title)}</span>
+        <span class="pr-helper-suggested-area-count">${area.fileCount} file${area.fileCount === 1 ? "" : "s"}</span>
+      </div>
+      ${area.why ? `<p class="pr-helper-suggested-area-why">${escapeHtml(area.why)}</p>` : ""}
+      ${area.riskNote ? `<p class="pr-helper-suggested-area-risk">Watch for: ${escapeHtml(area.riskNote)}</p>` : ""}
+      ${renderAreaAction(area, busyLabel)}
+    </div>
+  `;
+	const unfinished = areas.filter((area) => area.partiallyAnalysed);
+	const suggested = areas.filter((area) => !area.partiallyAnalysed);
+	const remainder = notNamed > 0 ? `<p class="pr-helper-suggested-area-remainder">${notNamed} further changed file${notNamed === 1 ? " was" : "s were"} not placed in any theme. See the Files tab for the full list.</p>` : "";
+	return `${unfinished.length === 0 ? "" : `
+    <div class="pr-helper-suggested-areas">
+      <h4 class="pr-helper-suggested-areas-heading">Unfinished themes</h4>
+      <p class="pr-helper-suggested-areas-intro">The analysis plan chose ${unfinished.length === 1 ? "this theme" : "these themes"} for in-depth analysis and the file ceiling stopped it partway. What is listed below is the remainder; the part that was read has ${unfinished.length === 1 ? "a theme" : "themes"} above.</p>
+      ${unfinished.map(card).join("")}
+    </div>
+  `}${suggested.length === 0 && notNamed === 0 ? "" : `
+    <div class="pr-helper-suggested-areas">
+      <h4 class="pr-helper-suggested-areas-heading">Suggested themes</h4>
+      <p class="pr-helper-suggested-areas-intro">Identified from the changed-file list, not analysed. Nothing below has been read, so none of it has been assessed.</p>
+      ${suggested.map(card).join("")}
+      ${remainder}
+    </div>
+  `}`;
+}
+function renderGuideTab(session, activeGuidedSectionId = null, followUpInFlight = null) {
+	if (!session) return emptyState("Generate an analysis to see the Guide.");
+	if (session.status === "generating") return emptyState("Analysis in progress…");
+	if (session.status === "failed") return emptyState("No analysis available.");
+	const result = composeReview(session);
+	const sections = result?.sections ?? [];
+	if (sections.length === 0) return emptyState("Guide not available for this analysis.");
+	const completed = new Set(session.completedSectionIds ?? []);
+	const statuses = deriveSectionStatuses(sections, completed);
+	const activeBadgeLabel = [...statuses.values()].includes("completed") ? "Continue" : "Start here";
+	const cards = sections.map((s) => {
+		return renderGuideSectionCard(s, {
+			issues: result?.issues.filter((i) => i.sectionId === s.id).length ?? 0,
+			questions: result?.questions.filter((q) => q.sectionId === s.id).length ?? 0
+		}, activeGuidedSectionId, statuses.get(s.id) ?? "pending", activeBadgeLabel);
+	}).join("");
+	return `
+    <div class="pr-helper-guide">
+      ${renderGuideProgressSummary(sections, completed)}
+      <div class="pr-helper-guide-sections">${cards}</div>
+      ${renderSuggestedAreas(session, followUpInFlight)}
+    </div>
+  `;
+}
+function renderSectionTag(sectionId, sections) {
+	if (!sectionId) return "";
+	const section = sections.get(sectionId);
+	if (!section) return "";
+	return `<button type="button"${pillAttrs("pr-helper-section-tag", SECTION_TAG_TIP)} data-guide-jump="${escapeHtml(section.id)}">${escapeHtml(section.title)}</button>`;
+}
+/**
+* How sure the model is that an issue is real — deliberately not shown when it is sure.
+*
+* Severity already earns a badge on every card, and a second always-present badge would turn the
+* header into a row of labels the eye stops reading. Confidence only carries information when it
+* is *not* high, so that is the only case that gets ink: "medium confidence" and "low confidence"
+* are qualifications, and a qualification nobody notices is the same as not making it.
+*
+* Absent means the model did not state one, which renders as nothing rather than a guessed middle.
+*/
+function renderIssueConfidence(confidence) {
+	if (!confidence || confidence === "high") return "";
+	return `<span${pillAttrs(`pr-helper-issue-confidence pr-helper-issue-confidence-${confidence}`, confidenceTip(confidence))}>${escapeHtml(confidence)} confidence</span>`;
+}
+/**
+* What became of a finding when the pull request moved on. Absent on an ordinary analysis, which
+* has no prior state to report — those cards render exactly as they always have.
+*
+* Placed first among the badges, before the section tag and severity: on a reconciled analysis this
+* is the axis the reviewer is scanning for. They already know what the findings were; what they
+* came back to learn is which ones the author dealt with.
+*/
+function renderFindingStatus(status) {
+	if (!status) return "";
+	return `<span${pillAttrs(`pr-helper-finding-status pr-helper-finding-status-${status}`, findingStatusTip(status))}>${escapeHtml(findingStatusLabel(status))}</span>`;
+}
+/**
+* The same pill, for a question.
+*
+* A separate function rather than a widened one, because the two draw from different vocabularies:
+* a finding is `resolved` and a question is `answered`, which are different events. Nothing fixed
+* the question; somebody now knows the answer.
+*/
+function renderQuestionStatus(status) {
+	if (!status) return "";
+	return `<span${pillAttrs(`pr-helper-finding-status pr-helper-finding-status-${status === "answered" ? "resolved" : status}`, questionStatusTip(status))}>${escapeHtml(questionStatusLabel(status))}</span>`;
+}
+/** The model's one-line reason for a status, when it gave one. */
+function renderReconciliationNote(note) {
+	if (!note?.trim()) return "";
+	return `<p class="pr-helper-reconciliation-note">${renderInlineText(note)}</p>`;
+}
+/**
+* Escalation to a repository-aware coding agent, on the findings that might actually need one.
+*
+* Only issues and questions carry it. Those are the two things a reviewer can be *uncertain*
+* about, and uncertainty is the only state a repository investigation resolves — the Overview,
+* the Guide and the Files tab describe what the change is, which the diff already settled.
+*
+* Visible rather than tucked into a menu: if the escalation is worth building it is worth
+* seeing, and a reviewer who has to discover it will not reach for it at the moment they are
+* stuck. Outlined rather than filled — see sidebar.css.
+*
+* Text only, no leading icon. Every other action in the sidebar (Jump to file, Mark answered,
+* Explain, Analyse, Copy) is a bare label, and an emoji here read as decoration on a control
+* whose neighbours have none rather than as emphasis.
+*/
+function renderInvestigateButton(attribute, id, label) {
+	return `<button type="button" class="pr-helper-investigate-btn" ${attribute}="${escapeHtml(id)}" title="Generate a prompt to investigate this with your repository-aware AI">${escapeHtml(label)}</button>`;
+}
+/**
+* The two halves of the investigation loop, side by side on the finding they concern.
+*
+* Outbound ("Investigate Repository") generates the prompt; inbound ("Add Investigation") brings
+* the agent's answer back. Pairing them here rather than putting the inbound action somewhere
+* general is the whole mental model: the finding is the entry point, the reviewer goes away, and
+* they return to the same place. A generic "add context" control elsewhere in the sidebar would
+* make the round trip something the reviewer has to assemble for themselves.
+*
+* State comes from the **newest** record for this finding, because records accumulate — a reviewer
+* who has just pressed "Investigate Again" is mid-investigation whatever earlier rounds concluded.
+* "Add Investigation" names what the reviewer is doing; "Paste Results" would name the mechanism,
+* which the modal explains once they are in it.
+*/
+function renderInvestigationActions(kind, id, records, investigatingId) {
+	const attribute = kind === "issue" ? "data-investigate-issue" : "data-investigate-question";
+	const addAttribute = kind === "issue" ? "data-add-investigation-issue" : "data-add-investigation-question";
+	const newest = newestInvestigationForFinding(records, kind, id);
+	if (investigatingId && newest?.id === investigatingId) return `${renderInvestigateButton(attribute, id, "Investigate Again")}<span class="pr-helper-investigate-applying" role="status">Applying…</span>`;
+	if (!newest) return renderInvestigateButton(attribute, id, "Investigate Repository");
+	const inbound = newest.state === "applied" ? "<span class=\"pr-helper-investigate-added\" aria-label=\"Investigation added\">Investigation Added ✓</span>" : `<button type="button" class="pr-helper-investigate-btn pr-helper-investigate-btn-add" ${addAttribute}="${escapeHtml(id)}" title="Paste the result from your repository-aware AI">Add Investigation</button>`;
+	return `${renderInvestigateButton(attribute, id, "Investigate Again")}${inbound}`;
+}
+/**
+* One line per applied investigation, oldest first.
+*
+* All of them, not just the most recent: a finding investigated twice was shaped by two pieces of
+* evidence, and showing only the latest would quietly retire the first from the record while its
+* effect on the analysis remains.
+*/
+function renderInvestigationProvenance(kind, id, records, now) {
+	const applied = investigationsForFinding(records, kind, id).filter((r) => r.state === "applied");
+	if (!applied.length) return "";
+	return applied.map((record) => `
+    <p class="pr-helper-investigation-provenance">
+      <span class="pr-helper-investigation-provenance-label">Repository investigation</span>
+      <span class="pr-helper-investigation-provenance-agent">${escapeHtml(record.agent ?? "Unknown agent")}</span>
+      <span class="pr-helper-investigation-provenance-time">${escapeHtml(formatRelativeTime(record.appliedAt ?? record.requestedAt, now))}</span>
+      <button type="button" class="pr-helper-investigation-view" data-view-investigation="${escapeHtml(record.id)}">View investigation</button>
+    </p>
+  `).join("");
+}
+/**
+* What a repository investigation concluded about this finding.
+*
+* Sits beside renderFindingStatus rather than replacing it: the two axes answer different questions
+* and a finding may carry both, so `[Still open] [Revised]` is a coherent and useful pair rather
+* than a contradiction to be resolved in the renderer.
+*/
+function renderInvestigationImpact(impact) {
+	if (!impact) return "";
+	return `<span${pillAttrs(`pr-helper-investigation-impact pr-helper-investigation-impact-${impact}`, investigationImpactTip(impact))}>${escapeHtml(investigationImpactLabel(impact))}</span>`;
+}
+/**
+* `major → minor`, when an investigation moved a grade.
+*
+* Rendered only on an actual change, because priorSeverity/priorConfidence are only set on one (see
+* applyReassessment). Showing where a value came from matters more here than anywhere else in the
+* product: a reviewer who saw "major" yesterday and "minor" today, with no arrow, has been given a
+* different answer with no indication that anything moved it.
+*/
+function renderSeverityRevision(prior, current) {
+	if (!prior || prior === current) return "";
+	return `<p class="pr-helper-investigation-revision"><span class="pr-helper-investigation-revision-from">${escapeHtml(prior)}</span> → <span class="pr-helper-investigation-revision-to">${escapeHtml(current)}</span></p>`;
+}
+/** The model's one-line reason for an impact, when it gave one. */
+function renderInvestigationNote(note) {
+	if (!note?.trim()) return "";
+	return `<p class="pr-helper-investigation-note">${renderInlineText(note)}</p>`;
+}
+function renderIssuesTab(session, investigatingId) {
+	if (!session) return emptyState("Generate an analysis to see issues.");
+	if (session.status === "generating") return emptyState("Analysis in progress…");
+	if (session.status === "failed") return emptyState("No analysis available.");
+	const result = composeReview(session);
+	if (!result || result.issues.length === 0) return emptyState("No issues found.");
+	const sections = buildSectionLookup(result);
+	const records = session.investigations;
+	const now = Date.now();
+	return result.issues.map((issue) => `
+    <div class="pr-helper-issue-card pr-helper-severity-${issue.severity}${issue.reconciliationStatus ? ` pr-helper-issue-${issue.reconciliationStatus}` : ""}${issue.investigationImpact ? ` pr-helper-issue-investigation-${issue.investigationImpact}` : ""}" data-finding-card="${escapeHtml(issue.id)}">
+      <div class="pr-helper-issue-header">
+        <p class="pr-helper-issue-title">${renderInlineText(issue.title)}</p>
+        <div class="pr-helper-issue-badges">
+          ${renderFindingStatus(issue.reconciliationStatus)}
+          ${renderInvestigationImpact(issue.investigationImpact)}
+          ${renderSectionTag(issue.sectionId, sections)}
+          ${renderIssueConfidence(issue.confidence)}
+          <span${pillAttrs("pr-helper-severity-badge", severityTip(issue.severity))}>${escapeHtml(issue.severity)}</span>
+        </div>
+      </div>
+      ${renderSeverityRevision(issue.priorSeverity, issue.severity)}
+      <p class="pr-helper-issue-desc">${renderInlineText(issue.description)}</p>
+      ${renderReconciliationNote(issue.reconciliationNote)}
+      ${renderInvestigationNote(issue.investigationNote)}
+      ${renderExistingDiscussion(issue.existingDiscussion)}
+      ${renderFileLocation(issue.file, "pr-helper-issue-loc", issue.line)}
+      ${renderInvestigationProvenance("issue", issue.id, records, now)}
+      <div class="pr-helper-issue-actions">
+        ${renderInvestigationActions("issue", issue.id, records, investigatingId)}
+      </div>
+    </div>
+  `).join("");
+}
+function renderQuestionCard(q, sections, showTag, answered, records, now = Date.now(), investigatingId, options) {
+	const importanceBadge = q.importance ? `<span${pillAttrs(`pr-helper-question-importance-badge pr-helper-question-importance-${q.importance}`, importanceTip(q.importance))}>${escapeHtml(q.importance)}</span>` : "";
+	const jumpLink = renderQuestionJump(q.file, options);
+	const answerToggle = `<button type="button" class="pr-helper-question-answer-toggle" data-question-answered="${escapeHtml(q.id)}" data-answered="${answered}">${answered ? "Mark as unanswered" : "Mark answered"}</button>`;
+	const investigationAnswer = q.investigationAnswer?.trim() ? `<h5>Answer from investigation</h5><p class="pr-helper-issue-desc pr-helper-investigation-answer">${renderInlineText(q.investigationAnswer)}</p>` : "";
+	const reconciliationAnswer = q.reconciliationAnswer?.trim() ? `<h5>Answered by the new changes</h5><p class="pr-helper-issue-desc pr-helper-investigation-answer">${renderInlineText(q.reconciliationAnswer)}</p>` : "";
+	return `
+    <div class="pr-helper-question-card${answered ? " pr-helper-question-card-answered" : ""}${q.investigationImpact ? ` pr-helper-issue-investigation-${q.investigationImpact}` : ""}" data-finding-card="${escapeHtml(q.id)}">
+      <div class="pr-helper-issue-header">
+        <p class="pr-helper-issue-title">${renderInlineText(q.question)}</p>
+        <div class="pr-helper-issue-badges">
+          ${renderQuestionStatus(q.reconciliationStatus)}
+          ${renderInvestigationImpact(q.investigationImpact)}
+          ${showTag ? renderSectionTag(q.sectionId, sections) : ""}
+          ${importanceBadge}
+        </div>
+      </div>
+      ${q.whyThisMatters ? `<h5>Why this matters</h5><p class="pr-helper-issue-desc">${renderInlineText(q.whyThisMatters)}</p>` : ""}
+      ${reconciliationAnswer}
+      ${renderReconciliationNote(q.reconciliationNote)}
+      ${investigationAnswer}
+      ${renderInvestigationNote(q.investigationNote)}
+      ${q.file ? `<h5>Files</h5>${renderFileLocation(q.file, "pr-helper-issue-loc", void 0)}` : ""}
+      ${renderInvestigationProvenance("question", q.id, records, now)}
+      <div class="pr-helper-question-actions">
+        ${jumpLink}
+        <div class="pr-helper-question-actions-group">
+          ${renderInvestigationActions("question", q.id, records, investigatingId)}
+          ${answerToggle}
+        </div>
+      </div>
+    </div>
+  `;
+}
+/**
+* The counter's contents, split out so a caller that toggles one question can refresh it without
+* re-rendering the tab.
+*
+* The extension redraws the whole Questions tab on every toggle and never needed this. The
+* plugin's workspace updates the card in place, so its counter sat frozen at "2 of 2 unanswered"
+* while a card visibly turned green above it. Exported rather than reimplemented there, because
+* two places wording the same count differently is how "All 5 questions answered" and "0 of 5
+* unanswered" end up on the same product.
+*/
+function questionsProgressBody(total, outstanding) {
+	return outstanding === 0 ? `<span class="pr-helper-questions-progress-check" aria-hidden="true">✓</span><span class="pr-helper-questions-progress-count">All ${total} questions answered</span>` : `<span class="pr-helper-questions-progress-count">${outstanding} of ${total} unanswered</span>`;
+}
+function renderQuestionsProgress(questions, answered) {
+	const total = questions.length;
+	if (total < 2) return "";
+	const outstanding = questions.filter((q) => !answered.has(q.id)).length;
+	return `<div class="pr-helper-questions-progress" role="status">${questionsProgressBody(total, outstanding)}</div>`;
+}
+function renderQuestionJump(file, options) {
+	if (!file || options?.suppressFileJump) return "";
+	return `<button type="button" class="pr-helper-question-jump" data-file="${escapeHtml(file)}">Jump to file →</button>`;
+}
+function renderQuestionsTab(session, investigatingId, options) {
+	if (!session) return emptyState("Generate an analysis to see open questions.");
+	if (session.status === "generating") return emptyState("Analysis in progress…");
+	if (session.status === "failed") return emptyState("No analysis available.");
+	const result = composeReview(session);
+	if (!result || result.questions.length === 0) return emptyState("No open questions.");
+	const sections = buildSectionLookup(result);
+	const answered = new Set(session.answeredQuestionIds ?? []);
+	const progress = renderQuestionsProgress(result.questions, answered);
+	const records = session.investigations;
+	const now = Date.now();
+	if (result.sections.length === 0) return `${progress}${result.questions.map((q) => renderQuestionCard(q, sections, true, answered.has(q.id), records, now, investigatingId, options)).join("")}`;
+	const grouped = /* @__PURE__ */ new Map();
+	const ungrouped = [];
+	for (const q of result.questions) if (q.sectionId && sections.has(q.sectionId)) {
+		const list = grouped.get(q.sectionId) ?? [];
+		list.push(q);
+		grouped.set(q.sectionId, list);
+	} else ungrouped.push(q);
+	return `${progress}${result.sections.filter((s) => grouped.has(s.id)).map((s) => `
+      <div class="pr-helper-question-group">
+        <h5 class="pr-helper-question-group-title">${escapeHtml(s.title)}</h5>
+        ${grouped.get(s.id).map((q) => renderQuestionCard(q, sections, false, answered.has(q.id), records, now, investigatingId, options)).join("")}
+      </div>
+    `).join("")}${ungrouped.map((q) => renderQuestionCard(q, sections, false, answered.has(q.id), records, now, investigatingId, options)).join("")}`;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/file_links.ts
+/**
+* Where a file lives on the pull request, when there is one.
+*
+* There used to be a "Jump to file" button beside a question that did exactly what clicking the
+* file name does, which is open the file in this workspace. Two controls, one behaviour, and the
+* second one quietly teaching the reviewer that the first was worth ignoring. The useful second
+* destination is the pull request itself, where the file sits next to its comments and its review
+* controls.
+*
+* Shared because three surfaces need the same answer: the rendered page, the file viewer's route,
+* and the Files tab. A second copy of this decision is how one of them ends up linking somewhere
+* else.
+*/
+function buildPrFileLink(attached, path) {
+	if (!attached) return null;
+	const { pullRequest } = attached;
+	if (pullRequest.fileUrlTemplate) return {
+		href: fillFileUrlTemplate(pullRequest.fileUrlTemplate, path),
+		label: "Open in pull request",
+		precise: true
+	};
+	return {
+		href: pullRequest.filesUrl || pullRequest.url,
+		label: "Open the pull request",
+		precise: false
+	};
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/pr_context_view.ts
+/**
+* Everything that was imported from the pull request, shown as it was imported.
+*
+* This view is not a convenience. Every "already raised" line in a review rests on a conversation
+* the daemon never fetched and cannot verify — Claude Code produced the payload, using the
+* developer's own tooling, and the daemon has no way to check it against the real pull request.
+* What makes that claim honest rather than merely asserted is that the reviewer can read the
+* threads themselves and follow each one back to the comment it came from. A finding attributed
+* to a conversation that never happened is one click from being caught here.
+*
+* So: complete, in the order the processor bucketed it, with every permalink intact. Nothing is
+* summarised and nothing is hidden behind a "show more" — the budget trimming that happens
+* upstream is about what fits in a prompt, and has nothing to do with what a reviewer may read.
+*/
+/**
+* The four buckets, in the order a reviewer needs them.
+*
+* Unresolved first because it is the live disagreement; outdated-unresolved next because the
+* anchor moved but the concern did not; conversation then resolved. This is the processor's own
+* priority order, not a second opinion about it.
+*/
+var BUCKETS = [
+	{
+		key: "unresolved",
+		title: "Unresolved",
+		note: "Open threads on the current code."
+	},
+	{
+		key: "unresolvedOutdated",
+		title: "Unresolved, code has moved",
+		note: "Still open, but written against a revision that has since changed."
+	},
+	{
+		key: "conversation",
+		title: "Conversation",
+		note: "The main discussion, not anchored to a line."
+	},
+	{
+		key: "resolved",
+		title: "Resolved",
+		note: "Marked resolved. Not proof the underlying problem is fixed."
+	}
+];
+function renderPrContextView(view, attribution, refresh) {
+	if (!view) return renderNothingConnected();
+	const { pullRequest, discussion } = view.prContext;
+	const { processed } = view;
+	const buckets = BUCKETS.map((bucket) => renderBucket(bucket.title, bucket.note, processed[bucket.key])).join("");
+	return `<h3 class="prb-doc-title">PR context</h3>
+${renderProvenance(pullRequest, discussion.fetchedAt, processed)}
+${renderRefresh(refresh)}
+${renderAttribution(attribution, processed)}
+${discussion.truncated ? renderTruncation() : ""}
+${renderDecisions(processed)}
+${processed.all.length === 0 ? "<p class=\"prb-pr-empty\">This pull request has no comments yet.</p>" : buckets}`;
+}
+/**
+* Re-reading the threads, and what the last re-read found.
+*
+* The narrowest useful action in the product, and the copy has to keep it narrow. This corrects
+* what the review already claims about other people's threads — who raised one, whether it is
+* still open — and it cannot produce a finding, because deciding whether a new comment changes
+* anything is judgement and judgement is a fresh review. A reviewer who pressed this expecting a
+* re-review would be worse off than one who never saw the button.
+*/
+function renderRefresh(refresh) {
+	if (!refresh?.enabled) return "";
+	const last = refresh.last;
+	return `<div class="prb-pr-refresh">
+  <button type="button" data-pr-recheck>Re-check the conversation</button>
+  <span class="prb-pr-refresh-note">
+    Fetches every thread again and updates what this review says about them. If someone has
+    replied or resolved a thread since the review ran, the "Already raised" notes on the Issues
+    view will be corrected to match, and any note pointing at a thread that has been deleted will
+    be removed. Your code is not looked at again, so no findings are added, changed or removed.
+  </span>
+  ${last ? `<p class="prb-pr-refresh-last" data-ok="${last.ok}">
+           Last re-checked ${escapeHtml(relativeTime$1(last.at))}. ${escapeHtml(last.message)}
+           ${last.attributionsRestated ? escapeHtml(` ${last.attributionsRestated} finding${last.attributionsRestated === 1 ? "" : "s"} had its thread's state corrected.`.replace("its", last.attributionsRestated === 1 ? "its" : "their")) : ""}
+           ${last.attributionsWithdrawn ? escapeHtml(` ${last.attributionsWithdrawn} claim${last.attributionsWithdrawn === 1 ? "" : "s"} withdrawn: the thread it cited is no longer in the conversation.`) : ""}
+         </p>` : ""}
+</div>`;
+}
+/**
+* How much of this review the conversation actually touched.
+*
+* Without this the page has a hole exactly where the feature's own promise sits. A reviewer who
+* reads the threads here and then sees no "already raised" line anywhere cannot tell whether the
+* review compared its findings against this conversation and matched none, or never compared them
+* at all — and those call for completely different responses. Zero matches is an ordinary,
+* frequent outcome; it is silence about zero matches that is the problem.
+*
+* Counted from the findings themselves, so it can never disagree with what the Issues view shows.
+*/
+function renderAttribution(attribution, processed) {
+	if (!attribution || processed.all.length === 0) return "";
+	const { findings, matched } = attribution;
+	if (findings === 0) return "";
+	return `<p class="prb-pr-attribution" data-matched="${matched}">${escapeHtml(matched === 0 ? `None of the ${findings} finding${findings === 1 ? "" : "s"} in this review matched a thread here. The comparison was made; nothing lined up.` : `${matched} of ${findings} finding${findings === 1 ? "" : "s"} in this review ${matched === 1 ? "is" : "are"} matched to a thread here. Each one says so on the Issues view.`)}</p>`;
+}
+/**
+* Said plainly, because the alternative is a reviewer assuming their findings were checked
+* against a conversation that was never read. "No comments" and "never looked" are different
+* facts and this is the page that has to tell them apart.
+*/
+function renderNothingConnected() {
+	return `<h3 class="prb-doc-title">PR context</h3>
+<p class="prb-pr-empty">
+  No pull request discussion was brought into this review, so none of the findings have been
+  checked against what other reviewers have already said.
+</p>
+<p class="prb-pr-empty">
+  That usually means the branch does not have a pull request open yet, or that the tools on this
+  machine could not sign in to fetch one. It does not mean the pull request is free of comments.
+  Nobody looked.
+</p>`;
+}
+function renderProvenance(pullRequest, fetchedAt, processed) {
+	const { stats } = processed;
+	const parts = [
+		`${stats.totalThreads} thread${stats.totalThreads === 1 ? "" : "s"}`,
+		`${stats.totalComments} comment${stats.totalComments === 1 ? "" : "s"}`,
+		`${stats.unresolvedCount} unresolved`
+	];
+	return `<p class="prb-pr-provenance">
+  <a href="${escapeHtml(pullRequest.url)}" target="_blank" rel="noopener noreferrer">${escapeHtml(pullRequest.provider)} #${pullRequest.number}</a>
+  ${pullRequest.title ? `<span class="prb-pr-title">${escapeHtml(pullRequest.title)}</span>` : ""}
+  <span class="prb-pr-counts">${parts.join(" &middot; ")}</span>
+  <time datetime="${new Date(fetchedAt).toISOString()}">imported ${escapeHtml(relativeTime$1(fetchedAt))}</time>
+  <span class="prb-pr-asof">This is a snapshot taken at that moment, not a live view. Anything that has happened on the pull request since then, including replies and threads being resolved, will not show up here until you re-check it.</span>
+</p>`;
+}
+/** Disclosed rather than absorbed: a review working from a partial record should say which part. */
+function renderTruncation() {
+	return `<p class="prb-pr-truncated">
+  This discussion arrived incomplete. Whatever fetched it reported that it could not retrieve
+  everything, so some threads are missing from the list below. The review did not see those
+  threads either, so treat its coverage of the discussion as partial.
+</p>`;
+}
+/**
+* The verdicts people left, drawn the same way their threads are.
+*
+* These used to be a bare list while every thread beside them was a card, so the one section
+* carrying a reviewer's overall position on the change looked like a footnote next to the
+* line-level nitpicks. Same card, same author line, same body treatment. A verdict is at least as
+* important as a comment on line 317.
+*/
+function renderDecisions(processed) {
+	if (processed.decisions.length === 0) return "";
+	const cards = processed.decisions.map((decision) => `<article class="prb-pr-thread prb-pr-decision">
+      <header>
+        <span class="prb-pr-author">@${escapeHtml(decision.reviewer)}${decision.reviewerIsBot ? " (bot)" : ""}</span>
+        <span class="prb-pr-verdict" data-verdict="${escapeHtml(decision.verdict)}">${escapeHtml(verdictLabel(decision.verdict))}</span>
+        ${decision.timestamp ? `<time datetime="${escapeHtml(decision.timestamp)}">${escapeHtml(relativeTime$1(Date.parse(decision.timestamp)))}</time>` : ""}
+      </header>
+      ${decision.body ? renderBody(decision.body) : "<p class=\"prb-pr-nobody\">No comment left with this review.</p>"}
+    </article>`).join("");
+	return `<section class="prb-pr-bucket">
+  <h4>Reviews <span class="prb-pr-bucket-count">${processed.decisions.length}</span></h4>
+  <p class="prb-pr-bucket-note">Where each reviewer landed on the change as a whole.</p>
+  ${cards}
+</section>`;
+}
+/**
+* Someone else's words, rendered as they wrote them.
+*
+* People write review comments in Markdown, so a comment that quotes a stack trace or a snippet
+* was arriving as one unbroken wall of text with stray backticks in it. That is the comment at its
+* least readable, in the one place the reviewer most needs to read it carefully.
+*
+* `renderMarkdown` escapes before it parses, so nothing in a comment can become markup this page
+* did not emit, and its href allow-list means a link is only ever a link. It was written for model
+* output injected into github.com, which is a harsher setting than this one.
+*/
+function renderBody(body) {
+	return `<div class="prb-pr-comment-body prb-pr-md">${renderMarkdown(body)}</div>`;
+}
+function renderBucket(title, note, threads) {
+	if (threads.length === 0) return "";
+	return `<section class="prb-pr-bucket">
+  <h4>${escapeHtml(title)} <span class="prb-pr-bucket-count">${threads.length}</span></h4>
+  <p class="prb-pr-bucket-note">${escapeHtml(note)}</p>
+  ${threads.map(renderThread).join("")}
+</section>`;
+}
+function renderThread(thread) {
+	const location = thread.location ? `<span class="prb-pr-loc">${escapeHtml(thread.location.file)}${thread.location.line !== null ? `:${thread.location.line}${thread.location.lineIsOriginal ? " (original)" : ""}` : ""}</span>` : "";
+	return `<article class="prb-pr-thread" data-thread-id="${escapeHtml(thread.id)}">
+  <header>
+    ${location}
+    ${thread.outdated ? "<span class=\"prb-pr-flag\">outdated</span>" : ""}
+    ${thread.resolved ? "<span class=\"prb-pr-flag\">resolved</span>" : ""}
+  </header>
+  ${thread.comments.map(renderComment).join("")}
+  ${thread.truncatedCommentCount > 0 ? `<p class="prb-pr-truncated">${thread.truncatedCommentCount} further comment${thread.truncatedCommentCount === 1 ? "" : "s"} in this thread were not imported.</p>` : ""}
+</article>`;
+}
+function renderComment(comment) {
+	const who = `@${comment.author}${comment.authorIsBot ? " (bot)" : ""}`;
+	return `<div class="prb-pr-comment">
+  <p class="prb-pr-comment-meta">
+    ${comment.url ? `<a href="${escapeHtml(comment.url)}" target="_blank" rel="noopener noreferrer">${escapeHtml(who)}</a>` : escapeHtml(who)}
+    ${comment.timestamp ? `<time datetime="${escapeHtml(comment.timestamp)}">${escapeHtml(relativeTime$1(Date.parse(comment.timestamp)))}</time>` : ""}
+  </p>
+  ${renderBody(comment.body)}
+</div>`;
+}
+var VERDICT_LABELS = {
+	approved: "approved",
+	changes_requested: "requested changes",
+	commented: "commented",
+	dismissed: "dismissed"
+};
+function verdictLabel(verdict) {
+	return VERDICT_LABELS[verdict] ?? verdict;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/update_view.ts
+/**
+* The Update review control, and what it says afterwards.
+*
+* Two pieces of copy that have to carry the same idea from opposite ends. Before: what pressing
+* this will do, in enough detail that a reviewer can decide whether to spend the minutes. After:
+* what it did, in numbers they can act on without opening anything.
+*
+* The one thing neither may do is describe the machinery. A reviewer does not want to know that a
+* fast-forward preceded a reconciliation. They want to know that the review they are reading is
+* about the code they have, and what changed in it while they were away.
+*/
+/**
+* The primary action on a moved branch.
+*
+* A button rather than a command to copy, and that is a deliberate reversal of what the freshness
+* strip used to offer. The old reasoning was that a re-analysis is minutes of work that belongs in
+* the session where the reviewer can watch it, which is true of a *fresh review* and was quietly
+* being applied to everything. This is not a fresh review: it is bounded, it reads only the new
+* commits, it keeps the reviewer's place, and it refuses rather than improvising whenever the
+* working tree would need a judgement call. That is a button.
+*
+* The fresh review stays on offer beside it, because a branch rebuilt from scratch genuinely needs
+* one, but behind a disclosure rather than in the open. It is the rarer answer, and a raw slash
+* command sitting on the panel is the implementation showing through the product: the reviewer has
+* to read and dismiss it every time to get to the button they actually want.
+*/
+function renderUpdateButton() {
+	return `<button type="button" class="prb-update-btn" data-review-update>Update review</button>`;
+}
+/**
+* What pressing it does, and the way out for someone who wants a different thing entirely.
+*
+* Separate from the button rather than wrapped with it, because the panel lays out its own rows:
+* the controls sit on one line and this sits under them. Trying to do that with flex ordering
+* inside a wrapper put the sentence after `Dismiss`, which is exactly where it does not belong.
+*/
+function renderUpdateAside(command) {
+	return {
+		alt: `<details class="prb-update-alt">
+      <summary>Start fresh instead</summary>
+      <span>A brand new review, with its own findings and its own path through the change. Run <code>${escapeHtml(command)}</code> in your session.<button type="button" class="prb-fresh-quiet" data-copy-command="${escapeHtml(command)}">Copy</button></span>
+    </details>`,
+		explain: `<p class="prb-update-explain">Reanalyses the new commits and re-reads the pull request conversation. Your progress and Buddy AI history are kept.</p>`
+	};
+}
+/**
+* What the last update did, on the review it did it to.
+*
+* Shown after the reload that follows an update, and only then: it reports an event rather than a
+* state, so it is dismissible and does not come back. A stop is shown with the same weight as a
+* success, because "nothing happened and here is why" is the outcome most likely to be missed and
+* the only one the reviewer has to act on.
+*/
+function renderUpdateOutcome(outcome) {
+	if (!outcome) return "";
+	return `<div class="prb-update-result" data-state="${outcome.ok ? "done" : outcome.stop === "refused" ? "refused" : "stopped"}" data-update-result role="status">
+  <div class="prb-update-result-body">
+    <p><strong>${escapeHtml(outcome.ok ? "Review updated" : outcome.stop === "refused" ? "There was nothing to update against" : "The review was not updated")}</strong> ${escapeHtml(outcome.message)}</p>
+    ${renderFootnotes(outcome)}
+  </div>
+  <button type="button" class="prb-fresh-dismiss" data-update-close>Close</button>
+</div>`;
+}
+/**
+* The two things that can go quietly half-wrong, said out loud.
+*
+* Both are cases where the headline is a success and part of the work did not happen. A reviewer
+* who is told "Review updated" and not told the conversation could not be re-read will read the
+* "already raised by @sarah" lines as current, which is exactly the confident staleness the
+* freshness strip exists to prevent.
+*/
+function renderFootnotes(outcome) {
+	const notes = [];
+	if (outcome.fetchFailed) notes.push("The remote could not be reached, so this used the commits your copy of the repository already had.");
+	if (outcome.conversationOk === false) notes.push("The pull request conversation could not be re-read, so the notes about who raised what are as old as the review.");
+	if (!notes.length) return "";
+	return `<p class="prb-update-footnote">${notes.map((note) => escapeHtml(note)).join(" ")}</p>`;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/freshness_view.ts
+/**
+* Freshness, said in sentences.
+*
+* Rendered by one function shared between the server and the page's own client, because this is
+* the second renderer of a thing that already exists on the server and the codebase has been
+* bitten by that before — "two viewers would drift the first time one of them was improved". The
+* server paints it on load; the client repaints it after a re-check; both call this.
+*
+* Nothing here decides what the reviewer should do. It reports three comparisons and, where it
+* cannot make one, says so — including the third, which it can never make. The reason that matters
+* is the one the whole module is against: a review that goes stale silently is more dangerous than
+* one that admits it does not know, because the reader supplies the confidence themselves.
+*/
+/**
+* What the reviewer runs to get a brand new review of the change.
+*
+* Still handed over rather than run from here, and the boundary is real: a fresh review is a fresh
+* set of findings, a fresh path through the change, and questions it may need answering along the
+* way. That belongs in the session where the analyser lives and the reviewer can watch it.
+*
+* Its own command rather than `/prreviewbuddy:review`, which now hands back the review of this
+* branch that already exists rather than making a second one. That is the safe default for the
+* command someone types most often, and it makes this string the only way to ask for another
+* review on purpose — which is exactly what the reviewer reading it is trying to do.
+*
+* What *is* run from here is the update, which is a different thing wearing similar clothes. It
+* reads only the commits since this review was made, it keeps the review and everything marked in
+* it, and it refuses rather than improvising whenever the working tree would need a judgement call.
+* See `update_view.ts`, which offers both side by side.
+*/
+var REANALYSE_COMMAND = "/prreviewbuddy:fresh-review";
+/** Short summary for the header control. The reviewer should not have to open a panel to worry. */
+function freshnessLabel(report) {
+	if (!report) return {
+		label: "Check for updates",
+		state: "unknown"
+	};
+	if (report.code.state === "changed") return {
+		label: report.code.rewritten ? "Code rewritten" : "Code changed",
+		state: "changed"
+	};
+	if (report.checkout.state === "changed") return {
+		label: "Checkout differs",
+		state: "changed"
+	};
+	if (report.code.state === "current") return {
+		label: "Up to date",
+		state: "current"
+	};
+	return {
+		label: "Freshness unknown",
+		state: "unknown"
+	};
+}
+/**
+* The banner under the header, or nothing.
+*
+* Silent when every comparison came back clean and the reviewer has not asked, because a strip
+* that is always there is a strip nobody reads — and the one time it says something new is the
+* time it has to be noticed.
+*/
+/**
+* The panel under the header: one status, one consequence, one primary action.
+*
+* This used to be a stack of independent sentence-rows, one per comparison, each with its own
+* amber dot and its own paragraph. Three comparisons meant three warnings of equal weight, so a
+* rewritten branch and a checkout that is merely behind shouted equally loudly, the action was
+* buried in the middle of the prose, and the whole thing pushed the review it describes off the
+* screen. Everything below is one restructure of that into a hierarchy.
+*
+* The code comparison is the status. Everything else is a footnote to it, because everything else
+* is only interesting once you know whether the findings still describe the code. The header chip
+* carries the same status in two words; this panel exists to say what it means and offer the way
+* out, so it does not repeat the chip's job.
+*/
+function renderFreshness(report, options = {}) {
+	if (!report) return "";
+	const alarming = report.code.state === "changed" || report.checkout.state === "changed";
+	const lost = report.code.reason === "missing-commit";
+	const dismissed = options.dismissedSha !== void 0 && options.dismissedSha === report.code.headSha;
+	if (!options.open && (!(alarming || lost) || dismissed)) return "";
+	const status = codeStatus(report.code);
+	const facts = [...status.facts, `checked ${escapeHtml(relativeTime$1(report.checkedAt))}`];
+	const notes = [checkoutNote(report.checkout), options.open ? conversationNote$1(report, options.actions === true) : ""].filter((note) => note !== "");
+	return `<div class="prb-fresh" data-state="${alarming || lost ? "changed" : "quiet"}" role="status">
+  <div class="prb-fresh-head">
+    <span class="prb-fresh-dot" data-freshness="${status.state}" aria-hidden="true"></span>
+    <strong class="prb-fresh-title">${escapeHtml(status.title)}</strong>
+    <span class="prb-fresh-facts">${facts.join(" &middot; ")}</span>
+  </div>
+  ${status.consequence ? `<p class="prb-fresh-say">${status.consequence}</p>` : ""}
+  ${renderActions(report, options, alarming || lost)}
+  ${notes.length === 0 ? "" : `<div class="prb-fresh-notes">${notes.map((note) => `<p>${note}</p>`).join("")}</div>`}
+</div>`;
+}
+/**
+* One primary action, then the two that only adjust the panel itself.
+*
+* `Update review` is the only control here that changes the review, so it is the only one wearing
+* the brand colour. `Check again` and `Dismiss` are quiet text buttons: as equal-weight boxes they
+* competed with it, which is what made the area read as busy rather than as a decision.
+*/
+function renderActions(report, options, alarming) {
+	const offerUpdate = options.actions && alarming;
+	const dismiss = alarming ? `<button type="button" class="prb-fresh-quiet" data-fresh-dismiss="${escapeHtml(report.code.headSha ?? "")}">Dismiss</button>` : `<button type="button" class="prb-fresh-quiet" data-fresh-close>Close</button>`;
+	const aside = offerUpdate ? renderUpdateAside(REANALYSE_COMMAND) : {
+		alt: "",
+		explain: ""
+	};
+	return `<div class="prb-fresh-actions">
+    ${offerUpdate ? renderUpdateButton() : ""}
+    <button type="button" class="prb-fresh-quiet" data-fresh-recheck>Check again</button>
+    ${dismiss}
+    ${aside.alt}
+  </div>
+  ${aside.explain}`;
+}
+function files(n, verb) {
+	return n === null ? [] : [`${n} file${n === 1 ? "" : "s"} ${verb}`];
+}
+/** Seven characters is how everyone reads a commit, and the full sha is on the element for copying. */
+function short(sha) {
+	return sha ? `<code title="${escapeHtml(sha)}">${escapeHtml(sha.slice(0, 7))}</code>` : "";
+}
+/** The reviewed commit, which is the one fact worth repeating on every variant. */
+function reviewed(sha) {
+	return sha ? [`reviewed ${short(sha)}`] : [];
+}
+function codeStatus(code) {
+	if (code.state === "current") return {
+		state: "current",
+		title: "Up to date",
+		facts: reviewed(code.reviewedSha),
+		consequence: ""
+	};
+	if (code.state === "changed") {
+		if (code.rewritten) return {
+			state: "changed",
+			title: "Code rewritten",
+			facts: [...reviewed(code.reviewedSha), ...files(code.changedFiles, "differ")],
+			consequence: "The branch was rebased, amended or reset, so the reviewed commit is no longer on it. Every finding below describes the older code."
+		};
+		const commits = code.newCommits === null ? [] : [`${code.newCommits} new commit${code.newCommits === 1 ? "" : "s"}`];
+		return {
+			state: "changed",
+			title: "Code changed",
+			facts: [
+				...reviewed(code.reviewedSha),
+				...commits,
+				...files(code.changedFiles, "changed")
+			],
+			consequence: "Findings below describe the reviewed commit, and the lines they cite may no longer be those lines."
+		};
+	}
+	switch (code.reason) {
+		case "uncommitted": return {
+			state: "unknown",
+			title: "Cannot be compared",
+			facts: reviewed(code.reviewedSha),
+			consequence: "This review read uncommitted work and nothing recorded what the working tree held, so whether the files still match cannot be told from here."
+		};
+		case "missing-commit": return {
+			state: "unknown",
+			title: "Reviewed commit is gone",
+			facts: reviewed(code.reviewedSha),
+			consequence: "It is not in this repository any more, after a force-push or a branch rebuilt from scratch, so nothing can be measured against it."
+		};
+		default: return {
+			state: "unknown",
+			title: "Cannot be compared",
+			facts: [],
+			consequence: "Git could not be read in this checkout."
+		};
+	}
+}
+/**
+* The checkout, demoted to a footnote.
+*
+* It was a second amber warning carrying the same weight as the code status, which is the wrong
+* ranking: a checkout that is behind changes nothing about whether the findings are true, it only
+* explains why the conversation reads the way it does. Muted, one line, inside the same panel.
+*/
+function checkoutNote(checkout) {
+	if (checkout.reason === "no-pull-request") return "";
+	if (checkout.reason === "no-head-sha" || checkout.reason === "git-failed") return "Your checkout cannot be compared against the pull request.";
+	const untouched = "Updating leaves your checkout alone.";
+	switch (checkout.relation) {
+		case "same": return "";
+		case "checkout-behind": return `Your checkout is behind the pull request head ${short(checkout.prHeadSha)}, recorded at import. ${untouched}`;
+		case "checkout-ahead": return `Your checkout is ahead of the pull request head ${short(checkout.prHeadSha)} recorded at import, so the conversation below describes earlier code. ${untouched}`;
+		case "diverged": return `Your checkout and the pull request have diverged, measured against ${short(checkout.prHeadSha)} at import. ${untouched}`;
+		default: return "The relationship between your checkout and the pull request could not be worked out.";
+	}
+}
+/**
+* When the conversation was last read, and the offer to read it again.
+*
+* The wording changed with the thing it describes. This used to say the page "has no connection to
+* the site your pull request lives on, so someone has to go and look", which was true while the
+* only way to fetch a conversation was to ask a model to go and do it. A forge adapter drives the
+* CLI the reviewer has already signed in to now, so re-checking takes a couple of seconds and the
+* sentence calling it impossible had outlived the limitation it described.
+*
+* Still safe to run from here for the reason it always was: re-reading threads can only correct
+* the state of claims that already exist, never produce a finding.
+*/
+function conversationNote$1(report, actions) {
+	if (!report.conversation.attached) return "";
+	const when = escapeHtml(relativeTime$1(report.conversation.importedAt));
+	if (!actions) return `The pull request conversation was read ${when}.`;
+	return `The pull request conversation was read ${when}. Re-checking fetches every thread again and corrects the &ldquo;already raised&rdquo; notes on your findings, leaving the findings themselves alone.<button type="button" class="prb-fresh-quiet" data-pr-recheck>Re-check the conversation</button>`;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/job_view.ts
+/**
+* The workspace while its review is still being made, and what to do about it if it fails.
+*
+* A reviewer can now open a link before the review behind it exists: the review runs in a spawned
+* process against an isolated checkout, and this is minutes long by design. A silent wait was
+* reported as a hang once already in this product, on a step that took far less time than this
+* one does, so every state here says which phase it is in and how long it has been going rather
+* than leaving a blank space where the review will eventually appear.
+*
+* A conversation that could not be fetched is not folded in here as a failure: it is a line on a
+* review that finished, not a state this module renders while the job is still working.
+*/
+/** What the reviewer reads while each phase runs. The only copy visible during the wait. */
+var PHASE_COPY = {
+	preparing: "Preparing an isolated checkout. This can take a minute on a large repository.",
+	context: "Reading what changed.",
+	conversation: "Reading the pull request conversation.",
+	analysing: "Analysing the change."
+};
+/**
+* The same phases, as a noun, for the retry sentence.
+*
+* "picks up from the analysis" reads as an answer to "will this redo work"; "picks up from the
+* analysing" does not, which is why this is a separate table from `PHASE_COPY` rather than a
+* reuse of it.
+*/
+var PHASE_NOUN = {
+	preparing: "checkout",
+	context: "context reading",
+	conversation: "conversation reading",
+	analysing: "analysis"
+};
+function isWorkPhase(phase) {
+	return phase === "preparing" || phase === "context" || phase === "conversation" || phase === "analysing";
+}
+/** How long a phase has been running, in words a reviewer reads as reassurance rather than alarm. */
+function elapsedFor(startedAt) {
+	const minutes = Math.round((Date.now() - startedAt) / 6e4);
+	if (minutes < 1) return "under a minute";
+	return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+}
+/**
+* What to say about a conversation that is not attached, and when to say nothing at all.
+*
+* Two of the six outcomes are silence. An attached conversation speaks for itself, on the review.
+* A change that is not on a pull request has nothing missing from it, and a permanent note saying
+* so on every branch review would be the house style's own bad habit: a status strip that is only
+* ever true.
+*
+* The other four all change what the "already raised" notes on this review can claim, which is
+* exactly the thing a reviewer would otherwise assume they had.
+*/
+function conversationNote(outcome) {
+	switch (outcome.kind) {
+		case "attached":
+		case "no-request": return "";
+		case "unsupported-forge": return outcome.host ? `PR Review Buddy does not read pull request conversation on ${outcome.host} yet, so this review is of the code alone.` : "This repository has no remote to look a pull request up on, so this review is of the code alone.";
+		case "cli-missing": return `This review was made without the pull request conversation, because \`${outcome.cli}\` is not installed.`;
+		case "not-authenticated": return `This review was made without the pull request conversation, because \`${outcome.cli}\` is not signed in. Run \`${outcome.cli} auth login\` and update the review to read it.`;
+		case "failed": return `This review was made without the pull request conversation attached. ${outcome.detail}`;
+	}
+}
+/**
+* The workspace page above the review: what the job is doing, or nothing at all.
+*
+* Nothing is rendered once the job has finished cleanly, because a permanent status strip on a
+* complete review is exactly the noise this house style avoids elsewhere. The one exception is a
+* conversation that could not be attached: that is worth a line even on a review that otherwise
+* succeeded, because it changes what the "already raised" notes on this review can claim.
+*/
+function renderJobState(job) {
+	if (!job) return "";
+	if (job.phase === "failed" && job.failure) {
+		const noun = isWorkPhase(job.failure.phase) ? PHASE_NOUN[job.failure.phase] : job.failure.phase;
+		return `<div class="prb-job" data-job-phase="failed" role="status">
+  <p><strong>Review paused.</strong> ${escapeHtml(job.failure.message)}</p>
+  <button type="button" class="prb-job-retry" data-job-retry>Retry</button>
+  <p class="prb-job-note">Retry picks up from the ${escapeHtml(noun)}, not from the start.</p>
+</div>`;
+	}
+	if (job.phase === "done") {
+		const note = job.conversation ? conversationNote(job.conversation) : "";
+		if (!note) return "";
+		return `<div class="prb-job" data-job-phase="done" role="status">
+  <p>${escapeHtml(note)}</p>
+</div>`;
+	}
+	const copy = isWorkPhase(job.phase) ? PHASE_COPY[job.phase] : "";
+	const progress = job.progress ? ` <span class="prb-job-progress">${escapeHtml(job.progress)}</span>` : "";
+	return `<div class="prb-job" data-job-phase="${escapeHtml(job.phase)}" role="status" aria-live="polite">
+  <p><span class="prb-spinner" aria-hidden="true"></span> ${escapeHtml(copy)}${progress}</p>
+  <p class="prb-job-elapsed">Running for ${escapeHtml(elapsedFor(job.startedAt))}.</p>
+</div>`;
+}
+/**
+* What the page's poll asks for, and what the client needs to decide whether to keep asking.
+*
+* `'none'` covers a workspace with no job at all, which is an ordinary state for anything made
+* before jobs existed, or a review whose job record has since been swept.
+*/
+function jobStatus(job) {
+	if (!job) return {
+		phase: "none",
+		progress: "",
+		failed: false
+	};
+	const progress = job.phase === "failed" ? job.failure?.message ?? "" : job.progress ?? (isWorkPhase(job.phase) ? PHASE_COPY[job.phase] : "");
+	return {
+		phase: job.phase,
+		progress,
+		failed: job.phase === "failed"
+	};
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/page.ts
+function renderWorkspace(view) {
+	const { session, changeSet } = view;
+	const result = session.result;
+	const sections = result?.sections ?? [];
+	const title = changeSet.data.pullRequest.title;
+	/**
+	* Freshness is a claim about findings, so a review with no findings has none to make.
+	*
+	* "The code has moved on, the findings below describe that commit" said on a review that stopped
+	* before producing a finding describes nothing, and the Update review button beside it offers to
+	* reconcile a review against itself. The CLI already refuses this; the page was showing it.
+	*
+	* Decided once here rather than at each of the three places it is drawn, because the header pill,
+	* the `data-report` the client repaints from, and the banner itself have to agree. Suppressing
+	* only the markup would leave the pill able to paint it straight back.
+	*/
+	const freshness = result ? view.freshness : void 0;
+	return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(changeSet.isLinkedWorktree ? `${changeSet.checkoutName}: ${title}` : title)} · PR Review Buddy</title>
+<link rel="icon" type="image/png" href="/assets/icon128.png">
+<link rel="stylesheet" href="/assets/sidebar.css">
+<link rel="stylesheet" href="/assets/shell.css">
+</head>
+<body data-api-base="${escapeHtml(view.apiBase)}"${view.token ? ` data-token="${escapeHtml(view.token)}"` : ""}${view.editor ? ` data-editor-label="${escapeHtml(view.editor.label)}" data-editor-template="${escapeHtml(view.editor.template)}"` : ""}${view.repoPath ? ` data-repo-path="${escapeHtml(view.repoPath)}"` : ""} data-explain-prompt="${escapeHtml(EXPLAIN_SIMPLY_PROMPT)}">
+${renderHeader(view, freshness)}
+${renderJobState(view.job ?? null)}
+<div class="prb-fresh-region" data-fresh-region${freshness ? ` data-report="${escapeHtml(JSON.stringify(freshness))}"` : ""}${view.dismissedFreshnessSha ? ` data-dismissed-sha="${escapeHtml(view.dismissedFreshnessSha)}"` : ""}>${renderFreshness(freshness ?? null, {
+		dismissedSha: view.dismissedFreshnessSha,
+		actions: view.token !== void 0
+	})}</div>
+${renderUpdateOutcome(view.lastUpdate)}
+${renderLineageNotice(view)}
+${result ? renderReviewBody(view, sections) : ""}
+${view.token ? renderShutdownDialog() : ""}
+${view.token ? renderPromptDialog() : ""}
+<script type="module" src="/assets/workspace.js"><\/script>
+</body>
+</html>`;
+}
+/**
+* Everything the review actually shows: the rail, the document, the assistant.
+*
+* Pulled out of `renderWorkspace` so it can be skipped whole rather than rendered around a null
+* result. A review with no result yet has no sections, no issues, no files worth listing — every
+* one of those panes would draw as empty rather than as absent, and a reviewer cannot tell "this
+* finished with nothing to say" from "this has not run yet" by looking at an empty list.
+*/
+function renderReviewBody(view, sections) {
+	const { session } = view;
+	const result = session.result;
+	return `<div class="prb-body"${view.askWidth ? ` style="--ask-width: ${Math.round(view.askWidth)}px"` : ""}>
+  ${renderRail(view, sections)}
+  <main class="prb-doc">
+    <div class="pr-helper-sidebar prb-pane">
+      ${renderDisclosure(view)}
+      <section class="prb-view" data-view="overview">${renderOverviewTab(session)}</section>
+      <section class="prb-view" data-view="guide" hidden>${renderGuideTab(session, null, null)}</section>
+      <section class="prb-view" data-view="issues" hidden>
+        <h3 class="prb-doc-title">Issues</h3>
+        ${renderAttributionAge(view)}
+        ${renderIssuesTab(session, null)}
+      </section>
+      <section class="prb-view" data-view="questions" hidden>
+        <h3 class="prb-doc-title">Questions</h3>
+        ${renderQuestionsTab(session, null, { suppressFileJump: true })}
+      </section>
+      <section class="prb-view" data-view="files" hidden>
+        <h3 class="prb-doc-title">Files</h3>
+        ${renderFiles(view, sections)}
+      </section>
+      <section class="prb-view" data-view="prcontext" hidden>
+        ${renderPrContextView(view.prContext ?? null, {
+		findings: result?.issues.length ?? 0,
+		matched: (result?.issues ?? []).filter((issue) => issue.existingDiscussion).length
+	}, {
+		enabled: view.token !== void 0 && view.prContext !== void 0,
+		last: view.lastPrRefresh
+	})}
+      </section>
+    </div>
+  </main>
+  ${renderAsk(view, sections)}
+</div>`;
+}
+/**
+* When the "already raised" claims below were last true.
+*
+* Every attribution on this view carries a thread's state — "still unresolved", "since marked
+* resolved" — and that state was frozen the moment the conversation was imported. Nothing
+* re-checks it, and nothing here can: the daemon reaches no forge. So a card can go on telling
+* the reviewer that Sergei's thread is open an hour after Sergei closed it.
+*
+* Every other kind of staleness in this product degrades into vagueness. This one degrades into a
+* confident, specific, wrong claim about what a named colleague currently thinks, which is worth
+* one line above the list rather than an explanation the reviewer has to go and find.
+*
+* Only where a conversation was attached: there are no such claims to qualify otherwise.
+*/
+function renderAttributionAge(view) {
+	if (!view.prContext) return "";
+	return `<p class="prb-doc-note">Any &ldquo;already raised&rdquo; note below describes the pull request as it stood ${escapeHtml(relativeTime$1(view.prContext.prContext.discussion.fetchedAt))}, when its discussion was fetched. That includes whether each thread was still open. If someone has replied or resolved a thread since then, this page has no way of knowing. Use <b>Re-check the conversation</b> on the PR context view to bring it up to date.</p>`;
+}
+/**
+* The link out to this file on the pull request.
+*
+* Wraps the shared builder in `file_links.ts`, which the file viewer's own route uses too so the
+* two cannot disagree about where a file lives.
+*/
+function prFileLink(view, path) {
+	return buildPrFileLink(view.prContext?.prContext, path);
+}
+/**
+* Whose work this is, beside the branch it is on.
+*
+* Here rather than in the Overview because it is part of what identifies the change, and a
+* reviewer wants it before they read a line rather than after. Absent when nothing recorded it,
+* which is an ordinary state for a review made before this existed.
+*/
+function renderAuthor(view) {
+	const author = describeAuthorship(view.changeSet, view.prContext?.prContext.pullRequest);
+	if (!author) return "";
+	const title = author.title ? ` title="${escapeHtml(author.title)}"` : "";
+	const handle = author.handle ? `<span class="prb-author-handle">@${escapeHtml(author.handle)}</span>` : "";
+	const body = `<span class="prb-author-name">${escapeHtml(author.label)}</span>${handle}`;
+	return author.url ? `<a class="prb-author" href="${escapeHtml(author.url)}" target="_blank" rel="noopener noreferrer"${title}>${body}</a>` : `<span class="prb-author"${title}>${body}</span>`;
+}
+/**
+* "You are reading review 1 of 3", when that is true and only then.
+*
+* Silent on the latest review, which is the overwhelming majority of page loads: a strip that
+* appears on every review is a strip nobody reads, and the one time this has something to say is
+* the time it has to be noticed.
+*
+* The link goes to the index and carries no token of its own. That is the whole reason this is a
+* sentence and a link rather than a dropdown: the index is the only page that holds every review's
+* credential, and a reviewer arriving there has their own way in.
+*/
+function renderLineageNotice(view) {
+	const lineage = view.lineage;
+	if (!lineage || lineage.position >= lineage.total) return "";
+	const newer = lineage.total - lineage.position;
+	return `<div class="prb-lineage" role="status">
+  <p><strong>You are reading review ${lineage.position} of ${lineage.total}.</strong> ${newer === 1 ? "A newer review" : `${newer} newer reviews`} of this branch ${newer === 1 ? "exists" : "exist"}, so the findings below may already have been answered. Nothing here is out of bounds, but the current one is somewhere else.</p>
+  <a class="prb-lineage-link" href="/">See every review of this branch</a>
+</div>`;
+}
+function renderHeader(view, freshness) {
+	const { changeSet } = view;
+	const additions = changeSet.data.files.reduce((sum, f) => sum + f.additions, 0);
+	const deletions = changeSet.data.files.reduce((sum, f) => sum + f.deletions, 0);
+	const fileCount = changeSet.data.files.length;
+	return `<header class="prb-header">
+  <span class="prb-wordmark"><b>pr</b>review<b>buddy</b></span>
+  <span class="prb-change-ref" title="${escapeHtml(changeSet.repoPath)}">
+    ${changeSet.isLinkedWorktree ? `<span class="prb-checkout">${escapeHtml(changeSet.checkoutName)}</span>` : ""}
+    ${view.prContext ? `<a class="prb-pr-chip" href="${escapeHtml(view.prContext.prContext.pullRequest.url)}" target="_blank" rel="noopener noreferrer" title="${escapeHtml(view.prContext.prContext.pullRequest.title ?? "")}">#${view.prContext.prContext.pullRequest.number}</a>` : ""}
+    <strong>${escapeHtml(changeSet.headRef)}</strong>
+    <span class="prb-arrow" aria-label="compared against">&rarr;</span>
+    <span>${escapeHtml(changeSet.baseRef)}</span>
+    ${changeSet.includesUncommitted ? "<span class=\"prb-file-status\">+ working tree</span>" : ""}
+    ${renderAuthor(view)}
+  </span>
+  <div class="prb-header-stats">
+    <span>${fileCount} file${fileCount === 1 ? "" : "s"}</span>
+    <span><span class="prb-add">+${additions}</span> <span class="prb-del">&minus;${deletions}</span></span>
+    ${view.token && freshness ? (() => {
+		const { label, state } = freshnessLabel(freshness ?? null);
+		return `<button type="button" class="prb-fresh-check" data-fresh-check data-state="${state}" aria-expanded="false" title="How this review stands against the branch as it is now">${escapeHtml(label)}</button>`;
+	})() : ""}
+    ${view.token ? `<button type="button" class="prb-complete" data-complete aria-pressed="${view.complete === true}">${view.complete ? "Reviewed" : "Mark review complete"}</button>` : ""}
+    <button type="button" class="prb-ask-toggle" data-ask-toggle aria-expanded="false">Buddy AI</button>
+  </div>
+</header>`;
+}
+/**
+* Everything below the review: where else to go, and what to do to the server.
+*
+* These are in the rail rather than the header because they are not about this review. The header
+* answers "what am I looking at" — branch, size, whether I am done with it, and Buddy AI — and
+* anything global sitting up there competed with that. Leaving the review is navigation, and it
+* belongs with the other navigation.
+*
+* Stopping the server is separated from the links because it is operational and it ends every open
+* review, not just this one. The build sits beside it: it is provenance, wanted when something is
+* wrong, and that is the same corner as the feedback link that carries it.
+*
+* The same feedback form the extension uses, so replies land in one place rather than two. What
+* it carries is decided in `version.ts` — version, client, OS — and deliberately not the
+* repository or its path.
+*/
+function renderRailFoot(view) {
+	return `<div class="prb-rail-group prb-rail-foot">
+    ${view.token ? `<a class="prb-rail-item" href="/">
+             <span class="prb-rail-order">&lsaquo;</span>
+             <span class="prb-rail-label"><span class="prb-rail-title">All reviews</span></span>
+           </a>` : ""}
+    <a class="prb-rail-item" href="${escapeHtml(feedbackUrl())}" target="_blank" rel="noopener noreferrer">
+      <span class="prb-rail-order"></span>
+      <span class="prb-rail-label"><span class="prb-rail-title">Send feedback</span></span>
+    </a>
+  </div>
+  <div class="prb-rail-group prb-rail-ops">
+    ${view.token ? `<button type="button" class="prb-rail-item prb-rail-danger" data-shutdown>
+             <span class="prb-rail-order"></span>
+             <span class="prb-rail-label"><span class="prb-rail-title">Stop server</span></span>
+           </button>` : ""}
+    <p class="prb-build">v${escapeHtml(BUILD_VERSION)}</p>
+  </div>`;
+}
+/**
+* The review path, nested under the Overview.
+*
+* The themes are the Overview made walkable, not a second place to go, so the rail says that by
+* containing them rather than by listing them alongside it. Collapsing is a plain button beside
+* the Overview rather than a <details>: the row has to stay a link to the Overview, and a control
+* inside a <summary> is toggled by the browser as well as by us in some engines.
+*
+* Themes are numbered because the guide genuinely is an ordered walkthrough — `order` is the
+* model's answer to "what sequence should a reviewer take through this change" — so the number
+* tells the reader something they need. It is not a decorative index.
+*/
+function renderRail(view, sections) {
+	const result = view.session.result;
+	const issues = result?.issues ?? [];
+	const questions = result?.questions ?? [];
+	return `<nav class="prb-rail" aria-label="Review path">
+  <div class="prb-rail-group">
+    <div class="prb-rail-row">
+      <button type="button" class="prb-rail-item" data-view-nav="overview" aria-current="true">
+        <span class="prb-rail-order"></span>
+        <span class="prb-rail-label"><span class="prb-rail-title">Overview</span></span>
+      </button>
+      <button type="button" class="prb-rail-twisty" data-rail-toggle aria-expanded="true" aria-controls="prb-rail-path" aria-label="Collapse the review path">
+        <svg viewBox="0 0 12 12" aria-hidden="true" focusable="false"><path d="M3 4.5 6 8l3-3.5" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>
+      </button>
+    </div>
+    <div class="prb-rail-path" id="prb-rail-path">
+      <p class="prb-rail-heading">Review path</p>
+      ${[...sections].sort((a, b) => a.order - b.order).map((section, index) => {
+		const sectionIssues = issues.filter((issue) => issue.sectionId === section.id).length;
+		const note = section.recommendedStartingPoint ? "<span class=\"prb-rail-start\">Start here</span>" : `<span class="prb-rail-note">${section.files.length} file${section.files.length === 1 ? "" : "s"}</span>`;
+		return `<button type="button" class="prb-rail-item" data-goto-section="${escapeHtml(section.id)}" data-theme-index="${index}" data-recommended-start="${section.recommendedStartingPoint}">
+        <span class="prb-rail-order">${index + 1}</span>
+        <span class="prb-rail-label">
+          <span class="prb-rail-title">${escapeHtml(section.title)}</span>
+          ${note}
+        </span>
+        ${sectionIssues > 0 ? `<span class="prb-rail-count" title="${sectionIssues} issue${sectionIssues === 1 ? "" : "s"} in this theme">${sectionIssues}</span>` : ""}
+        <span class="prb-attention" data-attention="${escapeHtml(section.reviewAttention)}" title="Needs ${escapeHtml(section.reviewAttention)} attention"></span>
+      </button>`;
+	}).join("") || "<p class=\"prb-rail-heading\">No themes</p>"}
+    </div>
+  </div>
+  <div class="prb-rail-group">
+    ${railLink("issues", "Issues", issues.length)}
+    ${railLink("questions", "Questions", questions.length)}
+    ${railLink("files", "Files", view.changeSet.data.files.length)}
+    ${view.prContext ? railLink("prcontext", "PR context", view.prContext.processed.stats.totalThreads) : railLink("prcontext", "PR context", null, "No pull request was connected to this review")}
+  </div>
+  ${renderRailFoot(view)}
+</nav>`;
+}
+/** A null count renders no badge, for the case where zero would be a claim rather than a total. */
+function railLink(view, label, count, note) {
+	return `<button type="button" class="prb-rail-item" data-view-nav="${view}"${note ? ` title="${escapeHtml(note)}"` : ""}>
+    <span class="prb-rail-order"></span>
+    <span class="prb-rail-label"><span class="prb-rail-title">${escapeHtml(label)}</span></span>
+    ${count === null ? "" : `<span class="prb-rail-count" title="${count} ${escapeHtml(label.toLowerCase())}">${count}</span>`}
+  </button>`;
+}
+/**
+* What the harness corrected, stated above the review rather than buried in a details element.
+* A guide quietly repaired is a guide trusted more than it deserves.
+*
+* Corrections only. There is deliberately nothing here about how much of the change travelled
+* inline: that is provenance, it belongs in Analysis details on the Overview, and putting it in a
+* box under this heading would restate a limit that no longer exists as though it did.
+*/
+function renderDisclosure(view) {
+	const { audit } = view;
+	const notes = [];
+	if (audit.unknownPaths.length > 0) notes.push(`${audit.unknownPaths.length} referenced path${audit.unknownPaths.length === 1 ? "" : "s"} could not be found in this change and ${audit.unknownPaths.length === 1 ? "was" : "were"} removed: ` + audit.unknownPaths.map((path) => `<code>${escapeHtml(path)}</code>`).join(", ") + ".");
+	if (audit.relocatedFindings > 0) notes.push(`${audit.relocatedFindings} finding${audit.relocatedFindings === 1 ? "" : "s"} pointed at a file that is not in this change. The finding is kept; its location is not.`);
+	if (notes.length === 0) return "";
+	return `<aside class="prb-disclosure">
+  <strong>What the harness corrected</strong>
+  <ul>${notes.map((note) => `<li>${note}</li>`).join("")}</ul>
+</aside>`;
+}
+/**
+* Every changed file, split by whether the guide sends the reviewer there.
+*
+* The split used to be analysed / not analysed, which was the truth under a file ceiling and is a
+* lie without one: nothing here was beyond the analysis's reach. What the two groups now record
+* is a priority the model set after reading, so the second group is a "later, if you want to",
+* not a gap the reviewer has to go and close.
+*/
+/**
+* The Files tab: the escape hatch from the guide.
+*
+* Everywhere else in the workspace the code shown is the code some finding is *about* — "here is
+* the evidence for this claim". This tab answers the other question a reviewer asks, which no
+* guide can anticipate: "let me look at that file myself". So it lists every changed file, groups
+* them by the theme that owns them, and expands them in place.
+*
+* The viewer is not a second implementation — every row carries `data-file`, which is the same
+* attribute the guide's file rows, an issue's location and a question's jump button carry, so all
+* four go through one code path. Two viewers would drift the first time one of them was improved.
+*/
+function renderFiles(view, sections) {
+	const files = view.changeSet.data.files;
+	const byPath = new Map(files.map((file) => [file.name, file]));
+	const references = collectReferences(view, sections);
+	const claimed = /* @__PURE__ */ new Set();
+	const groups = sections.map((section) => {
+		const sectionFiles = section.files.map((file) => byPath.get(file.path)).filter((file) => {
+			if (!file || claimed.has(file.name)) return false;
+			claimed.add(file.name);
+			return true;
+		});
+		return fileGroup(view, `${section.order}. ${section.title}`, sectionFiles, references);
+	}).join("");
+	const unclaimed = files.filter((file) => !claimed.has(file.name));
+	return `<div class="prb-file-search">
+    <input type="search" data-file-filter placeholder="Search files…" aria-label="Filter files by path" autocomplete="off" spellcheck="false">
+    <span class="prb-file-search-count" data-file-count>${files.length} file${files.length === 1 ? "" : "s"}</span>
+  </div>
+  ${groups}
+  ${fileGroup(view, "Not in the review path", unclaimed, references)}
+  <p class="prb-file-none" data-file-none hidden>No file matches that.</p>`;
+}
+/**
+* Which findings point at each file.
+*
+* Worth showing on the row because it is the one thing the file list cannot say for itself: a file
+* with four issues against it and a file with none look identical by path, status and line count.
+*/
+function collectReferences(view, sections) {
+	const result = /* @__PURE__ */ new Map();
+	const owner = /* @__PURE__ */ new Map();
+	for (const section of sections) for (const file of section.files) if (!owner.has(file.path)) owner.set(file.path, section.id);
+	const titles = new Map(sections.map((section) => [section.id, `${section.order}. ${section.title}`]));
+	const entry = (path) => {
+		const existing = result.get(path);
+		if (existing) return existing;
+		const created = {
+			issues: 0,
+			questions: 0,
+			otherSections: []
+		};
+		result.set(path, created);
+		return created;
+	};
+	const note = (path, sectionId, kind) => {
+		if (!path) return;
+		const record = entry(path);
+		record[kind] += 1;
+		const title = sectionId && sectionId !== owner.get(path) ? titles.get(sectionId) : void 0;
+		if (title && !record.otherSections.includes(title)) record.otherSections.push(title);
+	};
+	for (const issue of view.session.result?.issues ?? []) note(issue.file, issue.sectionId, "issues");
+	for (const question of view.session.result?.questions ?? []) note(question.file, question.sectionId, "questions");
+	return result;
+}
+function fileGroup(view, heading, files, references) {
+	if (files.length === 0) return "";
+	const rows = files.map((file) => fileRow(view, file, references.get(file.name))).join("");
+	return `<div class="prb-file-group" data-file-group>
+    <h4 data-group-heading="${escapeHtml(heading)}" data-group-total="${files.length}">${escapeHtml(heading)} · ${files.length}</h4>${rows}
+  </div>`;
+}
+function fileRow(view, file, refs) {
+	const { dir, name } = splitFilePath(file.name);
+	const badges = [
+		...refs?.issues ? [`<span class="prb-file-ref prb-file-ref-issue">${refs.issues} issue${refs.issues === 1 ? "" : "s"}</span>`] : [],
+		...refs?.questions ? [`<span class="prb-file-ref">${refs.questions} question${refs.questions === 1 ? "" : "s"}</span>`] : [],
+		...(refs?.otherSections ?? []).map((title) => `<span class="prb-file-ref">also ${escapeHtml(title)}</span>`)
+	].join("");
+	const readable = !(file.additions === 0 && file.deletions === 0 && !file.patch);
+	const openEditor = !readable && view.editor ? `<button type="button" class="prb-file-open" data-open-editor="${escapeHtml(file.name)}" data-open-line="1" title="Open in ${escapeHtml(view.editor.label)}">Open in ${escapeHtml(view.editor.label)}</button>` : "";
+	const link = readable ? null : prFileLink(view, file.name);
+	const openPr = link ? `<a class="prb-file-open prb-file-pr" href="${escapeHtml(link.href)}" target="_blank" rel="noopener noreferrer" title="${escapeHtml(link.label)}">Pull request</a>` : "";
+	const attributes = readable ? ` data-file="${escapeHtml(file.name)}" role="button" tabindex="0" aria-expanded="false"` : "";
+	return `<div class="prb-file${readable ? " prb-file-expandable" : ""}"${attributes} data-search="${escapeHtml(file.name.toLowerCase())}" title="${escapeHtml(file.name)}">
+    <span class="prb-file-status">${escapeHtml(file.status)}</span>
+    <span class="prb-file-path">
+      ${dir ? `<span class="pr-helper-path-dir">${escapeHtml(dir)}</span>` : ""}
+      <span class="pr-helper-path-name">${escapeHtml(name)}</span>
+    </span>
+    ${openPr}
+    ${openEditor}
+    ${badges ? `<span class="prb-file-badges">${badges}</span>` : ""}
+    <span class="prb-file-stat"><span class="prb-add">+${file.additions}</span> <span class="prb-del">&minus;${file.deletions}</span></span>
+  </div>`;
+}
+/**
+* Saving and editing one prompt.
+*
+* A dialog rather than an inline field: a prompt is a paragraph often enough that a one-line
+* input would misrepresent what belongs here, and editing needs somewhere to put Delete that is
+* not next to the button that inserts.
+*
+* One dialog, reused for add and for edit — `data-prompt-id` says which, and it is empty for a
+* new one. Two dialogs would be two places for the field wiring to drift.
+*/
+function renderPromptDialog() {
+	return `<dialog class="prb-dialog prb-prompt-dialog" data-prompt-dialog aria-labelledby="prb-prompt-title">
+  <h2 id="prb-prompt-title">Save a prompt</h2>
+  <label class="prb-field">
+    <span>Name</span>
+    <input type="text" data-prompt-name maxlength="60" placeholder="N+1 queries">
+  </label>
+  <label class="prb-field">
+    <span>Prompt</span>
+    <textarea data-prompt-text rows="5" maxlength="2000" placeholder="Check this change for N+1 database queries."></textarea>
+  </label>
+  <p class="prb-dialog-reassure">Saved prompts are yours and stay on this machine. They are offered in every review, and on any text you select.</p>
+  <div class="prb-dialog-actions">
+    <button type="button" class="prb-dialog-danger" data-prompt-delete hidden>Delete</button>
+    <span class="prb-dialog-spacer"></span>
+    <button type="button" data-prompt-cancel>Cancel</button>
+    <button type="button" class="prb-dialog-primary" data-prompt-save>Save</button>
+  </div>
+</dialog>`;
+}
+/**
+* A real dialog rather than a button that relabels itself.
+*
+* The relabelling version had a disarm timer, and an uncancelled timer from an earlier arming
+* could fire after the server had already stopped and reset the label to an offer that no longer
+* meant anything. A dialog has no timer to race, and it has room to say what is about to happen.
+*/
+function renderShutdownDialog() {
+	return `<dialog class="prb-dialog" data-shutdown-dialog aria-labelledby="prb-shutdown-title">
+  <h2 id="prb-shutdown-title">Stop the workspace server?</h2>
+  <p>One server serves every review on this machine, so <b>every open workspace stops</b>, not just this one.</p>
+  <p class="prb-dialog-reassure">Nothing is deleted. Your reviews stay on disk for thirty days. Run <code>/prreviewbuddy:start-server</code> to start the server again and get their links back.</p>
+  <div class="prb-dialog-actions">
+    <button type="button" data-shutdown-cancel>Cancel</button>
+    <button type="button" class="prb-dialog-danger" data-shutdown-confirm>Stop server</button>
+  </div>
+</dialog>`;
+}
+function renderAsk(view, sections) {
+	const suggestions = buildSuggestions(view, sections);
+	const transcript = view.transcript ?? [];
+	return `<aside class="prb-ask" aria-label="Ask Buddy AI">
+  <div
+    class="prb-ask-resize"
+    data-ask-resize
+    role="separator"
+    aria-orientation="vertical"
+    aria-label="Resize the assistant. Arrow keys adjust; Home resets."
+    tabindex="0"
+  ></div>
+  <div class="prb-ask-header">
+    <h2>Ask Buddy AI</h2>
+    <span class="prb-ask-scope" data-ask-scope>whole change</span>
+  </div>
+  ${renderPromptBank(view.prompts ?? [])}
+  <div class="prb-ask-log" data-ask-log>
+    ${transcript.length > 0 ? transcript.map((exchange) => `<div class="prb-msg prb-msg-user">${escapeHtml(exchange.question)}</div>
+      <div class="prb-msg prb-msg-assistant prb-md">${renderMarkdown(exchange.answer)}</div>`).join("") : `<div class="prb-ask-empty">
+      <p>Ask about this change. Answers come from the review, the diff and the repository on disk — not from anywhere else.</p>
+      ${suggestions.map((text) => `<button type="button" class="prb-suggestion" data-suggestion>${escapeHtml(text)}</button>`).join("")}
+    </div>`}
+  </div>
+  <form class="prb-ask-form" data-ask-form>
+    <textarea name="question" rows="1" placeholder="Ask about this change…" aria-label="Your question"></textarea>
+    <button type="submit">Ask</button>
+  </form>
+</aside>`;
+}
+/**
+* The reviewer's own prompts, above the conversation.
+*
+* Rendered server-side rather than fetched, so the bank is there on first paint — a list that
+* appears a moment after the page does reads as something that loaded, and a prompt bank is
+* furniture rather than content.
+*
+* The list is always present, even when empty: an empty bank with an Add button explains what
+* the feature is, where a hidden one leaves it undiscoverable until someone reads a changelog.
+*/
+function renderPromptBank(prompts) {
+	return `<div class="prb-bank" data-prompt-bank data-prompts="${escapeHtml(JSON.stringify(prompts))}">
+    <div class="prb-bank-head">
+      <span>Your prompts</span>
+      <button type="button" class="prb-bank-add" data-prompt-add>Add</button>
+    </div>
+    <div class="prb-bank-list" data-prompt-list>${prompts.map(renderPromptChip).join("")}</div>
+  </div>`;
+}
+function renderPromptChip(prompt) {
+	return `<span class="prb-bank-item">
+    <button type="button" class="prb-bank-use" data-prompt-use="${escapeHtml(prompt.id)}" title="${escapeHtml(prompt.prompt)}">${escapeHtml(prompt.name)}</button>
+    <button type="button" class="prb-bank-edit" data-prompt-edit="${escapeHtml(prompt.id)}" aria-label="Edit ${escapeHtml(prompt.name)}">&#9998;</button>
+  </span>`;
+}
+/**
+* Openers drawn from this change rather than a fixed list.
+*
+* A generic "explain this code" prompt teaches the reviewer nothing about what the assistant is
+* for. Naming the actual highest-severity finding and the actual starting theme shows them that it
+* already knows what they are looking at.
+*/
+function buildSuggestions(view, sections) {
+	const suggestions = [];
+	const worst = (view.session.result?.issues ?? [])[0];
+	if (worst) suggestions.push(`Why is "${worst.title}" risky?`);
+	const start = sections.find((section) => section.recommendedStartingPoint) ?? sections[0];
+	if (start) suggestions.push(`Walk me through the ${start.title.toLowerCase()} changes.`);
+	suggestions.push("Would this break existing users?");
+	return suggestions.slice(0, 3);
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/reviews_page.ts
+function renderReviewsPage(view) {
+	const now = view.now ?? Date.now();
+	const ordered = [...view.groups].sort((a, b) => Number(b.latest.pinned) - Number(a.latest.pinned) || touchedAt(b.latest) - touchedAt(a.latest));
+	return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Reviews · PR Review Buddy</title>
+<link rel="icon" type="image/png" href="/assets/icon128.png">
+<link rel="stylesheet" href="/assets/sidebar.css">
+<link rel="stylesheet" href="/assets/shell.css">
+</head>
+<body class="prb-index-body">
+<header class="prb-header">
+  <span class="prb-wordmark"><b>pr</b>review<b>buddy</b></span>
+  <span class="prb-change-ref">Reviews</span>
+  <div class="prb-header-stats">
+    <span>${storedLabel(view.groups.reduce((total, group) => total + group.history.length, 0), ordered.length)}</span>
+    <span class="prb-build">v${escapeHtml(BUILD_VERSION)}</span>
+    <a class="prb-feedback" href="${escapeHtml(feedbackUrl())}" target="_blank" rel="noopener noreferrer">Send feedback</a>
+  </div>
+</header>
+<main class="prb-index">
+  ${ordered.length === 0 ? "" : renderControls()}
+  <div class="prb-cards" data-cards>
+    ${ordered.map((group) => renderCard(group, now)).join("")}
+  </div>
+  ${ordered.length === 0 ? `<p class="prb-index-empty">No reviews stored yet. Ask Claude Code to review a change and one will appear here.</p>` : `<p class="prb-index-none" data-no-matches hidden>Nothing matches that.</p>`}
+  <p class="prb-index-note">Reviews are kept for thirty days, on this machine only. Stopping the server deletes nothing, but the next start gives every review a new link, so come back to this page rather than to a bookmarked review.</p>
+</main>
+<script src="/assets/reviews.js" type="module"><\/script>
+</body>
+</html>`;
+}
+/**
+* Search and filters, above the grid.
+*
+* Search covers everything a person might remember about a review — the repository, the branch,
+* the title, the model's summary, and the paths it touched — because which of those they recall
+* is not predictable. The filters are the three states and nothing else; a filter per risk level
+* would be four more controls for a question ("show me only the risky ones") that sorting by
+* recency already answers badly and that scanning answers well.
+*/
+function renderControls() {
+	return `<div class="prb-index-controls">
+    <input type="search" class="prb-index-search" data-search placeholder="Search repo, branch, title, summary or file…" aria-label="Search reviews" spellcheck="false">
+    <div class="prb-index-filters" role="group" aria-label="Filter reviews">
+      <button type="button" data-filter="all" aria-pressed="true">All</button>
+      <button type="button" data-filter="in-progress" aria-pressed="false">In progress</button>
+      <button type="button" data-filter="complete" aria-pressed="false">Reviewed</button>
+    </div>
+  </div>`;
+}
+/**
+* "13 reviews of 9 branches", once those are different numbers.
+*
+* The count used to be the number of cards, and it still could be, but the card no longer stands
+* for one review. Saying "9 stored" over a page holding thirteen analyses would be quietly wrong
+* about the one thing this header exists to state.
+*/
+function storedLabel(reviews, branches) {
+	if (reviews === branches) return `${reviews} stored`;
+	return `${reviews} reviews of ${branches} branch${branches === 1 ? "" : "es"}`;
+}
+/**
+* One branch.
+*
+* The order down the card is the order the questions get asked: what is this (summary), where is
+* it (repo and branch), how big and how risky, what is left, and when was I last here. Everything
+* above the history line describes the **latest** review, because that is the state of this branch
+* as far as the product knows; the earlier ones are history and are folded away until asked for.
+*/
+function renderCard(group, now) {
+	const review = group.latest;
+	const status = statusOf(review);
+	const href = `/r/${encodeURIComponent(review.id)}?t=${encodeURIComponent(review.token)}`;
+	return `<article class="prb-card" data-card data-status="${status}" data-pinned="${review.pinned}" data-search-text="${escapeHtml(groupSearchText(group))}">
+    <button type="button" class="prb-card-pin" data-pin="${escapeHtml(review.id)}" aria-pressed="${review.pinned}" aria-label="${review.pinned ? "Unpin" : "Pin"} this review" title="${review.pinned ? "Unpin" : "Pin to the top"}">${review.pinned ? "&#9733;" : "&#9734;"}</button>
+    <a class="prb-card-link" href="${escapeHtml(href)}">
+      <div class="prb-card-head">
+        <h2>${escapeHtml(review.title)}</h2>
+        ${renderStatus(status)}
+      </div>
+      ${review.summary ? `<p class="prb-card-summary">${escapeHtml(review.summary)}</p>` : ""}
+      <p class="prb-card-where">
+        <span class="prb-card-repo">${escapeHtml(lastSegment(review.repoPath))}</span>
+        <span class="prb-card-branch">${escapeHtml(review.branch)}</span>
+        ${review.author ? `<span class="prb-card-author">${escapeHtml(review.author)}</span>` : ""}
+      </p>
+      <p class="prb-card-stats">
+        ${renderRisk(review.overallRisk)}
+        <span>${review.changedFiles} file${review.changedFiles === 1 ? "" : "s"}</span>
+        <span class="prb-card-diffstat"><span class="prb-add">+${review.additions}</span> <span class="prb-del">&minus;${review.deletions}</span></span>
+      </p>
+      <p class="prb-card-left">${escapeHtml(whatIsLeft(review))}</p>
+      <p class="prb-card-when"><time datetime="${new Date(touchedAt(review)).toISOString()}" title="${escapeHtml(new Date(touchedAt(review)).toLocaleString())}">${escapeHtml(whenLabel(review, now))}</time></p>
+    </a>
+    ${renderHistory(group, now)}
+  </article>`;
+}
+/**
+* Every analysis of this branch, folded away.
+*
+* Absent entirely on a branch reviewed once, which is most of them: a disclosure reading
+* "1 review" is a control that can only ever tell you what the card already said.
+*
+* Outside the card's link rather than inside it, because a link inside a link is not a thing HTML
+* has, and each row is its own link into its own review with its own token.
+*/
+function renderHistory(group, now) {
+	if (group.history.length < 2) return "";
+	const count = group.history.length;
+	return `<div class="prb-card-history">
+    <button type="button" class="prb-card-history-toggle" data-history-toggle aria-expanded="false">
+      <span class="prb-card-history-caret" aria-hidden="true">&#9662;</span>${count} reviews
+    </button>
+    <ol class="prb-card-history-list" data-history-list hidden>
+      ${group.history.map((review, index) => renderHistoryRow(review, count - index, index === 0, now)).join("")}
+    </ol>
+  </div>`;
+}
+/**
+* One analysis in the list.
+*
+* The commit is on every row, including the latest, and it is the field that does the real work
+* here: two reviews an hour apart are told apart by what they were of, not by when they happened.
+* A review whose commit was never recorded shows none rather than a placeholder.
+*
+* Numbered from the oldest, so the newest has the highest number and "Review 1" is where this
+* branch started. The same numbering the workspace itself uses, so "Review 1 of 3" there and
+* "Review 1" here are the same review.
+*
+* **Only the latest row carries a workflow status.** `New`, `In progress` and `Reviewed` describe
+* where someone is in a piece of work, and on a superseded review that is a claim about work
+* nobody should be continuing: a row reading `IN PROGRESS` under a newer review of the same branch
+* invites exactly the wrong click. The second slot is the lineage instead, `Latest` or `Previous`,
+* which is the only thing about an older review that a reader needs before opening it.
+*/
+function renderHistoryRow(review, number, latest, now) {
+	const href = `/r/${encodeURIComponent(review.id)}?t=${encodeURIComponent(review.token)}`;
+	return `<li class="prb-card-history-row"${latest ? " data-latest" : ""}>
+    <a href="${escapeHtml(href)}">
+      <span class="prb-card-history-name">Review ${number} ${latest ? "<span class=\"prb-card-history-latest\">Latest</span>" : "<span class=\"prb-card-history-previous\">Previous</span>"}</span>
+      ${review.commitSha ? `<code class="prb-card-history-sha" title="${escapeHtml(review.commitSha)}">${escapeHtml(review.commitSha.slice(0, 7))}</code>` : ""}
+      <span class="prb-card-history-when">${escapeHtml(relativeTime(review.createdAt, now))}</span>
+      ${latest ? renderStatus(statusOf(review)) : ""}
+    </a>
+  </li>`;
+}
+/**
+* What this review still has open.
+*
+* Unresolved counts, not totals: "1 unanswered question" says where the review stands, where
+* "1/2 questions" makes the reader do the subtraction. Nothing here is a completion metric — the
+* product does not track file-by-file review, so the card does not pretend it does.
+*/
+function whatIsLeft(review) {
+	const parts = [];
+	if (review.issues > 0) parts.push(`${review.issues} issue${review.issues === 1 ? "" : "s"}`);
+	if (review.unansweredQuestions > 0) parts.push(`${review.unansweredQuestions} unanswered question${review.unansweredQuestions === 1 ? "" : "s"}`);
+	else if (review.questions > 0) parts.push("all questions answered");
+	if (review.messages > 0) parts.push(`${review.messages} Buddy AI message${review.messages === 1 ? "" : "s"}`);
+	return parts.length > 0 ? parts.join(" · ") : "Nothing flagged";
+}
+/**
+* Three states, and only one of them is inferred from anything.
+*
+* `complete` is set by the reviewer pressing a button and never derived. Every signal that looks
+* like completion — questions ticked, issues read — means the checklist is empty, which is not
+* the same as being done; a reviewer can still be reading code with nothing left to tick.
+*/
+function statusOf(review) {
+	if (review.completedAt) return "complete";
+	return review.lastViewedAt ? "in-progress" : "new";
+}
+function renderStatus(status) {
+	return `<span class="prb-card-status" data-status="${status}">${status === "complete" ? "Reviewed" : status === "in-progress" ? "In progress" : "New"}</span>`;
+}
+function renderRisk(risk) {
+	if (risk === "unknown") return "";
+	return `<span class="prb-card-risk" data-risk="${risk}">${risk} risk</span>`;
+}
+/** Last opened where that is known, created otherwise. */
+function touchedAt(review) {
+	return review.lastViewedAt ?? review.createdAt;
+}
+function whenLabel(review, now) {
+	return review.lastViewedAt ? `Opened ${relativeTime(review.lastViewedAt, now)}` : `Created ${relativeTime(review.createdAt, now)}`;
+}
+/**
+* Everything the search field matches, flattened into one string on the card.
+*
+* Matching happens in the browser against this attribute rather than over the rendered text: the
+* paths are searchable without being displayed, and a filter that walked the DOM would match the
+* word "issue" in a label as readily as in a title.
+*/
+function groupSearchText(group) {
+	return group.history.map(searchText).join(" ");
+}
+function searchText(review) {
+	return [
+		lastSegment(review.repoPath),
+		review.repoPath,
+		review.branch,
+		review.title,
+		review.summary,
+		review.author ?? "",
+		...review.paths
+	].join(" ").toLowerCase();
+}
+function lastSegment(path) {
+	const segments = path.split("/").filter(Boolean);
+	return segments[segments.length - 1] ?? path;
+}
+/**
+* "12 minutes ago" rather than a timestamp.
+*
+* What the reader is deciding is which of these is the one they were just working on, and a
+* relative age answers that in a glance where a clock time makes them do the subtraction. The
+* exact time is on the element's `title` for when several read the same.
+*/
+function relativeTime(at, now) {
+	const seconds = Math.max(0, Math.round((now - at) / 1e3));
+	if (seconds < 60) return "just now";
+	const minutes = Math.round(seconds / 60);
+	if (minutes < 60) return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+	const hours = Math.round(minutes / 60);
+	if (hours < 24) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+	const days = Math.round(hours / 24);
+	return `${days} day${days === 1 ? "" : "s"} ago`;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/ask.ts
+/** Long enough for a real look at the repository; short enough that a hang is not forever. */
+var ASK_TIMEOUT_MS = 18e4;
+var SYSTEM_PROMPT = `You are Buddy AI, PR Review Buddy's review assistant. Refer to yourself as Buddy AI on the rare occasion you need to name yourself.
+
+A developer is reviewing a specific code change and is looking at a review guide you have been given below. They ask you questions while they read.
+
+Answer only in relation to this change and the repository it lives in. You have the working tree, so open the files, trace callers and read history wherever that settles the question. Do not speculate about code you could have read.
+
+If a question cannot be answered from this change and this repository, say so plainly and say what would answer it. Do not pad the answer out with general advice about the topic; a developer mid-review wants the specific answer or an honest "that isn't determinable from here".
+
+Write in short paragraphs and keep it to what was asked. Markdown renders, so use it where it carries meaning: backticks for identifiers and paths, a fenced block for a snippet worth reading as code rather than described in a sentence, a bullet list where the answer genuinely is a list. Prose is still the default. No headings, and do not break a paragraph into bullets to look organised.`;
+var AskUnavailableError = class extends Error {};
+/**
+* Answer one question about the change, by running the agent in a checkout of the reviewed commit.
+*
+* Not the reviewer's own checkout, which is what this used to read. They are mid-review: the tree
+* has their edits in it, or a branch they switched to, or a rebase half done, and an assistant
+* reading that answers confidently about code the review is not about. The checkout here is pinned
+* to the commit the review was made from, so the answer describes the change the reviewer is
+* looking at, and the isolation the analysis has always had now covers the questions too.
+*
+* The agent rather than a provider API on purpose: it uses the authentication the developer already
+* has, needs no API key, and costs them nothing beyond their existing subscription. It also means
+* the assistant keeps working after the session that produced the review has closed, which is the
+* whole reason the workspace is served rather than written to a file.
+*/
+async function askAboutChange(workspace, question, sectionId) {
+	const cwd = await askCheckout(workspace);
+	const env = agentEnvOf(workspace);
+	try {
+		return extractAnswer(await agentFor(env).run({
+			capability: "read-code",
+			prompt: buildPrompt(workspace, question, sectionId, cwd),
+			cwd,
+			originRepoPath: workspace.repoPath,
+			env,
+			timeoutMs: ASK_TIMEOUT_MS
+		}));
+	} catch (error) {
+		if (error instanceof AgentUnavailableError) throw new AskUnavailableError("The agent is not available here, so the assistant cannot answer. Install Claude Code, or start the workspace from a shell where `claude` runs.");
+		throw error;
+	}
+}
+/**
+* The answer, checked before it is shown.
+*
+* An agent that produced nothing is a failure with a clear cause, and rendering its empty string as
+* an answer would show the reviewer a blank panel and call it a reply.
+*/
+function extractAnswer(raw) {
+	const answer = raw.trim();
+	if (!answer) throw new Error("The assistant returned an empty answer.");
+	return answer;
+}
+/**
+* Bound the assistant to this change.
+*
+* The guide and the whole diff go in every time. The theme the reviewer is currently reading is
+* named rather than used to filter the diff: they routinely ask "does this interact with X",
+* where X is in another theme, and a prompt that had quietly dropped X would answer confidently
+* and wrongly.
+*/
+function buildPrompt(workspace, question, sectionId, cwd) {
+	const section = workspace.session.result?.sections.find((s) => s.id === sectionId);
+	const recent = workspace.transcript.slice(-4);
+	return [
+		SYSTEM_PROMPT,
+		"---",
+		`CHANGE: ${workspace.changeSet.headRef} compared against ${workspace.changeSet.baseRef}, in the checkout at ${cwd}`,
+		"---",
+		"REVIEW GUIDE (JSON):",
+		JSON.stringify(workspace.session.result),
+		"---",
+		"DIFF:",
+		workspace.diff,
+		...section ? ["---", `The reviewer is currently reading the "${section.title}" theme. Answer with that in view, but do not ignore the rest of the change if it bears on the question.`] : [],
+		...recent.length > 0 ? [
+			"---",
+			"EARLIER IN THIS CONVERSATION:",
+			recent.map((entry) => `Q: ${entry.question}\nA: ${entry.answer}`).join("\n\n")
+		] : [],
+		"---",
+		`QUESTION: ${question}`
+	].join("\n");
+}
+var FileOutsideRepositoryError = class extends Error {};
+/**
+* Resolve a path against the reviewed repository, refusing anything outside it.
+*
+* The token already gates every route. This is the second lock: a path escape would turn one
+* review's link into a read of anything the developer can read, which is a much larger failure
+* than an unauthorised look at a review.
+*/
+function resolveInRepository(repoPath, path) {
+	const root = resolve(repoPath);
+	const target = resolve(root, path);
+	const rel = relative(root, target);
+	if (rel.startsWith("..") || isAbsolute(rel)) throw new FileOutsideRepositoryError("That path is outside the repository.");
+	return target;
+}
+function readFileWindow(workspace, path, options = {}) {
+	const target = resolveInRepository(workspace.repoPath, path);
+	const all = readFileSync(target, "utf8").split("\n");
+	if (all.length > 0 && all[all.length - 1] === "") all.pop();
+	const totalLines = all.length;
+	const added = addedLinesFor(workspace, path);
+	let from = 1;
+	let to = Math.min(totalLines, 600);
+	if (options.line && !options.expand) {
+		from = Math.max(1, options.line - 12);
+		to = Math.min(totalLines, options.line + 12);
+	} else if (options.expand) to = Math.min(totalLines, 600);
+	return {
+		path,
+		totalLines,
+		from,
+		to,
+		lines: all.slice(from - 1, to),
+		addedLines: added.filter((n) => n >= from && n <= to),
+		truncated: to < totalLines
+	};
+}
+/**
+* Which lines of the *current* file this change added, from the patch we already hold.
+*
+* Read out of the stored change set rather than by running git again: the review describes one
+* specific state of the working tree, and a second `git diff` could answer about a different one.
+*/
+function addedLinesFor(workspace, path) {
+	const file = workspace.changeSet.data.files.find((entry) => entry.name === path);
+	if (!file?.patch) return [];
+	return addedLinesFromPatch(file.patch);
+}
+var HUNK = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+function addedLinesFromPatch(patch) {
+	const added = [];
+	let lineNumber = 0;
+	for (const line of patch.split("\n")) {
+		const hunk = HUNK.exec(line);
+		if (hunk) {
+			lineNumber = Number(hunk[1]);
+			continue;
+		}
+		if (lineNumber === 0) continue;
+		if (line.startsWith("+++")) continue;
+		if (line.startsWith("+")) {
+			added.push(lineNumber);
+			lineNumber += 1;
+		} else if (line.startsWith("-") || line.startsWith("\\")) {} else lineNumber += 1;
+	}
+	return added;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/editor.ts
+/**
+* How to hand a file back to the reviewer's real environment.
+*
+* A review tool is a navigation layer, not an IDE. The moment someone wants to actually change
+* code they should leave, and the value of this button is that leaving is one click rather than a
+* path copied out of a citation.
+*
+* `{path}` is substituted with the absolute path, `{line}` with a 1-based line number.
+*/
+var EDITOR_TEMPLATES = {
+	vscode: "vscode://file{path}:{line}",
+	"vscode-insiders": "vscode-insiders://file{path}:{line}",
+	cursor: "cursor://file{path}:{line}",
+	windsurf: "windsurf://file{path}:{line}",
+	zed: "zed://file{path}:{line}",
+	sublime: "subl://open?url=file://{path}&line={line}",
+	intellij: "idea://open?file={path}&line={line}"
+};
+var DEFAULT_EDITOR = "vscode";
+var LABELS = {
+	vscode: "VS Code",
+	"vscode-insiders": "VS Code Insiders",
+	cursor: "Cursor",
+	windsurf: "Windsurf",
+	zed: "Zed",
+	sublime: "Sublime Text",
+	intellij: "IntelliJ"
+};
+/**
+* Read the configured editor. There is no way to detect one from a browser, so this is asked
+* rather than guessed: a button that opens the wrong application is worse than one that says
+* plainly which application it opens.
+*/
+function editorChoice() {
+	const configured = readConfiguredEditor();
+	if (configured?.includes("{path}")) return {
+		label: "editor",
+		template: configured
+	};
+	const key = configured && EDITOR_TEMPLATES[configured] ? configured : DEFAULT_EDITOR;
+	return {
+		label: LABELS[key] ?? key,
+		template: EDITOR_TEMPLATES[key]
+	};
+}
+function readConfiguredEditor() {
+	if (process.env.PRB_EDITOR) return process.env.PRB_EDITOR;
+	try {
+		const config = JSON.parse(readFileSync(join(STORE_ROOT, "config.json"), "utf8"));
+		return typeof config.editor === "string" && config.editor ? config.editor : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/preferences.ts
+/**
+* Workspace preferences that belong to the reviewer rather than to a review.
+*
+* Kept server-side, in their own file, for two reasons. `localStorage` is keyed by origin, and
+* this server takes whatever port the OS offers on each start — so a restart would silently
+* discard a width the reviewer had deliberately chosen, which is the one failure a preference
+* must not have. And `config.json` next door is hand-edited: writing to a file someone maintains
+* by hand reformats it under them the first time they save.
+*
+* Everything here is best-effort. A workspace that will not open because a preferences file is
+* unreadable would be a preference costing more than it is worth.
+*/
+var PREFERENCES_PATH = join(STORE_ROOT, "ui.json");
+var MAX_ASK_WIDTH = 1200;
+function readPreferences() {
+	try {
+		const parsed = JSON.parse(readFileSync(PREFERENCES_PATH, "utf8"));
+		if (!parsed || typeof parsed !== "object") return {};
+		const askWidth = parsed.askWidth;
+		return typeof askWidth === "number" && Number.isFinite(askWidth) ? { askWidth: clampAskWidth(askWidth) } : {};
+	} catch {
+		return {};
+	}
+}
+function writeAskWidth(width) {
+	if (!Number.isFinite(width)) return;
+	try {
+		mkdirSync(STORE_ROOT, { recursive: true });
+		const next = {
+			...readPreferences(),
+			askWidth: clampAskWidth(width)
+		};
+		writeFileSync(PREFERENCES_PATH, `${JSON.stringify(next, null, 2)}\n`);
+	} catch {}
+}
+/** Forget a stated width, so the stylesheet's proportional default applies again. */
+function clearAskWidth() {
+	try {
+		const { askWidth: _dropped, ...rest } = readPreferences();
+		mkdirSync(STORE_ROOT, { recursive: true });
+		writeFileSync(PREFERENCES_PATH, `${JSON.stringify(rest, null, 2)}\n`);
+	} catch {}
+}
+/**
+* Absolute bounds only. The upper limit the reviewer actually feels is half the viewport, which
+* the page enforces because it is the only party that knows how wide the window is — this is the
+* far cruder job of keeping a hand-edited or stale number from producing an unusable layout.
+*/
+function clampAskWidth(width) {
+	return Math.round(Math.min(MAX_ASK_WIDTH, Math.max(320, width)));
+}
+/** Long enough for a paragraph of standing instructions, short enough not to crowd the question. */
+var MAX_PROMPT_CHARS = 2e3;
+/**
+* Everything reaching this function came from a client, so nothing here is trusted.
+*
+* Entries are repaired where the repair is unambiguous — trimming, truncating — and dropped where
+* it is not. An entry with no name has nothing to show on a chip; an entry with no prompt has
+* nothing to insert. Neither is worth rejecting the whole bank over: the reviewer would lose
+* everything they had saved to one bad row.
+*/
+function sanitisePromptBank(value) {
+	if (!Array.isArray(value)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const clean = [];
+	for (const entry of value) {
+		if (!entry || typeof entry !== "object") continue;
+		const { id, name, prompt } = entry;
+		if (typeof id !== "string" || typeof name !== "string" || typeof prompt !== "string") continue;
+		const trimmed = {
+			id: id.trim(),
+			name: name.trim().slice(0, 60),
+			prompt: prompt.trim().slice(0, MAX_PROMPT_CHARS)
+		};
+		if (!trimmed.id || !trimmed.name || !trimmed.prompt) continue;
+		if (seen.has(trimmed.id)) continue;
+		seen.add(trimmed.id);
+		clean.push(trimmed);
+		if (clean.length === 50) break;
+	}
+	return clean;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/prompt_bank.ts
+/**
+* The reviewer's own prompts, kept on disk.
+*
+* Saved next to the workspaces rather than inside one: a prompt belongs to the person, not to the
+* review they happened to think of it during. The rules for what counts as a saved prompt live in
+* `domain/ai_review/prompt_bank` and are shared with the extension — this file is only the storage.
+*
+* Best-effort throughout, exactly as `preferences.ts` is. A bank that cannot be read must never be
+* a workspace that will not open.
+*/
+var PROMPTS_PATH = join(STORE_ROOT, "prompts.json");
+function readPromptBank() {
+	try {
+		return sanitisePromptBank(JSON.parse(readFileSync(PROMPTS_PATH, "utf8")));
+	} catch {
+		return [];
+	}
+}
+/** Returns the bank as stored, which is not always the bank that was passed in. */
+function writePromptBank(bank) {
+	const clean = sanitisePromptBank(bank);
+	try {
+		mkdirSync(STORE_ROOT, { recursive: true });
+		writeFileSync(PROMPTS_PATH, `${JSON.stringify(clean, null, 2)}\n`, { mode: 384 });
+	} catch {}
+	return clean;
+}
+//#endregion
+//#region ../../packages/review-harness/src/telemetry/rollup.ts
+/**
+* Close out a workspace session by summarising its own events.
+*
+* Every number is read back out of the log rather than tracked alongside it. A rollup that keeps
+* its own counters can drift from the events it claims to summarise, and the resulting number
+* looks exactly as authoritative as a correct one — the same failure the review engine avoids by
+* counting what the model produced instead of letting it report its own coverage.
+*/
+function recordReviewCompleted(reviewId) {
+	const events = readEvents(reviewId);
+	if (events.length === 0) return;
+	if (events.some((event) => event.event === "review_completed")) return;
+	const opened = events.find((event) => event.event === "workspace_opened");
+	const themesTotal = opened?.event === "workspace_opened" ? opened.themes : 0;
+	record({
+		event: "review_completed",
+		reviewId,
+		activeSeconds: sum(events, "workspace_heartbeat", (event) => event.event === "workspace_heartbeat" ? event.visibleSeconds : 0),
+		themesOpened: distinct(events, (event) => event.event === "theme_opened" ? event.themeIndex : null),
+		themesTotal,
+		viewsOpened: distinct(events, (event) => event.event === "view_opened" ? event.view : null),
+		filesOpened: events.filter((event) => event.event === "file_opened").length,
+		editorOpened: events.some((event) => event.event === "editor_opened"),
+		questionsAsked: events.filter((event) => event.event === "assistant_question_asked").length,
+		assistantUsed: events.some((event) => event.event === "assistant_answered" && event.ok)
+	});
+}
+function sum(events, name, value) {
+	return events.filter((event) => event.event === name).reduce((total, event) => total + value(event), 0);
+}
+function distinct(events, pick) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		const value = pick(event);
+		if (value !== null) seen.add(value);
+	}
+	return seen.size;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/http.ts
+/**
+* Where the page's assets live, in each of the two layouts this file actually runs in.
+*
+* Bundled, it is `dist/server.js`, so the assets are one level up. In the source tree under
+* vitest, it is `src/workspace/http.ts`, so they are two. Both candidates are real, neither is a
+* guess, and resolving both is what lets the tests exercise the same code path the product uses —
+* the previous single-candidate version silently resolved to a directory that has never existed
+* (`src/static`), which is why nothing ever noticed that asset serving was untested.
+*/
+var STATIC_DIR = ["../static", "../../static"].map((candidate) => fileURLToPath(new URL(candidate, import.meta.url))).find(existsSync) ?? fileURLToPath(new URL("../static", import.meta.url));
+/**
+* The page's own assets, read into memory when the server starts.
+*
+* They used to be read from disk on each request, which quietly made a running workspace depend on
+* its own installation directory still being there. That is not a safe assumption for this
+* process: it is detached so a review outlives the session, so it equally outlives whatever
+* temporary directory a plugin archive was unpacked into to launch it. When that directory goes,
+* every asset starts 404ing while the pages keep rendering perfectly — the HTML is built from code
+* already in memory. The result looks exactly like broken CSS and points nowhere near the cause.
+*
+* A quarter of a megabyte, read once. Anything detached should carry what it needs.
+*/
+var ASSETS = loadAssets();
+function loadAssets() {
+	const assets = /* @__PURE__ */ new Map();
+	try {
+		for (const name of readdirSync(STATIC_DIR)) try {
+			assets.set(name, readFileSync(join(STATIC_DIR, name)));
+		} catch {}
+	} catch {}
+	return assets;
+}
+var CONTENT_TYPES = {
+	".css": "text/css; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".woff2": "font/woff2",
+	".png": "image/png"
+};
+function createWorkspaceServer(options = {}) {
+	return createServer((req, res) => {
+		handle(req, res, options).catch((error) => {
+			send(res, 500, { error: error instanceof Error ? error.message : "Unknown error" });
+		});
+	});
+}
+async function handle(req, res, options) {
+	const url = new URL(req.url ?? "/", "http://127.0.0.1");
+	if (url.pathname === "/health") return send(res, 200, {
+		ok: true,
+		version: BUILD_VERSION,
+		assets: ASSETS.size
+	});
+	if (url.pathname.startsWith("/assets/")) return sendAsset(res, url.pathname);
+	if (url.pathname === "/") return sendReviewsIndex(req, res, url.searchParams.get("t"), options.indexToken);
+	if (url.pathname === "/pin") return handlePin(req, res, options.indexToken);
+	const match = /^\/(?:r|api)\/([0-9a-f-]{36})(\/[a-z]+)?$/.exec(url.pathname);
+	if (!match) return send(res, 404, { error: "Not found" });
+	const [, id, action] = match;
+	const workspace = loadWorkspace(id);
+	if (!workspace) return send(res, 404, { error: "No such review" });
+	if (!tokenMatches(workspace, url.searchParams.get("t"))) return send(res, 403, { error: "This link is missing its access token." });
+	if (url.pathname.startsWith("/r/")) {
+		touchWorkspace(workspace);
+		return sendHtml(res, workspace);
+	}
+	if (action === "/job") return send(res, 200, jobStatus(workspace.jobId ? loadJob(workspace.jobId) : null));
+	if (action === "/retry") return handleRetry(res, workspace);
+	if (action === "/freshness") return handleFreshness(res, workspace);
+	if (action === "/refresh") return handleRefreshPr(res, workspace);
+	if (action === "/update") return handleUpdate(res, workspace);
+	if (action === "/review") return send(res, 200, workspace.session.result ?? {});
+	if (action === "/file") return sendFile(res, workspace, url.searchParams);
+	if (action === "/ask") return handleAsk(req, res, workspace);
+	if (action === "/state") return handleState(req, res, workspace);
+	if (action === "/event") return handleEvent(req, res, workspace);
+	if (action === "/prefs") return handlePrefs(req, res);
+	if (action === "/prompts") return handlePrompts(req, res);
+	if (action === "/shutdown") return handleShutdown(res, options);
+	return send(res, 404, { error: "Not found" });
+}
+/**
+* Constant-time, and length-checked first.
+*
+* `timingSafeEqual` throws on a length mismatch rather than returning false, so an unequal-length
+* token would surface as a 500 instead of a refusal.
+*/
+function tokenMatches(workspace, supplied) {
+	return secretMatches(workspace.token, supplied);
+}
+function secretMatches(expected, supplied) {
+	if (!supplied) return false;
+	const a = Buffer.from(expected);
+	const b = Buffer.from(supplied);
+	return a.length === b.length && timingSafeEqual(a, b);
+}
+/**
+* The list of every stored review, with a working link into each.
+*
+* Its own credential, not any review's. This page is the one place that holds all the per-review
+* tokens, so authorising it with one of them would make that review's token a key to the rest —
+* and a workspace page never receives this one, so it stays a key only to itself.
+*
+* The refusal names the command that produces a working link rather than saying "forbidden": the
+* likely reader is the owner of the machine arriving from a bookmark whose token is from a server
+* that has since restarted, and they need the way back, not a verdict.
+*/
+function sendReviewsIndex(req, res, supplied, indexToken) {
+	if (!indexToken || !(secretMatches(indexToken, supplied) || secretMatches(indexToken, indexCookie(req)))) return send(res, 403, { error: "This link is missing its access token. Run /prreviewbuddy:start-server to get the current one." });
+	const html = renderReviewsPage({ groups: recentReviewGroups(MAX_LISTED_BRANCHES) });
+	res.writeHead(200, {
+		"content-type": "text/html; charset=utf-8",
+		"set-cookie": `${INDEX_COOKIE}=${indexToken}; Path=/; HttpOnly; SameSite=Strict`
+	});
+	res.end(html);
+}
+/**
+* Pin or unpin a review.
+*
+* Authorised by the index credential rather than the review's own, because pinning is a fact about
+* the list and the caller is the list. It reaches this route as the cookie: the index page holds
+* no token in its markup, which is the point of the cookie in the first place.
+*/
+async function handlePin(req, res, indexToken) {
+	if (!indexToken || !secretMatches(indexToken, indexCookie(req))) return send(res, 403, { error: "Not authorised." });
+	const body = await readJson(req);
+	const id = typeof body?.id === "string" ? body.id : null;
+	const workspace = id ? loadWorkspace(id) : null;
+	if (!workspace) return send(res, 404, { error: "No such review" });
+	workspace.pinned = body?.pinned === true;
+	saveWorkspace(workspace);
+	send(res, 200, { ok: true });
+}
+var INDEX_COOKIE = "prb_index";
+/**
+* The reviews index, remembered by the browser that has already proved it may see it.
+*
+* A workspace needs a way back to `/`, and it cannot carry the index token — that was the whole
+* point of not building a switcher: a page holding a credential for every review is a master key,
+* and one that then lives in a URL, in history, and in whatever reads either.
+*
+* A cookie moves that credential out of the page entirely. It is set only when someone arrives at
+* the index with the real token, it is `HttpOnly` so no script can read it back out, and it is
+* `SameSite=Strict` so another origin cannot make the browser spend it. A browser that never had
+* the token gets a 403 from the link, which is correct: it was never shown the list.
+*/
+function indexCookie(req) {
+	const header = req.headers.cookie;
+	if (!header) return null;
+	for (const part of header.split(";")) {
+		const [name, ...rest] = part.trim().split("=");
+		if (name === INDEX_COOKIE) return rest.join("=");
+	}
+	return null;
+}
+/**
+* Enough to cover the reviews anyone still has in mind, and a bound on a page that is read by
+* scanning it. Older reviews are still on disk and still listed by the MCP tool.
+*/
+/** Branches, not reviews: a branch reviewed five times is one card and must not cost five slots. */
+var MAX_LISTED_BRANCHES = 50;
+async function sendHtml(res, workspace) {
+	const freshness = await freshnessOrNull(workspace);
+	const notice = workspace.lastUpdate?.acknowledged ? void 0 : workspace.lastUpdate;
+	if (notice) {
+		notice.acknowledged = true;
+		saveWorkspace(workspace);
+	}
+	const html = renderWorkspace({
+		session: workspace.session,
+		changeSet: workspace.changeSet,
+		audit: workspace.audit,
+		apiBase: `/api/${workspace.id}`,
+		token: workspace.token,
+		editor: editorChoice(),
+		repoPath: workspace.repoPath,
+		askWidth: readPreferences().askWidth,
+		transcript: workspace.transcript,
+		prompts: readPromptBank(),
+		complete: workspace.completedAt !== void 0,
+		prContext: workspace.prContext ? {
+			prContext: workspace.prContext,
+			processed: processDiscussion(workspace.prContext.discussion)
+		} : void 0,
+		freshness: freshness ?? void 0,
+		dismissedFreshnessSha: workspace.dismissedFreshnessSha,
+		lastPrRefresh: workspace.lastPrRefresh,
+		lastUpdate: notice,
+		lineage: lineagePosition(workspace),
+		job: workspace.jobId ? loadJob(workspace.jobId) : void 0
+	});
+	if (freshness) record({
+		event: "freshness_checked",
+		reviewId: workspace.id,
+		source: "page_load",
+		code: freshness.code.state,
+		checkout: freshness.checkout.state
+	});
+	res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+	res.end(html);
+}
+function sendAsset(res, pathname) {
+	const name = pathname.slice(8);
+	if (!/^[a-z0-9_-]+\.(css|js|woff2|png)$/i.test(name)) return send(res, 404, { error: "Not found" });
+	const body = ASSETS.get(name);
+	if (!body) return send(res, 404, { error: "Not found" });
+	const ext = name.slice(name.lastIndexOf("."));
+	res.writeHead(200, {
+		"content-type": CONTENT_TYPES[ext] ?? "application/octet-stream",
+		"cache-control": "no-cache"
+	});
+	res.end(body);
+}
+/**
+* A window onto a file from the reviewed repository.
+*
+* A window rather than the file, and JSON rather than text, because the caller is a review pane
+* showing why a file matters — not a code browser. Containment is enforced in file_view.ts.
+*/
+function sendFile(res, workspace, params) {
+	const path = params.get("path");
+	if (!path) return send(res, 400, { error: "No path given" });
+	const lineParam = Number(params.get("line"));
+	try {
+		send(res, 200, {
+			...readFileWindow(workspace, path, {
+				line: Number.isFinite(lineParam) && lineParam > 0 ? lineParam : void 0,
+				expand: params.get("expand") === "1"
+			}),
+			pullRequest: buildPrFileLink(workspace.prContext, path) ?? void 0
+		});
+	} catch (error) {
+		if (error instanceof FileOutsideRepositoryError) return send(res, 403, { error: error.message });
+		send(res, 404, { error: "That file is not in the working tree. This change may have deleted it." });
+	}
+}
+/**
+* The three comparisons, on demand.
+*
+* Separate from the page render so a tab that has been open for an hour can ask again without
+* losing its place — which is the case the button exists for. Read-only and cheap: four git
+* plumbing commands against the local object store, no network anywhere in it.
+*/
+async function handleFreshness(res, workspace) {
+	const report = await freshnessOrNull(workspace);
+	if (!report) return send(res, 200, { report: null });
+	record({
+		event: "freshness_checked",
+		reviewId: workspace.id,
+		source: "button",
+		code: report.code.state,
+		checkout: report.checkout.state
+	});
+	send(res, 200, {
+		report,
+		dismissedSha: workspace.dismissedFreshnessSha ?? null
+	});
+}
+/**
+* Re-read the pull request conversation, at the reviewer's request.
+*
+* Answers 200 with `ok: false` rather than an error status when it does not work. The page's job
+* here is to tell the reviewer what happened in a sentence, and a failed re-read is an outcome —
+* the conversation on disk is untouched and the review is exactly as usable as it was a moment
+* ago. An HTTP error would make the page choose between a stack trace and silence.
+*/
+async function handleRefreshPr(res, workspace) {
+	let outcome;
+	try {
+		outcome = await refreshPrContext(workspace);
+	} catch {
+		outcome = {
+			at: Date.now(),
+			ok: false,
+			message: "The pull request could not be re-read. Nothing here has changed."
+		};
+	}
+	workspace.lastPrRefresh = outcome;
+	saveWorkspace(workspace);
+	record({
+		event: "pr_conversation_rechecked",
+		reviewId: workspace.id,
+		ok: outcome.ok,
+		changed: outcome.changes ? !isUnchanged(outcome.changes) : false,
+		attributionsRestated: outcome.attributionsRestated ?? 0,
+		attributionsWithdrawn: outcome.attributionsWithdrawn ?? 0
+	});
+	send(res, 200, outcome);
+}
+/**
+* Bring the whole review up to date with the checkout, at the reviewer's request.
+*
+* Answers 200 with `ok: false` when it refuses or fails, for the reason the conversation re-read
+* does: a refusal is an outcome the page has to explain in a sentence, and the review is exactly
+* as usable as it was a moment ago. An HTTP error would make the page choose between a stack trace
+* and silence.
+*
+* The only place this reaches disk. `updateReview` computes and mutates in memory, so a failure
+* before this line leaves the stored review untouched, and the snapshot it takes of the result it
+* replaced is written in this same save.
+*/
+async function handleUpdate(res, workspace) {
+	let outcome;
+	try {
+		outcome = await updateReview(workspace);
+	} catch (error) {
+		outcome = {
+			at: Date.now(),
+			ok: false,
+			message: error instanceof RefreshUnavailableError ? error.message : "This review could not be brought up to date. Nothing here has changed.",
+			stop: "analysis-failed",
+			fetchFailed: false,
+			moved: false,
+			fromSha: null,
+			toSha: null
+		};
+	}
+	workspace.lastUpdate = outcome;
+	saveWorkspace(workspace);
+	record({
+		event: "review_updated",
+		reviewId: workspace.id,
+		ok: outcome.ok,
+		stop: outcome.stop,
+		moved: outcome.moved,
+		resolved: outcome.counts?.resolved ?? 0,
+		stillOpen: outcome.counts?.stillOpen ?? 0,
+		affected: outcome.counts?.affected ?? 0,
+		newIssues: outcome.counts?.newIssues ?? 0,
+		questionsAnswered: outcome.counts?.questionsAnswered ?? 0
+	});
+	send(res, 200, outcome);
+}
+/**
+* Resume a job that stopped, rather than start one over.
+*
+* Fires and returns at once, exactly as starting a job does: `runJob` can take minutes, and this
+* route answers a button click, not a session that is waiting for the review. `runJob` records
+* every outcome, success or failure, on the job itself before it resolves or rejects, so there is
+* nothing left worth doing with a rejection here except not letting it become an unhandled one.
+*
+* Refused up front when the job is not terminal, rather than left to `runJob`'s own guard: a job
+* that is still running has nothing here worth retrying, and saying so is cheaper and clearer than
+* a 200 that quietly does nothing.
+*
+* Refused again when a driver still holds the claim, which is not the same question. A job can be
+* terminal and driven at once: the sweep marks a job failed after half an hour of silence, and a
+* long analysis that streams nothing is silent while being perfectly alive. Without this line that
+* job is retryable, and pressing Retry starts a second driver against the worktree the first one is
+* still using. `runJob` refuses it too, but only after this route has already answered 200 and told
+* the reviewer their retry began.
+*/
+async function handleRetry(res, workspace) {
+	if (!workspace.jobId) return send(res, 404, { error: "No job for this review." });
+	const job = loadJob(workspace.jobId);
+	if (!job || !isTerminal(job) || isClaimed(job.id)) return send(res, 409, { error: "This review is still being made. Wait for it to finish before retrying." });
+	runJob(workspace.id).catch(() => {});
+	send(res, 200, { ok: true });
+}
+/**
+* Never throws.
+*
+* The checkout may have been deleted, moved, or turned into something that is not a repository
+* since the review was made — all of which are ordinary, and none of which is a reason to refuse
+* to serve a review that is sitting complete on disk. The page renders without the banner, which
+* reads as "not checked" rather than as "nothing has changed".
+*/
+async function freshnessOrNull(workspace) {
+	try {
+		return await checkFreshness(workspace);
+	} catch {
+		return null;
+	}
+}
+async function handleAsk(req, res, workspace) {
+	const body = await readJson(req);
+	const question = typeof body?.question === "string" ? body.question.trim() : "";
+	if (!question) return send(res, 400, { error: "No question given." });
+	const sectionId = typeof body?.sectionId === "string" ? body.sectionId : null;
+	record({
+		event: "assistant_question_asked",
+		reviewId: workspace.id,
+		source: askSource(body?.source),
+		scoped: sectionId !== null,
+		turn: workspace.transcript.length + 1
+	});
+	const startedAt = Date.now();
+	let answer;
+	try {
+		answer = await askAboutChange(workspace, question, sectionId);
+	} catch (error) {
+		record({
+			event: "assistant_answered",
+			reviewId: workspace.id,
+			durationMs: Date.now() - startedAt,
+			ok: false
+		});
+		throw error;
+	}
+	record({
+		event: "assistant_answered",
+		reviewId: workspace.id,
+		durationMs: Date.now() - startedAt,
+		ok: true
+	});
+	workspace.transcript.push({
+		question,
+		answer,
+		sectionId,
+		askedAt: Date.now()
+	});
+	saveWorkspace(workspace);
+	send(res, 200, { answer });
+}
+/**
+* Stop serving, at the request of a workspace.
+*
+* The reply goes first and the exit follows on the next tick: a process that dies mid-response
+* leaves the page unable to tell "stopped" from "crashed", which are the two things the reviewer
+* most needs to distinguish here.
+*
+* One server serves every review, so this ends all of them. The page says so before asking.
+*/
+function handleShutdown(res, options) {
+	send(res, 200, { ok: true });
+	const stop = options.onShutdown ?? (() => process.exit(0));
+	setTimeout(stop, 50).unref();
+}
+/**
+* Reviewer preferences, which outlive any one review.
+*
+* Stored server-side rather than in the page's `localStorage` because that is keyed by origin and
+* this server takes a fresh port on every start — a restart would silently forget a width the
+* reviewer chose deliberately. A null width means "back to the stylesheet's default".
+*/
+/**
+* The reviewer's saved prompts.
+*
+* The page sends the whole bank rather than a delta, and gets back the bank as stored — which is
+* not necessarily the bank it sent. `writePromptBank` trims, truncates and drops, so returning
+* the result is what stops the page from showing an entry the file does not hold.
+*
+* Global state behind a per-review route, exactly as the assistant width already is. The token
+* that authorises it belongs to a review, but what it protects is the machine's user.
+*/
+async function handlePrompts(req, res) {
+	if (req.method !== "POST") return send(res, 200, { prompts: readPromptBank() });
+	send(res, 200, { prompts: writePromptBank((await readJson(req))?.prompts) });
+}
+async function handlePrefs(req, res) {
+	const askWidth = (await readJson(req))?.askWidth;
+	if (typeof askWidth === "number") writeAskWidth(askWidth);
+	else if (askWidth === null) clearAskWidth();
+	send(res, 200, { ok: true });
+}
+async function handleState(req, res, workspace) {
+	const body = await readJson(req);
+	let changed = false;
+	if (Array.isArray(body?.answeredQuestionIds)) {
+		workspace.session.answeredQuestionIds = body.answeredQuestionIds.filter((id) => typeof id === "string");
+		changed = true;
+	}
+	if (typeof body?.dismissFreshnessSha === "string" || body?.dismissFreshnessSha === null) {
+		workspace.dismissedFreshnessSha = body.dismissFreshnessSha ?? void 0;
+		changed = true;
+	}
+	if (typeof body?.complete === "boolean") {
+		workspace.completedAt = body.complete ? Date.now() : void 0;
+		changed = true;
+	}
+	if (changed) saveWorkspace(workspace);
+	send(res, 200, {
+		ok: true,
+		completedAt: workspace.completedAt ?? null
+	});
+}
+/** 1 MB is far more than any question or id list, and far less than a memory problem. */
+var MAX_BODY_BYTES = 1048576;
+async function readJson(req) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		size += chunk.length;
+		if (size > MAX_BODY_BYTES) throw new Error("Request body too large.");
+		chunks.push(chunk);
+	}
+	try {
+		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	} catch {
+		return null;
+	}
+}
+function send(res, status, payload) {
+	res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+	res.end(JSON.stringify(payload));
+}
+var ASK_SOURCES = [
+	"suggestion",
+	"free_text",
+	"explain_simply",
+	"selection"
+];
+function askSource(value) {
+	return ASK_SOURCES.includes(value) ? value : "free_text";
+}
+/**
+* Usage events from the page.
+*
+* Rebuilt field by field from a fixed list rather than forwarded, so the log holds only what this
+* file constructs. A page could otherwise post anything into the record — and the point of the
+* event union is that there is nowhere for a path, a title or a question to end up.
+*/
+async function handleEvent(req, res, workspace) {
+	const body = await readJson(req);
+	const event = toEvent(body, workspace.id);
+	if (event) record(event);
+	if (body?.event === "review_completed") {
+		const trailing = toEvent({
+			event: "workspace_heartbeat",
+			visibleSeconds: body.trailingSeconds
+		}, workspace.id);
+		if (trailing && trailing.visibleSeconds > 0) record(trailing);
+		recordReviewCompleted(workspace.id);
+	}
+	send(res, 200, { ok: true });
+}
+var VIEWS = [
+	"overview",
+	"guide",
+	"issues",
+	"questions",
+	"files",
+	"prcontext"
+];
+var ATTENTIONS = [
+	"high",
+	"medium",
+	"low"
+];
+function toEvent(body, reviewId) {
+	const int = (value) => Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+	switch (body?.event) {
+		case "view_opened": {
+			const view = VIEWS.find((candidate) => candidate === body.view);
+			return view ? {
+				event: "view_opened",
+				reviewId,
+				view
+			} : null;
+		}
+		case "theme_opened": {
+			const attention = ATTENTIONS.find((candidate) => candidate === body.attention);
+			return attention ? {
+				event: "theme_opened",
+				reviewId,
+				themeIndex: int(body.themeIndex),
+				attention,
+				isRecommendedStart: body.isRecommendedStart === true
+			} : null;
+		}
+		case "file_opened": return {
+			event: "file_opened",
+			reviewId,
+			fromFinding: body.fromFinding === true,
+			targeted: body.targeted === true
+		};
+		case "editor_opened": return {
+			event: "editor_opened",
+			reviewId,
+			fromFinding: body.fromFinding === true
+		};
+		case "question_marked_answered": return {
+			event: "question_marked_answered",
+			reviewId,
+			answered: int(body.answered),
+			total: int(body.total)
+		};
+		case "workspace_heartbeat": return {
+			event: "workspace_heartbeat",
+			reviewId,
+			visibleSeconds: Math.min(int(body.visibleSeconds), 120)
+		};
+		default: return null;
+	}
+}
+/**
+* The reviewer-facing half of that. A job whose driver was killed did not fail: it stopped
+* updating, which the page had no way to tell from working. This is the sentence that makes the
+* difference visible, and marking the job failed is what puts Retry on the page.
+*/
+var ABANDONED_MESSAGE = "Nothing has updated it for over half an hour, so whatever was making it is no longer running.";
+async function sweep(now = Date.now()) {
+	const report = {
+		abandoned: 0,
+		retired: 0,
+		orphansRemoved: 0,
+		refusals: []
+	};
+	const jobs = allJobs();
+	for (const job of jobs) {
+		if (!isTerminal(job)) {
+			if (markAbandoned(job, now)) report.abandoned += 1;
+			continue;
+		}
+		if (now - finishedAt(job) < 216e5) continue;
+		if (await retire(job, report)) report.retired += 1;
+	}
+	await removeOrphans(jobs, report);
+	return report;
+}
+/** When this job stopped doing work. `finishedAt` predates nothing, but a record can be old. */
+function finishedAt(job) {
+	return job.finishedAt ?? job.updatedAt;
+}
+/**
+* Record that a job stopped, unless it has moved since this pass read it.
+*
+* The reload is the whole of the safety here. Between `allJobs` and this line a driver in another
+* process can have written a progress line, and saving a failure over that would take a review
+* that is being made and tell its reviewer it stopped.
+*/
+function markAbandoned(job, now) {
+	if (now - job.updatedAt < 18e5) return false;
+	if (isClaimed(job.id, now)) return false;
+	const current = loadJob(job.id);
+	if (!current || current.updatedAt !== job.updatedAt) return false;
+	saveJob(fail(current, ABANDONED_MESSAGE));
+	return true;
+}
+/**
+* Remove a finished job's checkout, and then its record.
+*
+* In that order, and the record only if the directory went. The record is the only thing that
+* names the directory; deleting it first would turn a refusal into an orphan and lose the origin
+* repository that the removal guard needs to ask git about it.
+*/
+async function retire(job, report) {
+	if (job.worktreePath) {
+		const outcome = await removeWorktree({
+			originRepoPath: job.target.originRepoPath,
+			worktreePath: job.worktreePath
+		});
+		if (!outcome.removed) {
+			report.refusals.push(outcome.message);
+			return false;
+		}
+	}
+	deleteJob(job.id);
+	clearClaim(job.id);
+	return true;
+}
+/**
+* Directories under the managed root that no job record names.
+*
+* A crash between creating a worktree and saving the record that points at it leaves exactly this.
+* The origin repository comes from the directory's own marker, because there is nothing else left
+* to ask, and that does make `removeWorktree`'s marker check tautological on this path. It is not
+* the guard here and was never meant to be: git is asked first and answers about a real repository,
+* and where git has disowned the path what remains is the managed root and `ORPHAN_MIN_AGE_MS`,
+* which is the ordering the removal guard has always had.
+*/
+async function removeOrphans(jobs, report) {
+	const claimed = new Set(jobs.map((job) => job.worktreePath).filter((path) => !!path));
+	let names;
+	try {
+		names = readdirSync(MANAGED_ROOT);
+	} catch {
+		return;
+	}
+	for (const name of names) {
+		const path = join(MANAGED_ROOT, name);
+		if (claimed.has(path)) continue;
+		try {
+			if (!statSync(path).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const marker = readMarker(path);
+		if (!marker) continue;
+		const outcome = await removeWorktree({
+			originRepoPath: marker.originRepoPath,
+			worktreePath: path
+		});
+		if (outcome.removed) report.orphansRemoved += 1;
+		else if (outcome.reason !== "too-young") report.refusals.push(outcome.message);
+	}
+}
+/**
+* How often the pass runs.
+*
+* Chosen from what it costs to be late rather than what it costs to run. A sweep is a directory
+* listing and a `git worktree list` per finished job, so ten minutes is nothing; being an hour
+* late telling a reviewer their review stopped is not. Ten minutes puts that answer between thirty
+* and forty minutes after the last sign of life.
+*/
+var SWEEP_INTERVAL_MS = 6e5;
+/**
+* Run the pass on a timer, and return the stop.
+*
+* Once immediately, because a server that has just started is very often one that restarted after
+* whatever killed the last one, and the jobs that died with it are exactly what this finds.
+*
+* Nothing here throws outward. A sweep that fails is disk it did not reclaim, and the server it
+* runs inside is serving reviews, which matters more.
+*/
+function startSweeping() {
+	const run = () => {
+		sweep().catch(() => {});
+	};
+	run();
+	const timer = setInterval(run, SWEEP_INTERVAL_MS);
+	timer.unref();
+	return () => clearInterval(timer);
+}
+//#endregion
+//#region ../../packages/review-harness/src/cli/server.ts
+/**
+* The workspace server process.
+*
+* Started detached by `ensureServer` and left running, so a workspace stays usable after the
+* Claude Code session that produced it has closed. One server serves every review; individual
+* reviews are addressed by id and gated by their own token.
+*/
+var indexToken = randomBytes(24).toString("base64url");
+var server = createWorkspaceServer({
+	indexToken,
+	onShutdown: () => process.kill(process.pid, "SIGTERM")
+});
+server.listen(0, "127.0.0.1", () => {
+	const address = server.address();
+	if (address === null || typeof address === "string") process.exit(1);
+	writeServerRecord({
+		pid: process.pid,
+		port: address.port,
+		startedAt: Date.now(),
+		token: indexToken
+	});
+});
+var stopSweeping = startSweeping();
+for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => {
+	stopSweeping();
+	clearServerRecord();
+	server.close(() => process.exit(0));
+});
+//#endregion
+export {};