prreviewbuddy 0.64.2 → 0.70.2

package/dist/server.js

@@ -1,7 +1,9 @@
-import { $ as storedScopes, $n as loadWorkspace, A as reanalyseReview, An as endedAt, Ar as issuesOutstanding, At as renderMarkdown, Br as isCommitReview, Bt as createWorktree, C as track, Cn as remoteHost, Cr as queueAddMany, Ct as unreadCount$1, D as endRun, Dn as followedBranch, Dr as doneVerb, Dt as authorPreview, E as completeRun, En as checkReview, Er as readQueue, Et as UNESTABLISHED_MOTIVATION, F as record, Fr as describeAuthorship, Ft as asString, G as describeRuntimes, Gn as groupByLineage, Gr as readAgentPreference, Gt as requestJobStop, H as mapRuntimes, Hn as isClaimed, Ht as isWorktreeHeld, In as isLiveJob, Ir as WITHHELD_REASON, It as extractJsonText, J as loadArchitecture, Jn as kissDecisionRefusal, Jr as STORE_ROOT, Jt as activateQueued, K as ARCHITECTURE_DIR, Kn as indexKeptIds, Kr as writeAgentPreference, Ln as phasesFor, Lr as kissOutcome, Lt as objectWithAnyOf, Mn as isTerminal, Mr as reviewerDispositions, Mt as CODE_COPY_CLASS, Nn as loadJob, Nr as processDiscussion, Nt as escapeHtml$1, O as reportRun, On as reviewedShaOf, Or as isIssueOutstanding, Ot as hasAuthorContent, P as readEvents, Pn as saveJob, Pr as recommendationsOf, Pt as renderInlineText, Q as storeArchitecture, Qn as lineagePosition, Qr as agentFor, Qt as readIndexToken, R as recordTelemetryUploadConsent, Rn as progressSteps, Rt as ReviewBeingDeletedError, S as isDriving, Sn as forgeFor, Sr as queueAdd, St as toneOf, T as beginRun, Tn as checkCodeFreshness, Tr as queueStamp, Tt as EXPLAIN_SIMPLY_PROMPT, U as recordRuntimeBestEffort, Un as decideKissRecommendation, Ur as resolveModel, Ut as readMarker, V as waitingHistory, Vr as git, Vt as holdWorktree, W as RUNTIME_WORDS, Wn as followedRefName, Wr as clearAgentPreference, Wt as removeWorktree, X as readArchitecture, Xn as latestKissRun, Y as partFiles, Yn as kissDecisionsOf, Yr as AGENT_IDS, Yt as compactQueue, Z as repositoryKey, Zt as settleQueue, _ as liveUpdateFor, _n as resolveWorkspacePort, _r as lifecycleItemLabel, _t as markRead, a as wasBlocked, an as spawnServer, ar as recentWorkspaces, at as isArchitectureId, bn as claimRequestUrl, br as parseLifecycle, bt as readNotification, c as RefreshUnavailableError, ct as branchOf, d as mergeUpdateInto, dr as workspaceStamps, dt as createPrState, ei as AgentCancelledError, en as clearServerRecordOwnedBy, et as trackedFiles, f as updateReview, fn as feedbackUrl, fr as LIFECYCLES, ft as createPrUpdate, g as UpdateAlreadyRunningError, gn as parseWorkspacePort, gr as lifecycleChip, gt as markAllRead, h as askCheckout, hn as MIN_WORKSPACE_PORT, hr as isLifecycle, ht as listNotifications, i as liveJobsFor, in as serverEntryExists, ir as previousKissResult, it as ancestorsOf, j as runJob, jn as fail, jr as questionsOutstanding, jt as CODE_BLOCK_CLASS, k as stopRun, kn as allJobs, kr as isQuestionOutstanding, kt as GITHUB_MARKDOWN, l as cancelUpdate, ln as writeServerRecord, lr as touchWorkspace, lt as subjectOf, m as isUnchanged, mn as MAX_WORKSPACE_PORT, mr as activityLabel, mt as headline, n as deleteReview, nn as readServerRecord, nt as QUOTE_LIMITS, o as discardJob, on as stopChild, or as reviewedCommit, ot as writeJsonAtomically, p as refreshPrContext, pn as DEFAULT_WORKSPACE_PORT, pr as activityAttributes, pt as eventName, q as checkArchitecture, qn as indexReviewGroups, qt as relativeTime$1, r as lineageIds, rr as presentedKissRunOf, rt as REPOSITORY_SCOPE, s as FETCH_TIMEOUT_MS, st as announceJob, t as deleteLineage, ti as AgentUnavailableError, tr as mutateWorkspace, tt as ownersOf, u as cancellableHere, un as BUILD_VERSION, ur as workspaceRevision, ut as createArchitectureNotification, vn as statedWorkspacePort, vr as lifecyclePill, vt as markReadForReview, w as RUN_KINDS, wn as fillFileUrlTemplate, wr as queueRemove, wt as withUsageRecorded, x as startKissJob, xr as sectionOf, xt as removeNotification, y as agentEnvOf, yn as writePortPreference, yr as offersLifecycle, yt as pruneNotifications, z as telemetryUploadConsent, zn as purposeOf, zt as MANAGED_ROOT } from "./delete_review-l4p_p6oh.js";
+import { $ as MAX_WORKSPACE_PORT, $n as isClaimed, $r as resolveAgent, $t as markReadForReview, A as relativeTime$1, An as isWorktreeHeld, Ar as parseLifecycle, At as partFiles, B as readIndexToken, Bn as reviewedShaOf, Br as issuesOutstanding, Bt as isArchitectureId, C as track, Cn as originRemote, Cr as activityAttributes, Ct as mapRuntimes, D as endRun, Dn as MANAGED_ROOT, Dr as lifecycleItemLabel, Dt as ARCHITECTURE_DIR, E as completeRun, En as ReviewBeingDeletedError, Er as lifecycleChip, Et as describeRuntimes, F as runBatch, Fr as queueStamp, Ft as trackedFiles, Gn as loadJob, Gr as describeAuthorship, Gt as createArchitectureNotification, H as clearServerRecordOwnedBy, Hn as endedAt, Hr as reviewerDispositions, Ht as announceJob, I as activateQueued, In as findExistingReview, Ir as readQueue, It as ownersOf, J as stopChild, Jn as isLiveJob, Jr as resolveTarget, Jt as eventName, K as serverEntryExists, Kn as saveJob, Kr as WITHHELD_REASON, Kt as createPrState, L as compactQueue, Ln as checkCodeFreshness, Lr as doneVerb, Lt as QUOTE_LIMITS, M as extractPullRequestLinks, Mn as removeWorktree, Mr as queueAdd, Mt as repositoryKey, N as parsePullRequestLink, Nn as requestJobStop, Nr as queueAddMany, Nt as storeArchitecture, O as reportRun, On as createWorktree, Or as lifecyclePill, Ot as checkArchitecture, P as unsupportedReason, Pr as queueRemove, Pt as storedScopes, Q as DEFAULT_WORKSPACE_PORT, Qr as git, Qt as markRead, Rn as checkReview, Rr as isIssueOutstanding, Rt as REPOSITORY_SCOPE, S as isDriving, Sn as remoteHost, Sr as LIFECYCLES, St as waitingHistory, T as beginRun, Tr as isLifecycle, Tt as RUNTIME_WORDS, Un as fail, Ur as processDiscussion, Ut as branchOf, Vn as allJobs, Vr as questionsOutstanding, Vt as writeJsonAtomically, W as readServerRecord, Wn as isTerminal, Wr as recommendationsOf, Wt as subjectOf, Xn as progressSteps, Xr as isCommitReview, Xt as listNotifications, Yn as phasesFor, Yr as DetachedHeadError, Yt as headline, Z as writeServerRecord, Zn as purposeOf, Zr as resolveBase, Zt as markAllRead, _ as liveUpdateFor, _n as extractJsonText, _t as telemetryUploadConsent, a as wasBlocked, ai as STORE_ROOT, an as withUsageRecorded, ar as kissDecisionRefusal, at as failureOf$1, bn as forgeResolver, br as workspaceRevision, c as RefreshUnavailableError, ci as agentFor$1, cn as authorPreview, cr as lineagePosition, ct as reanalyseReview, d as mergeUpdateInto, di as AgentUnavailableError, dn as renderMarkdown, dr as mutateWorkspace, ei as resolveModel, en as pruneNotifications, er as decideKissRecommendation, et as MIN_WORKSPACE_PORT, f as updateReview, fn as CODE_BLOCK_CLASS, ft as readEvents, g as UpdateAlreadyRunningError, gn as asString, gr as reviewedCommit, gt as recordTelemetryUploadConsent, h as askCheckout, hn as renderInlineText, hr as recentWorkspaces, i as liveJobsFor, in as unreadCount$1, ir as indexReviewGroups, it as writePortPreference, j as batchIdentity, jn as readMarker, jr as sectionOf, jt as readArchitecture, k as stopRun, kn as holdWorktree, kr as offersLifecycle, kt as loadArchitecture, l as cancelUpdate, li as detectAgents, ln as hasAuthorContent, lr as loadWorkspace, lt as runJob, m as isUnchanged, mn as escapeHtml$1, mr as previousKissResult, n as deleteReview, ni as readAgentPreference, nn as removeNotification, nr as groupByLineage, nt as resolveWorkspacePort, o as discardJob, oi as AGENT_IDS, on as EXPLAIN_SIMPLY_PROMPT, or as kissDecisionsOf, ot as prepareReview, p as refreshPrContext, pn as CODE_COPY_CLASS, pr as presentedKissRunOf, pt as record, q as spawnServer, qr as kissOutcome, qt as createPrUpdate, r as lineageIds, ri as writeAgentPreference, rn as toneOf, rr as indexKeptIds, rt as statedWorkspacePort, s as FETCH_TIMEOUT_MS, si as agentById, sn as UNESTABLISHED_MOTIVATION, sr as latestKissRun, st as settleReview, t as deleteLineage, ti as clearAgentPreference, tn as readNotification, tr as followedRefName, tt as parseWorkspacePort, u as cancellableHere, ui as AgentCancelledError, un as GITHUB_MARKDOWN, vn as objectWithAnyOf, w as RUN_KINDS, wn as fillFileUrlTemplate, wr as activityLabel, wt as recordRuntimeBestEffort, x as startKissJob, xn as forgeFor, xr as workspaceStamps, xt as feedbackUrl, y as agentEnvOf, yn as claimRequestUrl, yr as touchWorkspace, yt as BUILD_VERSION, z as settleQueue, zn as followedBranch, zr as isQuestionOutstanding, zt as ancestorsOf } from "./delete_review-CRPRIRKg.js";
 import { basename, isAbsolute, join, relative, resolve } from "node:path";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createServer } from "node:http";
 //#region ../../packages/review-harness/src/domain/ai_review/review_composition.ts
@@ -7241,7 +7243,7 @@ function startArchitectureRun(workspace, scope, deps = {}) {
 	const now = deps.now ?? Date.now;
 	const startedAt = now();
 	const env = agentEnvOf(workspace);
-	const agent = agentFor(env);
+	const agent = agentFor$1(env);
 	const requestedModel = resolveModel({ review: { session: workspace.session } }) ?? void 0;
 	const record = {
 		version: 1,
@@ -10372,6 +10374,656 @@ function reviewsRevision(live = analysisStates()) {
 	return hash.digest("base64url");
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/working_folders.ts
+/**
+* The local Git working folders PR Review Buddy can find right now.
+*
+* One question and nothing more: which folders on this machine could a review run in. The answer is
+* derived each time from what is already known, the folders past reviews ran in and the other
+* worktrees of those repositories, and nothing is stored. A worktree an agent made yesterday shows
+* up because `git worktree list` names it, not because anything remembered it.
+*
+* A folder is a folder. A linked worktree is its own entry with its own path and is never folded
+* into the clone it belongs to: a review is filed under the folder it ran in, and the worktree is
+* where the branch is checked out.
+*
+* Not a registry. If one is wanted later it replaces `discoverWorkingFolders` and keeps the shape.
+*/
+function canonical(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+/** `git worktree list --porcelain`, main worktree first, bare and prunable entries left out. */
+async function worktreesOf(repoPath) {
+	let output;
+	try {
+		output = await git(repoPath, [
+			"worktree",
+			"list",
+			"--porcelain"
+		]);
+	} catch {
+		return [];
+	}
+	const entries = [];
+	for (const block of output.split(/\n\s*\n/)) {
+		const lines = block.split("\n");
+		const path = lines.find((line) => line.startsWith("worktree "))?.slice(9);
+		if (!path || lines.includes("bare") || lines.some((line) => line.startsWith("prunable"))) continue;
+		const ref = lines.find((line) => line.startsWith("branch "))?.slice(7) ?? null;
+		entries.push({
+			path,
+			branch: ref ? ref.replace(/^refs\/heads\//, "") : null
+		});
+	}
+	return entries;
+}
+async function discoverWorkingFolders(summaries = recentWorkspaces(Number.MAX_SAFE_INTEGER)) {
+	const lastReviewed = /* @__PURE__ */ new Map();
+	for (const summary of summaries) {
+		if (!summary.repoPath) continue;
+		const key = canonical(summary.repoPath);
+		lastReviewed.set(key, Math.max(lastReviewed.get(key) ?? 0, summary.createdAt));
+	}
+	const found = /* @__PURE__ */ new Map();
+	for (const seed of lastReviewed.keys()) {
+		if (found.has(seed) || !existsSync(seed)) continue;
+		(await worktreesOf(seed)).forEach((entry, index) => {
+			const key = canonical(entry.path);
+			if (!found.has(key) && existsSync(key)) found.set(key, {
+				entry: {
+					...entry,
+					path: key
+				},
+				main: index === 0
+			});
+		});
+	}
+	return (await Promise.all([...found.values()].map(async ({ entry, main }) => ({
+		path: entry.path,
+		remote: await originRemote(entry.path),
+		branch: entry.branch,
+		main,
+		lastReviewedAt: lastReviewed.get(entry.path) ?? null
+	})))).sort((a, b) => (b.lastReviewedAt ?? 0) - (a.lastReviewedAt ?? 0) || Number(b.main) - Number(a.main) || a.path.localeCompare(b.path));
+}
+/** Whether a remote is this github.com repository. GitHub names are case-insensitive. */
+function isGitHubRepository(remote, owner, repo) {
+	return Boolean(remote && remote.host === "github.com" && remote.owner.toLowerCase() === owner.toLowerCase() && remote.repo.toLowerCase() === repo.toLowerCase());
+}
+/**
+* The folders a pull request could be reviewed in, the suggested one first.
+*
+* Every match is returned, because which one is right is the reviewer's call: an agent's worktree
+* and the main clone hold the same objects and differ in what is checked out. The order only
+* decides the default. A folder that already has a review of this pull request comes first, so
+* reviewing it again finds that review rather than starting a second one filed under another
+* folder; then the main worktree; then whichever was reviewed in most recently.
+*/
+function candidatesFor(folders, link, summaries) {
+	const reviewedHere = new Set(summaries.filter((summary) => summary.prNumber === link.number).map((summary) => canonical(summary.repoPath)));
+	const matching = folders.filter((folder) => isGitHubRepository(folder.remote, link.owner, link.repo));
+	const rank = (folder) => reviewedHere.has(folder.path) ? 0 : folder.main ? 1 : 2;
+	return [...matching].sort((a, b) => rank(a) - rank(b) || (b.lastReviewedAt ?? 0) - (a.lastReviewedAt ?? 0));
+}
+/** The review of this pull request already filed under one of these folders, if there is one. */
+function reviewedIn(folders, link, summaries) {
+	const paths = new Set(folders.map((folder) => folder.path));
+	return summaries.find((summary) => summary.prNumber === link.number && paths.has(canonical(summary.repoPath))) ?? null;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/choose_folder.ts
+/**
+* Ask the person at this machine to pick a folder, with the operating system's own picker.
+*
+* The workspace is a page served by a local daemon, and a page cannot learn a folder's path from
+* the browser's directory picker, so the daemon asks instead. The operation is "choose a working
+* folder"; how a platform does it stays in this file, so neither the routes nor the page know.
+*
+* Only macOS has an implementation, through `osascript`. Elsewhere there is no chooser, and the
+* Add review panel falls back to the path field and the Recent list, which is all v1 needs.
+*/
+/** Long enough for somebody to browse; short enough that a forgotten dialog does not hold a request for ever. */
+var CHOOSER_TIMEOUT_MS = 3e5;
+function folderChooser(platform = process.platform) {
+	if (platform !== "darwin") return null;
+	return () => new Promise((resolve, reject) => {
+		execFile("osascript", ["-e", "POSIX path of (choose folder with prompt \"Choose the working folder to review\")"], { timeout: CHOOSER_TIMEOUT_MS }, (error, stdout, stderr) => {
+			if (error) return /-128/.test(String(stderr)) ? resolve(null) : reject(/* @__PURE__ */ new Error("The folder picker could not be opened."));
+			resolve(stdout.trim().replace(/\/$/, "") || null);
+		});
+	});
+}
+function createSlots(capacity) {
+	let free = capacity;
+	const waiting = [];
+	const releaser = () => {
+		let given = false;
+		return () => {
+			if (given) return;
+			given = true;
+			const next = waiting.shift();
+			if (next) next(releaser());
+			else free += 1;
+		};
+	};
+	return {
+		acquire: () => {
+			if (free > 0) {
+				free -= 1;
+				return Promise.resolve(releaser());
+			}
+			return new Promise((resolve) => waiting.push(resolve));
+		},
+		tryAcquire: () => {
+			if (free === 0 || waiting.length > 0) return null;
+			free -= 1;
+			return releaser();
+		}
+	};
+}
+/** How many pull requests one submission may name. See `MAX_PULL_REQUESTS_PER_BATCH`. */
+var MAX_BATCH = 20;
+/** How long a finished batch stays answerable, for a panel that is still open on it. */
+var FINISHED_BATCH_TTL_MS = 6e5;
+function realAddReviewDeps() {
+	return {
+		resolveAgent: (flag) => resolveAgent(flag ? { flag } : {}),
+		agents: async () => (await detectAgents()).map((agent) => ({
+			id: agent.id,
+			displayName: agent.displayName,
+			installed: agent.state === "installed"
+		})),
+		folders: () => discoverWorkingFolders(),
+		summaries: () => recentWorkspaces(Number.MAX_SAFE_INTEGER),
+		remoteOf: originRemote,
+		resolvePullRequest: (folder, url) => resolveTarget({
+			repoPath: folder,
+			prUrl: url,
+			resolveRequest: forgeResolver
+		}),
+		resolveBranch: (folder, base) => resolveTarget({
+			repoPath: folder,
+			...base ? { base } : {}
+		}),
+		defaultBase: async (root) => {
+			try {
+				const base = await resolveBase(root, void 0);
+				return (base.followRef ?? base.display).replace(/^refs\/(?:heads|remotes)\//, "");
+			} catch {
+				return null;
+			}
+		},
+		findExisting: findExistingReview,
+		prepare: prepareReview,
+		settle: (workspaceId) => settleReview(workspaceId, "standard"),
+		track,
+		chooseFolder: folderChooser(),
+		concurrency: 2,
+		slots: createSlots(2),
+		resumeOf: (reviewId) => {
+			const failure = failureOf$1(reviewId);
+			return failure ? {
+				agent: agentNameOf(failure.agentId),
+				...failure.requestedModel ? { model: failure.requestedModel } : {}
+			} : null;
+		},
+		agentName: agentNameOf,
+		home: homedir()
+	};
+}
+function agentNameOf(agentId) {
+	try {
+		return agentById(agentId).displayName;
+	} catch {
+		return agentId;
+	}
+}
+var refuse = (status, error) => ({
+	status,
+	body: { error }
+});
+/** A path as a person reads it, with their home folder as `~`. */
+function displayPath(path, home) {
+	return home && (path === home || path.startsWith(`${home}/`)) ? `~${path.slice(home.length)}` : path;
+}
+/** A path a person typed, made absolute: `~` is their home folder, and anything relative is refused. */
+function expandPath(raw, home) {
+	const trimmed = raw.trim().replace(/(.)\/+$/, "$1");
+	if (!trimmed) return null;
+	const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") ? `${home}${trimmed.slice(1)}` : trimmed;
+	return isAbsolute(expanded) ? expanded : null;
+}
+function message(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Why no agent could be used, in a sentence for the panel. The CLI's own wording names flags. */
+function unresolvedAgent(resolution) {
+	switch (resolution.kind) {
+		case "none": return "No review agent is installed on this machine. Install one of the agents PR Review Buddy supports, then try again.";
+		case "unknown-id": return `"${resolution.id}" is not an agent PR Review Buddy knows. Choose another under Review options, or change the default in Settings.`;
+		case "unavailable": return `${resolution.agent.displayName} can't be used from the workspace: ${resolution.reason}`;
+	}
+}
+/**
+* The agent a submission runs under: the one named under Review options, or else the same answer
+* the CLI reaches with no flag (the configured default, or the only one installed). Never the
+* harness's own fallback: an id is always passed down, so `startJob` never has to guess.
+*/
+async function agentFor(flag, deps) {
+	if (flag !== void 0 && typeof flag !== "string") return refuse(400, "Say which agent by its id.");
+	const resolution = await deps.resolveAgent(flag || void 0);
+	if (resolution.kind === "resolved") return { agentId: resolution.agent.id };
+	if (resolution.kind === "ambiguous") return refuse(400, "More than one review agent is installed. Choose one under Review options.");
+	return refuse(resolution.kind === "unknown-id" ? 400 : 409, unresolvedAgent(resolution));
+}
+function modelOf(value) {
+	if (value === void 0 || value === null || value === "") return void 0;
+	if (typeof value !== "string" || value.length > 200) return refuse(400, "The model must be a short name.");
+	return value.trim() || void 0;
+}
+/**
+* The tail of each target's queue of creations, by batch identity. In-process, like the fetch
+* queue in `target.ts`.
+*
+* `prepareReview` looks for an existing review and then creates one, and nothing between the two
+* stops a second start of the same target, from another tab or another paste, from looking in the
+* same gap and creating a second review of it. One at a time per target closes that gap for every
+* start this server makes; the second one finds the first one's review.
+*/
+var creations = /* @__PURE__ */ new Map();
+function oneCreationAtATime(target, work) {
+	const key = batchIdentity(target);
+	const mine = (creations.get(key) ?? Promise.resolve()).then(work, work);
+	const tail = mine.catch(() => {});
+	creations.set(key, tail);
+	tail.then(() => {
+		if (creations.get(key) === tail) creations.delete(key);
+	});
+	return mine;
+}
+var isAnswer = (value) => typeof value === "object" && value !== null && "status" in value && "body" in value;
+async function addReviewOptions(deps) {
+	const [agents, resolution] = await Promise.all([deps.agents(), deps.resolveAgent()]);
+	return {
+		status: 200,
+		body: {
+			agents,
+			agent: resolution.kind === "resolved" ? {
+				kind: "resolved",
+				id: resolution.agent.id,
+				displayName: resolution.agent.displayName
+			} : resolution.kind === "ambiguous" ? { kind: "ambiguous" } : {
+				kind: "refused",
+				error: unresolvedAgent(resolution)
+			},
+			canChooseFolder: deps.chooseFolder !== null
+		}
+	};
+}
+function reviewedRow(reviewId, deps) {
+	const kept = deps.resumeOf(reviewId);
+	return {
+		reviewId,
+		...kept ? { kept } : {}
+	};
+}
+function folderOption(folder, home) {
+	return {
+		path: folder.path,
+		display: displayPath(folder.path, home),
+		branch: folder.branch
+	};
+}
+/**
+* What a paste would start, without starting anything: rows, the folders each could run in, and
+* which already have a review. No forge is asked and nothing is fetched, so it is cheap enough to
+* run on every pause in typing.
+*
+* Every link gets a row, however many there are. Past the batch limit the panel refuses to start
+* rather than this quietly dropping the tail: a reviewer who pasted twenty-one pull requests and
+* got twenty reviews would not find out which one was missing.
+*/
+async function previewPullRequests(text, deps) {
+	if (typeof text !== "string") return refuse(400, "Paste the pull request links to review.");
+	const links = extractPullRequestLinks(text);
+	const [folders, summaries] = links.some((link) => link.kind === "github") ? [await deps.folders(), deps.summaries()] : [[], []];
+	return {
+		status: 200,
+		body: {
+			rows: links.map((link) => {
+				if (link.kind === "unsupported") return {
+					key: link.key,
+					label: `${link.provider} ${link.provider === "GitLab" ? "merge request" : "pull request"}`,
+					url: link.url,
+					ok: false,
+					reason: unsupportedReason(link.provider),
+					folders: []
+				};
+				const label = `${link.owner}/${link.repo} #${link.number}`;
+				const candidates = candidatesFor(folders, link, summaries);
+				if (candidates.length === 0) return {
+					key: link.key,
+					label,
+					url: link.url,
+					ok: false,
+					reason: "Local repository not found",
+					needsFolder: true,
+					folders: []
+				};
+				const reviewed = reviewedIn(candidates, link, summaries);
+				return {
+					key: link.key,
+					label,
+					url: link.url,
+					ok: true,
+					folders: candidates.map((folder) => folderOption(folder, deps.home)),
+					folder: candidates[0].path,
+					...reviewed ? { reviewed: reviewedRow(reviewed.id, deps) } : {}
+				};
+			}),
+			limit: MAX_BATCH
+		}
+	};
+}
+var batches = /* @__PURE__ */ new Map();
+function forgetFinished(now) {
+	for (const [id, batch] of batches) if (batch.finishedAt !== null && now - batch.finishedAt > FINISHED_BATCH_TTL_MS) batches.delete(id);
+}
+function newBatch(rows) {
+	forgetFinished(Date.now());
+	const batch = {
+		id: randomUUID(),
+		rows,
+		finishedAt: null
+	};
+	batches.set(batch.id, batch);
+	return batch;
+}
+var rowsOf = (batch) => batch.rows.map((row) => ({ ...row }));
+/**
+* Create the review for a row's target, or find the one it has, under the per-target lock. The
+* caller holds an analysis slot: nothing is created without one, so nothing created waits.
+*/
+async function prepareRow(row, target, agentId, model, deps) {
+	const prepared = await oneCreationAtATime(target, () => deps.prepare(target, agentId, false, model));
+	row.reviewId = prepared.kind === "new" ? prepared.workspaceId : prepared.existing.id;
+	if (prepared.kind === "existing") row.status = "already-reviewed";
+	else row.status = "reviewing";
+	if (prepared.kind === "resume") row.kept = keptOf(prepared.failure.agentId, prepared.failure.requestedModel, deps);
+	return prepared;
+}
+async function settleRow(row, deps) {
+	const settled = await deps.settle(row.reviewId);
+	if (settled.ok) row.status = "ready";
+	else {
+		row.status = "failed";
+		row.reason = settled.stopped ? "Stopped" : settled.reason;
+	}
+}
+function keptOf(agentId, model, deps) {
+	return {
+		agent: deps.agentName(agentId),
+		...model ? { model } : {}
+	};
+}
+/**
+* Start a batch and answer at once. The analyses take minutes, and the panel is not a progress
+* dialog: it may watch the batch while it stays open, and the reviews appear in the list either way.
+*
+* Each pull request waits for one of the server's analysis slots (`deps.slots`), shared with every
+* other batch and every branch review, and is resolved and created only once it has one.
+*/
+async function startPullRequestBatch(body, deps) {
+	const raw = Array.isArray(body?.items) ? body.items : null;
+	if (!raw || raw.length === 0) return refuse(400, "Say which pull requests to review.");
+	if (raw.length > MAX_BATCH) return refuse(400, `At most ${MAX_BATCH} pull requests can be started at once.`);
+	const items = [];
+	for (const entry of raw) {
+		const url = typeof entry?.url === "string" ? entry.url : "";
+		const link = parsePullRequestLink(url);
+		if (!link || link.kind !== "github") return refuse(400, `${url || "That"} is not a github.com pull request link.`);
+		const folder = typeof entry?.folder === "string" ? expandPath(entry.folder, deps.home) : null;
+		if (!folder) return refuse(400, `Choose a local folder for ${link.owner}/${link.repo} #${link.number}.`);
+		items.push({
+			url: link.url,
+			owner: link.owner,
+			repo: link.repo,
+			number: link.number,
+			key: link.key,
+			folder
+		});
+	}
+	const model = modelOf(body?.model);
+	if (isAnswer(model)) return model;
+	const agent = await agentFor(body?.agent, deps);
+	if (isAnswer(agent)) return agent;
+	const batch = newBatch(items.map((item) => ({
+		key: item.key,
+		label: `${item.owner}/${item.repo} #${item.number}`,
+		status: "waiting"
+	})));
+	/** Which row claimed each pull request, by what it resolved to rather than how it was spelled. */
+	const claimed = /* @__PURE__ */ new Map();
+	const lane = async (item, index) => {
+		const row = batch.rows[index];
+		const release = await deps.slots.acquire();
+		row.status = "reviewing";
+		try {
+			const remote = await deps.remoteOf(item.folder);
+			if (!isGitHubRepository(remote, item.owner, item.repo)) {
+				row.status = "failed";
+				row.reason = remote ? `This folder is a clone of ${remote.owner}/${remote.repo}, not ${item.owner}/${item.repo}` : `This folder is not a clone of ${item.owner}/${item.repo}`;
+				return;
+			}
+			const target = await deps.resolvePullRequest(item.folder, item.url);
+			const identity = batchIdentity(target);
+			const first = claimed.get(identity);
+			if (first !== void 0) {
+				row.status = "already-reviewed";
+				row.reason = `Same pull request as ${batch.rows[first].label}`;
+				return;
+			}
+			claimed.set(identity, index);
+			if ((await prepareRow(row, target, agent.agentId, model, deps)).kind !== "existing") await settleRow(row, deps);
+		} catch (error) {
+			row.status = "failed";
+			row.reason = message(error);
+		} finally {
+			release();
+		}
+	};
+	deps.track(runBatch(items, {
+		concurrency: deps.concurrency,
+		run: lane
+	})).catch(() => {}).finally(() => {
+		batch.finishedAt = Date.now();
+	});
+	return {
+		status: 200,
+		body: {
+			batchId: batch.id,
+			rows: rowsOf(batch)
+		}
+	};
+}
+/**
+* A batch's rows as they stand. A batch this server does not know was either finished long ago,
+* which an open panel never asks about because it stops asking once a batch finishes, or lost to a
+* restart, which is the case worth saying plainly: whatever had not started never will.
+*/
+function batchRows(id) {
+	const batch = batches.get(id);
+	if (!batch) return refuse(404, "The workspace server no longer knows this batch, most likely because it restarted. Reviews that had started are in your list. Any that were still waiting did not start.");
+	return {
+		status: 200,
+		body: {
+			rows: rowsOf(batch),
+			finished: batch.finishedAt !== null
+		}
+	};
+}
+/** A target refusal in the panel's words where the CLI's would name a command. */
+function targetRefusal(error) {
+	if (error instanceof DetachedHeadError) return "This folder is on a detached HEAD, so there is no branch to review. Check out a branch in it, or review its pull request instead.";
+	return message(error);
+}
+/** The recent and discoverable folders, for the Branch panel's list. */
+async function listFolders(deps) {
+	return {
+		status: 200,
+		body: { folders: (await deps.folders()).map((folder) => ({
+			...folderOption(folder, deps.home),
+			repo: folder.remote ? folder.remote.repo : basename(folder.path)
+		})) }
+	};
+}
+/**
+* What reviewing this folder would review, read without changing anything: the same target a bare
+* `prreviewbuddy` here would resolve, and the review it would find.
+*
+* With the base the reviewer named, when they named one, so what this checks is the comparison
+* that would be submitted. Without it, a repository whose default base is ambiguous could never be
+* reviewed from here, though naming the base is exactly what settles it.
+*/
+async function inspectFolder(rawPath, deps, rawBase) {
+	const path = typeof rawPath === "string" ? expandPath(rawPath, deps.home) : null;
+	if (!path) return {
+		status: 200,
+		body: {
+			ok: false,
+			error: "Enter the full path of a folder, or choose one."
+		}
+	};
+	const named = typeof rawBase === "string" && rawBase.trim() ? rawBase.trim() : void 0;
+	let target;
+	try {
+		target = await deps.resolveBranch(path, named);
+	} catch (error) {
+		return {
+			status: 200,
+			body: {
+				ok: false,
+				error: targetRefusal(error)
+			}
+		};
+	}
+	const [remote, base, existing] = await Promise.all([
+		deps.remoteOf(target.originRepoPath),
+		named ? Promise.resolve(named) : deps.defaultBase(target.originRepoPath),
+		deps.findExisting(target)
+	]);
+	const kept = existing ? deps.resumeOf(existing.id) : null;
+	return {
+		status: 200,
+		body: {
+			ok: true,
+			path: target.originRepoPath,
+			display: displayPath(target.originRepoPath, deps.home),
+			repo: remote ? remote.repo : basename(target.originRepoPath),
+			branch: target.branch,
+			base,
+			...existing ? { reviewed: {
+				reviewId: existing.id,
+				inProgress: existing.inProgress,
+				...kept ? { kept } : {}
+			} } : {}
+		}
+	};
+}
+/**
+* Review the branch checked out in a folder: `prreviewbuddy` run there.
+*
+* With a free analysis slot it answers once the review exists, and the analysis runs on in this
+* process, counted by `track` like a Retry. With none free it answers `waiting` and a one-row batch
+* to watch, and creates nothing until a slot frees: a review created to wait is a job nobody is
+* running, which the sweep would fail. A review the branch already has needs no slot to hand back.
+*/
+async function startBranchReview(body, deps) {
+	const path = typeof body?.path === "string" ? expandPath(body.path, deps.home) : null;
+	if (!path) return refuse(400, "Choose the working folder to review.");
+	const base = typeof body?.base === "string" && body.base.trim() ? body.base.trim() : void 0;
+	const model = modelOf(body?.model);
+	if (isAnswer(model)) return model;
+	let target;
+	try {
+		target = await deps.resolveBranch(path, base);
+	} catch (error) {
+		return refuse(400, targetRefusal(error));
+	}
+	const agent = await agentFor(body?.agent, deps);
+	if (isAnswer(agent)) return agent;
+	const row = {
+		key: batchIdentity(target),
+		label: target.branch,
+		status: "waiting"
+	};
+	const release = deps.slots.tryAcquire();
+	if (!release) {
+		const existing = await deps.findExisting(target);
+		if (existing && !deps.resumeOf(existing.id)) return {
+			status: 200,
+			body: {
+				outcome: "existing",
+				reviewId: existing.id
+			}
+		};
+		const batch = newBatch([row]);
+		deps.track((async () => {
+			const later = await deps.slots.acquire();
+			try {
+				if ((await prepareRow(row, target, agent.agentId, model, deps)).kind !== "existing") await settleRow(row, deps);
+			} catch (error) {
+				row.status = "failed";
+				row.reason = message(error);
+			} finally {
+				later();
+			}
+		})()).finally(() => {
+			batch.finishedAt = Date.now();
+		});
+		return {
+			status: 200,
+			body: {
+				outcome: "waiting",
+				batchId: batch.id
+			}
+		};
+	}
+	let prepared;
+	try {
+		prepared = await prepareRow(row, target, agent.agentId, model, deps);
+	} catch (error) {
+		release();
+		return refuse(409, message(error));
+	}
+	if (prepared.kind === "existing") release();
+	else deps.track(deps.settle(row.reviewId)).catch(() => {}).finally(release);
+	return {
+		status: 200,
+		body: {
+			outcome: prepared.kind,
+			reviewId: row.reviewId,
+			...row.kept ? { kept: row.kept } : {}
+		}
+	};
+}
+async function chooseFolder(deps) {
+	if (!deps.chooseFolder) return refuse(404, "Choosing a folder is not available on this system. Type its path instead.");
+	try {
+		const path = await deps.chooseFolder();
+		return {
+			status: 200,
+			body: path ? { path } : { cancelled: true }
+		};
+	} catch (error) {
+		return refuse(500, message(error));
+	}
+}
+//#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;
@@ -10412,7 +11064,7 @@ async function askAboutChange(workspace, question, sectionId, signal) {
 	const env = agentEnvOf(workspace);
 	const requestedModel = resolveModel({ review: { session: workspace.session } }) ?? void 0;
 	try {
-		return extractAnswer(await withUsageRecorded(workspace.id, "ask", env, (onUsage) => agentFor(env).run({
+		return extractAnswer(await withUsageRecorded(workspace.id, "ask", env, (onUsage) => agentFor$1(env).run({
 			capability: "read-code",
 			prompt: buildPrompt$2(workspace, question, sectionId, cwd),
 			cwd,
@@ -10448,7 +11100,7 @@ async function askAboutChange(workspace, question, sectionId, signal) {
 function explained(error, env) {
 	if (!(error instanceof Error) || error instanceof AgentCancelledError) return error;
 	try {
-		const plain = agentFor(env).explainFailure?.(error.message, env);
+		const plain = agentFor$1(env).explainFailure?.(error.message, env);
 		return plain ? new AskFailedError(plain) : error;
 	} catch {
 		return error;
@@ -10560,7 +11212,7 @@ async function drawDiagram(workspace, sectionId, signal) {
 	const requestedModel = resolveModel({ review: { session: workspace.session } }) ?? void 0;
 	let raw;
 	try {
-		raw = await withUsageRecorded(workspace.id, "diagram", env, (onUsage) => agentFor(env).run({
+		raw = await withUsageRecorded(workspace.id, "diagram", env, (onUsage) => agentFor$1(env).run({
 			capability: "read-code",
 			prompt: buildPrompt$1(workspace, sectionId, cwd),
 			cwd,
@@ -10747,7 +11399,7 @@ async function drawChangeMap(workspace, signal) {
 	const requestedModel = resolveModel({ review: { session: workspace.session } }) ?? void 0;
 	let raw;
 	try {
-		raw = await withUsageRecorded(workspace.id, "change-map", env, (onUsage) => agentFor(env).run({
+		raw = await withUsageRecorded(workspace.id, "change-map", env, (onUsage) => agentFor$1(env).run({
 			capability: "read-code",
 			prompt: buildPrompt(workspace, cwd),
 			cwd,
@@ -11445,6 +12097,7 @@ async function handle(req, res, options) {
 	if (url.pathname === "/fetch-updates") return handleFetchUpdates(req, res, options.indexToken);
 	if (url.pathname === "/shutdown") return handleIndexShutdown(req, res, options);
 	if (url.pathname === "/restart") return handleIndexRestart(req, res, options);
+	if (url.pathname.startsWith("/add-review/")) return handleAddReview(req, res, url.pathname, options);
 	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;
@@ -12002,6 +12655,43 @@ async function handleFetchUpdates(req, res, indexToken) {
 	send(res, 200, await runFetchUpdates(new Set(ids)));
 }
 /**
+* Add review: start pull request and branch reviews from any workspace page.
+*
+* The index credential, as the cookie, because starting a review is the machine's business rather
+* than any one review's, the same authority as `/queue` and `/fetch-updates`. The cookie is set on
+* `Path=/`, so a review page carries it too. See `add_review.ts` for what each route does.
+*/
+async function handleAddReview(req, res, pathname, options) {
+	if (!options.indexToken || !secretMatches(options.indexToken, indexCookie(req))) return send(res, 403, { error: "Not authorised." });
+	const deps = options.addReview ?? (addReviewDeps ??= realAddReviewDeps());
+	const route = pathname.slice(12);
+	const answer = async () => {
+		if (req.method === "GET") {
+			if (route === "options") return addReviewOptions(deps);
+			if (route === "folders") return listFolders(deps);
+			const batch = /^batches\/([0-9a-f-]{36})$/.exec(route);
+			if (batch) return batchRows(batch[1]);
+			return null;
+		}
+		if (req.method !== "POST") return {
+			status: 405,
+			body: { error: "Method not allowed." }
+		};
+		if (route === "folder/choose") return chooseFolder(deps);
+		const body = await readJson(req);
+		if (route === "pull-requests/preview") return previewPullRequests(body?.text, deps);
+		if (route === "pull-requests") return startPullRequestBatch(body, deps);
+		if (route === "folder/inspect") return inspectFolder(body?.path, deps, body?.base);
+		if (route === "branch") return startBranchReview(body, deps);
+		return null;
+	};
+	const result = await answer();
+	if (!result) return send(res, 404, { error: "Not found." });
+	send(res, result.status, result.body);
+}
+/** Built on first use, so a server nobody adds a review on never runs the detectors. */
+var addReviewDeps;
+/**
 * Fetch remote updates, from one review's own page, on its own token.
 *
 * The list's fetch scoped to this review: `GET` says whether it applies (the page draws the item