prreviewbuddy 0.25.13 → 0.27.2

package/dist/main.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { A as liveUpdateFor, B as recordTelemetryUploadConsent, Bt as displayRef, C as writePortPreference, Ct as recentWorkspaces, Dt as summarise, Et as saveWorkspace, F as reanalyseReview, Gt as writeAgentPreference, H as BUILD_VERSION, Ht as agentIdOf, I as runJob, Jt as AGENT_IDS, Kt as CONFIG_PATH, L as startJob, N as recordKissRun, Q as removeWorktree, Qt as detectAgents, S as statedWorkspacePort, T as updateReview, Tt as reviewedRepositories, U as PACKAGE_NAME, V as telemetryUploadConsent, Vt as git, Wt as readAgentPreference, X as MANAGED_ROOT, Xt as agentById, Yt as DEFAULT_AGENT_ID, Z as readMarker, _ as DEFAULT_WORKSPACE_PORT, a as liveJobsFor, at as loadJob, b as parseWorkspacePort, bt as positionInLineage, c as readIndexToken, d as ensureServer, dt as clearClaim, et as checkFreshness, ft as isClaimed, gt as lineageKeyFor, h as workspaceUrl, it as isTerminal, j as runningJobs, k as UpdateAlreadyRunningError, l as bootstrapUrl, lt as progressSteps, m as stopServer, mt as groupByLineage, o as wasBlocked, p as reviewsUrl, pt as followedRefName, q as forgeResolver, qt as STORE_ROOT, r as deleteReview$1, st as PHASES, t as relativeTime, tt as allJobs, ut as purposeOf, v as MAX_WORKSPACE_PORT, vt as loadWorkspace, y as MIN_WORKSPACE_PORT, yt as matchingWorkspaceIds, z as record, zt as resolveTarget } from "./relative_time-vn8Ex9E8.js";
+import { A as removeWorktree, B as workspaceUrl, Bt as resolveTarget, C as recordTelemetryUploadConsent, Dt as saveWorkspace, Et as reviewedRepositories, G as DEFAULT_WORKSPACE_PORT, H as BUILD_VERSION, Ht as git, I as ensureServer, J as parseWorkspacePort, Jt as CONFIG_PATH, K as MAX_WORKSPACE_PORT, Kt as readAgentPreference, M as relativeTime, N as readIndexToken, O as MANAGED_ROOT, Ot as summarise, P as bootstrapUrl, Q as forgeResolver, Qt as agentById, R as reviewsUrl, S as record, U as PACKAGE_NAME, Ut as resolveAgent, Vt as displayRef, Wt as resolveModel, X as statedWorkspacePort, Xt as AGENT_IDS, Yt as STORE_ROOT, Z as writePortPreference, Zt as DEFAULT_AGENT_ID, _t as lineageKeyFor, a as wasBlocked, at as isTerminal, b as startJob, bt as matchingWorkspaceIds, c as updateReview, ct as PHASES, dt as purposeOf, en as detectAgents, f as UpdateAlreadyRunningError, ft as clearClaim, g as recordKissRun, ht as groupByLineage, i as liveJobsFor, j as modelHelpLines, k as readMarker, m as runningJobs, mt as followedRefName, n as deleteReview$1, nt as allJobs, ot as loadJob, p as liveUpdateFor, pt as isClaimed, q as MIN_WORKSPACE_PORT, qt as writeAgentPreference, tt as checkFreshness, ut as progressSteps, v as reanalyseReview, w as telemetryUploadConsent, wt as recentWorkspaces, xt as positionInLineage, y as runJob, yt as loadWorkspace, z as stopServer } from "./delete_review-B3xciJ03.js";
 import { basename, dirname, join, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
@@ -12,11 +12,13 @@ var VALUED = {
 	review: [
 		"--base",
 		"--agent",
+		"--model",
 		"--branch",
 		"--pr",
 		"--review",
 		"--audience",
-		"--lens"
+		"--lens",
+		"--concurrency"
 	],
 	open: [],
 	agents: [],
@@ -113,6 +115,8 @@ function parse(argv) {
 	const values = {};
 	const flags = /* @__PURE__ */ new Set();
 	const positional = [];
+	/** Every URL `--pr` took. `review` has no positionals, so what follows `--pr` up to the next flag is its. */
+	const prs = [];
 	for (let index = 0; index < rest.length; index += 1) {
 		const argument = rest[index];
 		if (!argument.startsWith("--")) {
@@ -129,6 +133,13 @@ function parse(argv) {
 			};
 			values[name] = value;
 			if (equals === -1) index += 1;
+			if (head === "review" && name === "--pr") {
+				prs.push(value);
+				while (rest[index + 1] !== void 0 && !rest[index + 1].startsWith("--")) {
+					prs.push(rest[index + 1]);
+					index += 1;
+				}
+			}
 			continue;
 		}
 		if (BARE[head]?.includes(name) && equals === -1) {
@@ -155,11 +166,24 @@ function parse(argv) {
 	};
 	const first = positional[0];
 	if (head === "review") {
+		const batch = refuseBatch(prs, values, flags);
+		if (batch) return {
+			name: "error",
+			message: batch
+		};
 		const refused = refuseCombination(values, flags);
 		if (refused) return {
 			name: "error",
 			message: refused
 		};
+		if (prs.length > 1) return {
+			name: "review",
+			prUrls: prs,
+			...values["--concurrency"] ? { concurrency: Number(values["--concurrency"]) } : {},
+			...values["--agent"] ? { agentId: values["--agent"] } : {},
+			...values["--model"] ? { requestedModel: values["--model"] } : {},
+			...flags.has("--fresh") ? { operation: "fresh" } : {}
+		};
 		const target = Object.keys(TARGETS).find((flag) => values[flag]);
 		const operation = Object.keys(OPERATIONS).find((flag) => flags.has(flag));
 		return {
@@ -167,6 +191,7 @@ function parse(argv) {
 			...target ? { [TARGETS[target]]: values[target] } : {},
 			...values["--base"] ? { base: values["--base"] } : {},
 			...values["--agent"] ? { agentId: values["--agent"] } : {},
+			...values["--model"] ? { requestedModel: values["--model"] } : {},
 			...operation ? { operation: OPERATIONS[operation][0] } : {},
 			...values["--lens"] ? { lens: values["--lens"] } : {},
 			...values["--audience"] ? { audience: values["--audience"] } : {},
@@ -214,6 +239,32 @@ function parse(argv) {
 	};
 }
 /**
+* What several pull requests at once cannot be asked for, or null.
+*
+* A batch is the standard review of each, started together. An operation or a lens is a question
+* about one review, and answering it for several at once is a feature of its own rather than a
+* flag this can pass through.
+*/
+function refuseBatch(prs, values, flags) {
+	const concurrency = values["--concurrency"];
+	if (concurrency !== void 0) {
+		if (!/^\d+$/.test(concurrency) || Number(concurrency) < 1) return `\`--concurrency\` is how many pull requests are reviewed at once, so it takes a whole number of 1 or more, and \`${concurrency}\` is not one.`;
+		if (prs.length < 2) return "`--concurrency` says how many of several pull requests are reviewed at once, and this names one at most. Give `--pr` two or more URLs, or drop `--concurrency`.";
+	}
+	if (prs.length < 2) return null;
+	const repeated = prs.find((url, index) => prs.indexOf(url) !== index);
+	if (repeated) return `\`${repeated}\` is named twice. Each pull request is reviewed once, so name it once.`;
+	const operation = [
+		"--update",
+		"--reanalyse",
+		"--delete"
+	].find((flag) => flags.has(flag));
+	if (operation) return `\`${operation}\` ${OPERATIONS[operation][1]}, and it acts on one review. With several pull requests, run it once for each: \`prreviewbuddy review --pr <url> ` + operation + "`.";
+	const lensFlag = values["--lens"] ? "--lens" : values["--audience"] ? "--audience" : null;
+	if (lensFlag) return `Several pull requests at once get the standard review of each, and \`${lensFlag}\` asks for a different one. Run the lens once for each pull request: \`prreviewbuddy review --pr <url> --lens kiss\`.`;
+	return null;
+}
+/**
 * The combinations of individually legal flags that ask a question with no answer, or null.
 *
 * In this order, so the message is the most specific true one: how many targets, how many
@@ -257,6 +308,7 @@ function refuseCombination(values, flags) {
 			return (named ? `\`--delete\` removes one review, and \`${named}\` can name several: reviewing a target twice with \`--fresh\` leaves two. ` : "`--delete` removes one review, and the branch you are standing on can have several: reviewing it twice with `--fresh` leaves two. ") + "Say which with `--review <review>`, which `prreviewbuddy open` prints beside each review.";
 		}
 		if (values["--agent"]) return "`--agent` chooses who analyses a change, and `--delete` analyses nothing. Drop it, or drop `--delete` if you meant to review something.";
+		if (values["--model"]) return "`--model` chooses which model analyses a change, and `--delete` analyses nothing. Drop it, or drop `--delete` if you meant to review something.";
 	}
 	if (flags.has("--yes") && !flags.has("--delete")) return "`--yes` answers the confirmation that `--delete` asks, and nothing here is asking one. Add `--delete` if you meant to remove a review.";
 	if (values["--review"]) {
@@ -285,62 +337,6 @@ function unknownCommand(head) {
 	return `There is no \`${head}\` command. This does five things: review, open, agents, config and uninstall. Run \`prreviewbuddy --help\` for what each one takes.`;
 }
 //#endregion
-//#region ../../packages/review-harness/src/agents/resolve.ts
-/**
-* Which agent answers, decided in one place.
-*
-* A pure decision: nothing here prints, prompts or spawns. The CLI renders the outcome and the
-* harness owns the rule, which is what lets `review`, `update` and the first-run picker all reach
-* the same conclusion from different starting points instead of each carrying their own version of
-* "well, if there is only one installed...".
-*
-* The precedence is the whole content of this module:
-*
-*   1. flag        an explicit `--agent` always wins, and an unavailable one fails rather than
-*                  quietly falling back. Somebody who named an agent wants that agent or an answer.
-*   2. review      the agent of this review's most recent analysis. A review is not owned by an
-*                  agent, but an update with nothing said should continue the conversation it is
-*                  part of rather than switch tools because a machine default changed last week.
-*   3. preference  the configured default.
-*   4. only-one    exactly one agent installed, so there is nothing to ask about.
-*
-* and otherwise there is no answer to give: several installed and nothing chosen is `ambiguous`,
-* which the CLI turns into a question or a refusal depending on whether anyone is there to ask.
-* None installed is `none`. Neither is an error, because neither is the reviewer's mistake.
-*/
-async function resolveAgent(request) {
-	if (request.flag) return named(request.flag, "flag");
-	const fromReview = request.review ? agentIdOf(request.review.session) : null;
-	if (fromReview && AGENT_IDS.includes(fromReview)) return named(fromReview, "review");
-	const preferred = readAgentPreference();
-	if (preferred) return named(preferred, "preference");
-	const installed = (await detectAgents()).filter((agent) => agent.state === "installed");
-	if (installed.length === 1) return named(installed[0].id, "only-one");
-	if (installed.length === 0) return { kind: "none" };
-	return {
-		kind: "ambiguous",
-		candidates: installed
-	};
-}
-async function named(id, because) {
-	if (!AGENT_IDS.includes(id)) return {
-		kind: "unknown-id",
-		id
-	};
-	const agent = agentById(id);
-	const availability = await agent.available(agent.captureEnv());
-	if (!availability.ok) return {
-		kind: "unavailable",
-		agent,
-		reason: availability.reason
-	};
-	return {
-		kind: "resolved",
-		agent,
-		because
-	};
-}
-//#endregion
 //#region src/select.ts
 /**
 * Choosing an agent the first time, and only when there is somebody to ask.
@@ -428,6 +424,68 @@ async function pick$1(ask, options, candidates) {
 	return null;
 }
 //#endregion
+//#region src/selection_flags.ts
+/**
+* The flags that choose how a run executes, and what to say when a branch cannot consume them.
+*
+* `--agent` and `--model` select an execution rather than describe a subject: they say which tool
+* and which model answer, not what is being reviewed. So every branch that hands back an analysis
+* somebody else's run produced has the same problem, and they kept solving it separately. `--agent`
+* was answered on a resume and not on an update; `--model` on neither; then on a resume and beside
+* `--update`, but not beside a review that already exists. One mistake, four escapes, because the
+* decision lived in four places.
+*
+* It lives here now. A branch asks what it may not consume and prints the answer; it does not get
+* to decide which half of the question to ask. The copy table is total over both dimensions, so a
+* third selection flag or a fourth branch is a type error at every cell it has not written yet
+* rather than a flag that goes quiet in one place.
+*
+* What this never does is obey. Each of these branches continues work that was already begun, and
+* changing the engine halfway leaves a review whose provenance and whose execution disagree. So
+* the flag is answered and the command that would honour it is named.
+*/
+/** The execution-selection flags, in the order they are answered. */
+var SELECTION_FLAGS = ["agent", "model"];
+/**
+* One sentence per branch per flag.
+*
+* Written out rather than generated from a pattern: the reason each branch cannot use the flag is
+* different, and a reviewer is owed the actual reason rather than a template with the noun swapped.
+* Totality is what the type gives; the wording is deliberately hand-set.
+*
+* They share a tense on purpose. Both lines for one branch can print in the same breath, and a
+* tense that shifts between two adjacent lines reads as two different voices.
+*/
+var SENTENCE = {
+	update: {
+		agent: (value) => `An update continues the review with the agent it was made by, so \`--agent ${value}\` changes nothing here. To analyse the same commit again with another agent, run \`prreviewbuddy review --reanalyse --agent ${value}\`.`,
+		model: (value) => `An update continues the review with the model it was made with, so \`--model ${value}\` changes nothing here. To analyse the same commit with that model, run \`prreviewbuddy review --reanalyse --model ${value}\`.`
+	},
+	resume: {
+		agent: (value) => `A resume continues the job the review already started, so \`--agent ${value}\` changes nothing here: the phases it has finished were run by the agent it was started under. To analyse the same commit with another agent, run \`prreviewbuddy review --reanalyse --agent ${value}\`.`,
+		model: (value) => `A resume continues with the model the review was started with, so \`--model ${value}\` changes nothing here. To analyse the same commit with that model, run \`prreviewbuddy review --reanalyse --model ${value}\`.`
+	},
+	existing: {
+		agent: (value) => `This is the review that already exists rather than a new one, so \`--agent ${value}\` changes nothing here. To analyse the same commit again with that agent, run \`prreviewbuddy review --reanalyse --agent ${value}\`.`,
+		model: (value) => `This is the review that already exists rather than a new one, so \`--model ${value}\` changes nothing here. To analyse the same commit again with that model, run \`prreviewbuddy review --reanalyse --model ${value}\`.`
+	}
+};
+/**
+* Which selection flags this branch will not consume, said out loud.
+*
+* `running` is what the branch will actually use, when it knows: a resume carries the agent and
+* model its job was created with, and a flag naming one of those asked for what is already
+* happening. Answering it would tell a reviewer their correct command was ignored. A branch that
+* cannot know passes nothing and every named flag is answered.
+*/
+function unusedSelection(continuation, asked, running = {}) {
+	return SELECTION_FLAGS.flatMap((flag) => {
+		const value = asked[flag];
+		if (!value || value === running[flag]) return [];
+		return [SENTENCE[continuation][flag](value)];
+	});
+}
+//#endregion
 //#region src/audience.ts
 /**
 * Asking whose code this is, when the command did not say.
@@ -560,13 +618,19 @@ async function pick(ask, options) {
 * this branch against some other base is a different comparison wearing the right branch name. A
 * base nobody named narrows nothing, because the command claimed nothing about it: any review of
 * the branch is a truthful answer to "give me the review of this branch".
+*
+* **A pull request number narrows it too.** A request target has no ref, so its lineage key is the
+* head branch name, and two fork requests both called `patch-1` share one. Only a review recording
+* the same number answers a named request. One recording no number is unknown rather than a
+* match, the same strictness as an empty base: the cost is one redundant review, never the wrong one.
 */
 async function findExistingReview(target) {
 	const groups = groupByLineage(recentWorkspaces(Number.MAX_SAFE_INTEGER));
 	const wanted = lineageKeyFor(target.originRepoPath, target.branch, target.ref);
 	const group = groups.find((entry) => entry.key === wanted);
 	if (!group) return null;
-	const history = target.base ? group.history.filter(madeAgainst(target.base)) : group.history;
+	const requested = target.pullRequest?.number;
+	const history = group.history.filter((review) => target.base ? madeAgainst(target.base)(review) : true).filter((review) => requested ? review.prNumber === requested : true);
 	if (history.length === 0) return null;
 	const summary = history[0];
 	const found = {
@@ -665,58 +729,161 @@ function describeMovement(existing) {
 	return `${subject} has moved ${existing.commitsBehind} commit${existing.commitsBehind === 1 ? "" : "s"} since.`;
 }
 //#endregion
-//#region src/review_id.ts
+//#region src/batch_schedule.ts
 /**
-* Which review a `--review` value names.
-*
-* A review id is a UUID, and a UUID is not a thing anyone retypes. `open` prints them in full and
-* every other command took nothing else, so `--review a8a9a058` answered "there is no review called
-* a8a9a058" about a review that was right there. Every tool that hands out identifiers this long
-* takes an unambiguous prefix instead, and so does this one now.
+* Run `run` over every item, at most `concurrency` at once, and report each one's ending.
 *
-* A prefix that matches two reviews is refused rather than resolved to the newer or the first. It
-* is the same rule the base resolver keeps one directory over: acting on the wrong one of two is
-* not a wasted minute when the operation is `--delete`, it is the work. Anyone who wants the
-* shorthand back has the full id in the refusal.
+* Never throws for an item: one that rejects is recorded and the rest carry on. Once `signal` is
+* aborted nothing more starts, and what is already running is waited for, because it is the work's
+* own job to notice the abort and stop.
 */
-function lookUpReviewId(value, matches = matchingWorkspaceIds) {
-	const found = matches(value);
-	if (found.length === 0) return { kind: "none" };
-	if (found.length === 1) return {
-		kind: "one",
-		id: found[0]
-	};
-	return {
-		kind: "ambiguous",
-		ids: found
+async function runBatch(items, options) {
+	const outcomes = items.map(() => ({ kind: "not-started" }));
+	let next = 0;
+	const lane = async () => {
+		while (next < items.length && !options.signal?.aborted) {
+			const index = next;
+			next += 1;
+			try {
+				outcomes[index] = {
+					kind: "done",
+					value: await options.run(items[index], index)
+				};
+			} catch (error) {
+				outcomes[index] = {
+					kind: "threw",
+					error
+				};
+			}
+		}
 	};
+	const lanes = Math.max(1, Math.min(options.concurrency, items.length));
+	await Promise.all(Array.from({ length: lanes }, lane));
+	return outcomes;
 }
 //#endregion
-//#region src/confirm.ts
+//#region src/progress.ts
 /**
-* A yes or no, asked only when there is somebody to answer.
+* What the review is doing, while it does it.
 *
-* The same shape as `chooseAgent` next door and for the same reasons: hand-rolled on
-* `node:readline` because this binary has no runtime dependencies and one question is not worth
-* acquiring one, and with its input and output injected so the decision is testable without a
-* shell.
+* The job record is the source of truth, and it is the same one the workspace page polls over
+* HTTP. Read here directly from the store rather than through the server, because this process is
+* the one driving the job and a loopback request to ask itself what it is doing would be a strange
+* way to find out.
 *
-* The default is no. Every caller of this is about to delete something, and a bare Return at a
-* prompt somebody did not read must leave their machine as it was.
+* This used to print `job.progress ?? job.phase` whenever it changed, which meant the raw phase
+* enum reached the terminal as a bare `preparing` before the first progress note arrived, and every
+* later note appended a line to a growing log. A reviewer could not tell what had finished, what
+* was running, or how much was left.
+*
+* It now renders one block: a header, then a line per phase with a mark for its state, and the
+* agent's own notes indented under whichever phase is currently running. On a terminal the block is
+* redrawn in place, so the review reads as one task progressing rather than as a transcript. Where
+* stderr is not a terminal (a pipe, a CI log, a file) it falls back to appending only the lines
+* that changed, because cursor movement written into a log is worse than a plain list.
+*
+* Progress goes to stderr and the review's link goes to stdout, so `prreviewbuddy review | pbcopy`
+* copies a URL rather than a transcript.
 */
-async function confirm(options) {
-	if (!options.isTTY) return { kind: "unattended" };
-	const reader = createInterface({ input: options.input });
-	const lines = reader[Symbol.asyncIterator]();
-	try {
-		options.write(`${options.question} [y/N] `);
-		const next = await lines.next();
-		if (next.done) return { kind: "no" };
-		const answer = next.value.trim().toLowerCase();
-		return answer === "y" || answer === "yes" ? { kind: "yes" } : { kind: "no" };
-	} finally {
-		reader.close();
+var POLL_INTERVAL_MS$1 = 500;
+/**
+* Colour only where it means something, and never where it cannot be seen.
+*
+* `NO_COLOR` is honoured because this writes to stderr, which people redirect into files and CI
+* logs where escape codes are noise rather than emphasis.
+*/
+function styling(stream) {
+	return stream.isTTY === true && !process.env.NO_COLOR;
+}
+var DIM = "\x1B[2m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var RESET = "\x1B[0m";
+/** The header above the phases: what is being reviewed, and the facts about how. */
+function header(target, colour, purpose = "review") {
+	const meta = `${target.sha.slice(0, 7)} · isolated checkout · ${target.originRepoPath}`;
+	return [
+		`${purpose === "update" ? "Updating" : "Reviewing"} ${target.branch}`,
+		colour ? `${DIM}${meta}${RESET}` : meta,
+		""
+	];
+}
+/**
+* One line per phase, marked with its state, and the agent's note under the running one.
+*
+* Completed phases stay visible because they are the part that says how far along this is. Their
+* detail does not: a note about a file read two phases ago is history, and history is what the
+* transcript was made of.
+*
+* Which phases there are, what they are called and what has become of each is `progressSteps`,
+* shared with the workspace page so the browser and this block never name one phase two things.
+* What is left here is how a terminal draws that: a mark, a colour, and an indent.
+*/
+function phaseLines(job, colour) {
+	const lines = [];
+	for (const step of progressSteps(job)) {
+		const mark = step.state === "failed" ? "✕" : step.state === "stopped" ? "–" : step.state === "complete" ? "✓" : step.state === "active" ? "⟳" : " ";
+		const paint = step.state === "failed" ? RED : step.state === "complete" ? GREEN : "";
+		if (step.state === "pending") {
+			lines.push(colour ? `${DIM}  ${mark} ${step.label}${RESET}` : `  ${mark} ${step.label}`);
+			continue;
+		}
+		lines.push(colour && paint ? `${paint}${mark}${RESET} ${step.label}` : `${mark} ${step.label}`);
+		if (step.note) lines.push(colour ? `${DIM}    ${step.note}${RESET}` : `    ${step.note}`);
 	}
+	return lines;
+}
+/**
+* How many rows this block will actually occupy, which is not how many strings it is.
+*
+* The redraw moves the cursor up by a count and clears from there, so that count has to be in the
+* unit the terminal moves in: rows on screen, after wrapping. Counting strings instead lands the
+* cursor short and clears output the block never drew. The header's second line carries a full
+* repository path and wraps in any normal window, so this was not a corner case.
+*
+* Escape sequences are removed first because they occupy no columns. A resize between drawing and
+* redrawing still misplaces the cursor; nothing short of tracking the resize can fix that, and the
+* next repaint corrects itself.
+*/
+function rowsOccupied(lines, columns) {
+	if (!columns) return lines.length;
+	const visible = (line) => line.replace(/\u001b\[[0-9;]*m/g, "").length;
+	return lines.reduce((rows, line) => rows + Math.max(1, Math.ceil(visible(line) / columns)), 0);
+}
+/**
+* Watch a job and keep one block on the screen describing it.
+*
+* Returns the stop function the caller must call: nothing here may outlive the command, and a
+* stray interval would make `review` hang after the review finished.
+*/
+function followJob(jobId, target, options = {}) {
+	const stream = options.stream ?? process.stderr;
+	const read = options.read ?? loadJob;
+	const colour = styling(stream);
+	const inPlace = stream.isTTY === true;
+	let drawn = 0;
+	let last = "";
+	const paint = () => {
+		const job = read(jobId);
+		if (!job) return;
+		const lines = [...header(job.target ?? target, colour, purposeOf(job)), ...phaseLines(job, colour)];
+		const block = lines.join("\n");
+		if (block === last) return;
+		if (inPlace && drawn > 0) stream.write(`\u001b[${drawn}A\u001b[0J`);
+		stream.write(`${block}\n`);
+		last = block;
+		drawn = rowsOccupied(lines, stream.columns ?? 0);
+	};
+	const timer = setInterval(paint, POLL_INTERVAL_MS$1);
+	timer.unref();
+	paint();
+	let stopped = false;
+	return () => {
+		if (stopped) return;
+		stopped = true;
+		clearInterval(timer);
+		paint();
+	};
 }
 //#endregion
 //#region src/text.ts
@@ -748,6 +915,33 @@ function orList(items) {
 	return `${items.slice(0, -1).join(", ")} or ${items[items.length - 1]}`;
 }
 var AGENT_NAMES = orList([...AGENT_IDS].sort());
+/**
+* Where model names come from, laid out from what each adapter says about its own tool.
+*
+* Built from the registry for the same reason `AGENT_NAMES` is, and one step further: this file
+* names neither the agents nor the way each is asked. An adapter that learns a better answer
+* changes it in one place, and a fourth adapter appears here without this string being touched.
+*
+* No model is named anywhere in it, deliberately. Which models exist belongs to the vendor, and a
+* copy of it here would be wrong by the next release.
+*/
+/**
+* The adapters, skipping any this build cannot produce.
+*
+* Guarded for the reason `review_job.ts` guards its own registry lookups: an id the registry cannot
+* answer for is not a reason to fail, and here it would take the whole help text down with it at
+* import time. Help is the last thing that should need a working registry.
+*/
+function knownAgents() {
+	return [...AGENT_IDS].sort().flatMap((id) => {
+		try {
+			const agent = agentById(id);
+			return agent ? [agent] : [];
+		} catch {
+			return [];
+		}
+	});
+}
 var HELP = `PR Review Buddy reviews a branch in an isolated checkout and opens the result
 in your browser. The review runs in a separate process against a worktree pinned to one commit, so
 your own checkout is never read or written while it works.
@@ -755,8 +949,19 @@ your own checkout is never read or written while it works.
   prreviewbuddy review                    review the current branch
   prreviewbuddy review --branch <branch>  review another branch, without checking it out
   prreviewbuddy review --pr <url>         review a pull request
+  prreviewbuddy review --pr <url> <url> ...
+                                          review several pull requests, each on its own, two at a
+                                          time; --concurrency <n> changes how many
   prreviewbuddy review --base <ref>       compare against a base of your choosing
   prreviewbuddy review --agent <agent>    review with ${AGENT_NAMES}
+  prreviewbuddy review --model <model>    ask that agent for a particular model. Reviews keep
+                                          their requested model when reanalysed; use
+                                          --reanalyse --model <model> to change it.${((rows) => {
+	if (rows.length === 0) return "";
+	const width = Math.max(...rows.map(([name]) => name.length));
+	const table = rows.map(([name, how]) => `${" ".repeat(44)}${name.padEnd(width + 2)}${how}`).join("\n");
+	return `\n${" ".repeat(42)}To find the names:\n${table}`;
+})(modelHelpLines(knownAgents()))}
 
   prreviewbuddy review --lens <name>      run a specialised review lens: ${orList([...LENS_NAMES])}
   prreviewbuddy review --lens kiss --audience author
@@ -806,6 +1011,10 @@ have been made first. \`--audience\` is required with \`--lens kiss\` and is nev
 you are reviewing, because a reviewer checks out somebody else's branch and an author reviews their
 own pull request.
 
+Several pull requests at once are several ordinary reviews, each with its own link, and the command
+prints them all when it ends. One that fails does not stop the others. Ctrl-C stops them all, and
+running the same command again carries each one on from where it got to.
+
 Reviews can also be deleted from the list in your browser, one at a time or a whole branch at once.
 
 There is no account and no API key. PR Review Buddy uses a coding agent installed on your machine
@@ -1142,8 +1351,40 @@ function reviewFailed(message, url) {
 * be the paused review of `feat/foo`. Named through the same subject every other sentence about an
 * existing review uses, so a review that follows `origin/feat/foo` is resumed under that name.
 */
-function resumingReview(failure, existing) {
-	return `The review of ${followedRefName(existing.branch, existing.headResolvedRef) ?? existing.branch} is paused: ${failure}\nCarrying on from where it stopped.`;
+function resumingReview(failure, existing, stopped = false) {
+	const subject = followedRefName(existing.branch, existing.headResolvedRef) ?? existing.branch;
+	if (stopped) return `The review of ${subject} was stopped.\nCarrying on from where it stopped.`;
+	return `The review of ${subject} is paused: ${failure}\nCarrying on from where it stopped.`;
+}
+var BATCH_WORDS = {
+	ready: "Ready",
+	existing: "Already reviewed",
+	elsewhere: "Already being made",
+	duplicate: "Duplicate",
+	failed: "Failed",
+	stopped: "Stopped",
+	"not-started": "Not started"
+};
+function batchOutcomeWord(outcome) {
+	return BATCH_WORDS[outcome];
+}
+var BATCH_QUEUED = "Queued";
+var BATCH_LOOKING_UP = "Looking up the pull request";
+var BATCH_STOPPING = "Stopping. Reviews already running are being stopped, and the rest will not start.";
+/** The end of a batch: one line per pull request, with its link, and the index last. */
+function batchFinished(rows, index) {
+	const width = Math.max(...rows.map((row) => row.label.length));
+	const tally = Object.keys(BATCH_WORDS).map((outcome) => [outcome, rows.filter((row) => row.outcome === outcome).length]).filter(([, n]) => n > 0).map(([outcome, n]) => `${n} ${BATCH_WORDS[outcome].toLowerCase()}`);
+	const lines = ["", `${count(rows.length, "pull request")}: ${tally.join(", ")}`];
+	for (const row of rows) {
+		const lead = `  ${row.label.padEnd(width)}  ${BATCH_WORDS[row.outcome].padEnd(18)}  `;
+		lines.push(`${lead}${row.detail ?? row.url ?? ""}`.trimEnd());
+		if (row.detail && row.url) lines.push(`${" ".repeat(lead.length)}${row.url}`);
+	}
+	if (rows.some((row) => row.outcome === "stopped" || row.outcome === "not-started" || row.outcome === "failed" && row.url)) lines.push("", "Run the same command again to carry on with the reviews that did not finish, from where each got to.");
+	const all = indexLinks(index);
+	if (all) lines.push("", all);
+	return lines.join("\n");
 }
 function noReviews() {
 	return "No reviews stored yet. Run `prreviewbuddy review` in a repository to make one.";
@@ -1239,30 +1480,6 @@ function noReviewOfTarget(name, make) {
 	return `There is no review of ${name} to act on. Run \`${make}\` to make one.`;
 }
 /**
-* `--agent` was named alongside `--update`, where it changes nothing.
-*
-* An update continues an analysis rather than starting one, and `updateReview` runs the agent
-* recorded in the review's own session. Said out loud rather than resolved and thrown away, which
-* is what the old `update` command did: a flag that is accepted and quietly ignored is worse than
-* one that is refused, because the reviewer walks away believing they changed something.
-*/
-function agentUnusedByUpdate(agentId) {
-	return `An update continues the review with the agent it was made by, so \`--agent ${agentId}\` changes nothing here. To analyse the same commit again with another agent, run \`prreviewbuddy review --reanalyse --agent ${agentId}\`.`;
-}
-/**
-* `--agent` was named alongside a resume, where it changes nothing either.
-*
-* A paused job carries the agent it was started under, and its finished phases were done by that
-* agent. Switching engines halfway would leave one review whose provenance and whose execution
-* disagree, so the flag does not mutate the job; it is said instead, for the reason above.
-*
-* Only when the two differ. Resuming a Codex job with `--agent codex` is the agent the reviewer
-* asked for, and telling them it was ignored would be true and useless.
-*/
-function agentUnusedByResume(agentId) {
-	return `A resume continues with the agent the review was started by, so \`--agent ${agentId}\` changes nothing here. To analyse the same commit with it instead, run \`prreviewbuddy review --reanalyse --agent ${agentId}\`.`;
-}
-/**
 * The update's own sentence, which the harness already wrote for the workspace strip, plus the
 * link. Not rephrased here: an update that stopped early has a specific reason and the reviewer
 * gets the same reason whichever surface asked for it.
@@ -1447,18 +1664,391 @@ function firstRun(version) {
 	].join("\n");
 }
 //#endregion
-//#region src/write.ts
+//#region src/batch_progress.ts
 /**
-* Where the two kinds of output go, decided once.
+* What a batch is doing, while it does it: one row per pull request.
 *
-* Links and results to stdout, everything else to stderr, so `prreviewbuddy review | pbcopy`
-* copies a URL and progress still reaches the terminal it was meant for.
+* The mechanics are `followJob`'s: poll, redraw in place on a terminal, append only on change
+* anywhere else, and stderr so the links on stdout still pipe. The words for a running review are
+* `progressSteps`' active step, so a batch row, the single-review block and the page never name one
+* phase two things.
 */
-function out(text) {
-	process.stdout.write(`${text}\n`);
+var POLL_INTERVAL_MS = 500;
+function runningWords(job) {
+	if (!job) return "Starting the review";
+	return progressSteps(job).find((step) => step.state === "active")?.label ?? PHASES[job.phase].doing;
+}
+/** A row's mark, its colour, and what it says. */
+function describe$1(state, read) {
+	switch (state.kind) {
+		case "queued": return {
+			mark: " ",
+			paint: "",
+			words: BATCH_QUEUED,
+			faint: true
+		};
+		case "looking-up": return {
+			mark: "⟳",
+			paint: "",
+			words: BATCH_LOOKING_UP
+		};
+		case "running": return {
+			mark: "⟳",
+			paint: "",
+			words: runningWords(read(state.jobId))
+		};
+		case "ready": return {
+			mark: "✓",
+			paint: GREEN,
+			words: batchOutcomeWord("ready")
+		};
+		case "existing": return {
+			mark: "✓",
+			paint: GREEN,
+			words: batchOutcomeWord(state.inProgress ? "elsewhere" : "existing")
+		};
+		case "duplicate": return {
+			mark: "✓",
+			paint: GREEN,
+			words: `${batchOutcomeWord("duplicate")}, same pull request as ${state.of}`
+		};
+		case "failed": return {
+			mark: "✕",
+			paint: RED,
+			words: batchOutcomeWord("failed")
+		};
+		case "stopped": return {
+			mark: "–",
+			paint: "",
+			words: batchOutcomeWord("stopped")
+		};
+		case "not-started": return {
+			mark: "–",
+			paint: "",
+			words: batchOutcomeWord("not-started"),
+			faint: true
+		};
+	}
 }
-function err(text) {
-	process.stderr.write(`${text}\n`);
+/** Which count in the footer a row adds to. */
+var FOOTER = {
+	queued: "queued",
+	"looking-up": "running",
+	running: "running",
+	ready: "ready",
+	existing: "ready",
+	duplicate: "ready",
+	failed: "failed",
+	stopped: "stopped",
+	"not-started": "not started"
+};
+var FOOTER_ORDER = [
+	"ready",
+	"running",
+	"queued",
+	"failed",
+	"stopped",
+	"not started"
+];
+/** The rows and the footer counting them. Pure. */
+function batchLines(rows, colour, read = loadJob, stopping = false) {
+	const width = Math.max(...rows.map((row) => row.label.length));
+	const lines = rows.map((row) => {
+		const { mark, paint, words, faint } = describe$1(row.state, read);
+		const body = `${row.label.padEnd(width)}  ${words}`;
+		if (!colour) return `${mark} ${body}`;
+		if (faint) return `${DIM}${mark} ${body}${RESET}`;
+		return paint ? `${paint}${mark}${RESET} ${body}` : `${mark} ${body}`;
+	});
+	const counts = /* @__PURE__ */ new Map();
+	for (const row of rows) counts.set(FOOTER[row.state.kind], (counts.get(FOOTER[row.state.kind]) ?? 0) + 1);
+	const footer = FOOTER_ORDER.filter((name) => counts.has(name)).map((name) => `${counts.get(name)} ${name}`).join(" · ");
+	lines.push("", colour ? `${DIM}${footer}${RESET}` : footer);
+	if (stopping) lines.push(BATCH_STOPPING);
+	return lines;
+}
+/** Keep one block on the screen describing the batch. Returns the stop function the caller must call. */
+function followBatch(rows, options = {}) {
+	const stream = options.stream ?? process.stderr;
+	const read = options.read ?? loadJob;
+	const colour = styling(stream);
+	const inPlace = stream.isTTY === true;
+	let drawn = 0;
+	let last = "";
+	const all = indexLinks(options.index ?? null);
+	const header = all ? [
+		`Reviewing ${rows.length} pull requests`,
+		"",
+		all
+	] : [`Reviewing ${rows.length} pull requests`];
+	const paint = () => {
+		const lines = [
+			...header,
+			"",
+			...batchLines(rows, colour, read, options.stopping?.() ?? false)
+		];
+		const block = lines.join("\n");
+		if (block === last) return;
+		if (inPlace && drawn > 0) stream.write(`\u001b[${drawn}A\u001b[0J`);
+		stream.write(`${block}\n`);
+		last = block;
+		drawn = rowsOccupied(lines, stream.columns ?? 0);
+	};
+	const timer = setInterval(paint, POLL_INTERVAL_MS);
+	timer.unref();
+	paint();
+	let stopped = false;
+	return () => {
+		if (stopped) return;
+		stopped = true;
+		clearInterval(timer);
+		paint();
+	};
+}
+//#endregion
+//#region src/write.ts
+/**
+* Where the two kinds of output go, decided once.
+*
+* Links and results to stdout, everything else to stderr, so `prreviewbuddy review | pbcopy`
+* copies a URL and progress still reaches the terminal it was meant for.
+*/
+function out(text) {
+	process.stdout.write(`${text}\n`);
+}
+function err(text) {
+	process.stderr.write(`${text}\n`);
+}
+/**
+* What to call each pull request on screen: `#128`, or `!45` for a merge request. Two from
+* different repositories with one number are given the repository's name too.
+*/
+function labelsFor(urls) {
+	const parts = urls.map((url) => /\/([^/]+)\/(?:-\/)?(pull|pull-requests|merge_requests)\/(\d+)/.exec(url));
+	const short = parts.map((match, index) => match ? `${match[2] === "merge_requests" ? "!" : "#"}${match[3]}` : urls[index]);
+	return short.map((label, index) => {
+		const match = parts[index];
+		return short.some((other, j) => other === label && parts[j]?.[1] !== match?.[1]) && match ? `${match[1]}${label}` : label;
+	});
+}
+async function reviewBatch(command, repoPath, deps = realDeps()) {
+	const urls = command.prUrls ?? [];
+	const agent = await deps.chooseAgent(command);
+	if (!agent) return 1;
+	const rows = labelsFor(urls).map((label) => ({
+		label,
+		state: { kind: "queued" }
+	}));
+	const controller = new AbortController();
+	const signal = controller.signal;
+	/** Which row claimed each pull request, by what it resolved to rather than how it was spelled. */
+	const claimed = /* @__PURE__ */ new Map();
+	const reviewOne = async (url, index) => {
+		const row = rows[index];
+		try {
+			await attempt(url, index, row);
+		} catch (error) {
+			row.state = signal.aborted ? { kind: "not-started" } : {
+				kind: "failed",
+				reason: error instanceof Error ? error.message : String(error)
+			};
+		}
+	};
+	const attempt = async (url, index, row) => {
+		row.state = { kind: "looking-up" };
+		const target = await deps.resolve(url, repoPath);
+		if (signal.aborted) {
+			row.state = { kind: "not-started" };
+			return;
+		}
+		const identity = `${target.originRepoPath}\n${target.pullRequest?.number ?? target.sha}`;
+		const first = claimed.get(identity);
+		if (first !== void 0) {
+			row.state = {
+				kind: "duplicate",
+				of: rows[first].label
+			};
+			return;
+		}
+		claimed.set(identity, index);
+		const prepared = await deps.prepare(target, agent.id, command.operation === "fresh", command.requestedModel);
+		if (prepared.kind === "existing") {
+			row.workspaceId = prepared.existing.id;
+			row.state = {
+				kind: "existing",
+				inProgress: prepared.existing.inProgress
+			};
+			return;
+		}
+		const workspaceId = prepared.kind === "resume" ? prepared.existing.id : prepared.workspaceId;
+		row.workspaceId = workspaceId;
+		row.state = {
+			kind: "running",
+			jobId: deps.jobIdOf(workspaceId) ?? ""
+		};
+		const settled = await deps.settle(workspaceId, signal);
+		row.state = settled.ok ? { kind: "ready" } : settled.stopped ? { kind: "stopped" } : {
+			kind: "failed",
+			reason: settled.reason
+		};
+	};
+	const links = await deps.links();
+	const stopListening = deps.onInterrupt(() => controller.abort());
+	const stopDrawing = deps.follow(rows, () => signal.aborted, links.index);
+	try {
+		(await runBatch(urls, {
+			concurrency: command.concurrency ?? 2,
+			signal,
+			run: reviewOne
+		})).forEach((outcome, index) => {
+			if (outcome.kind === "not-started") rows[index].state = { kind: "not-started" };
+		});
+	} finally {
+		stopDrawing();
+		stopListening();
+	}
+	deps.out(batchFinished(rows.map((row) => summaryRow(row, links.review)), links.index));
+	if (signal.aborted) return 130;
+	return rows.some((row) => row.state.kind === "failed") ? 1 : 0;
+}
+function summaryRow(row, link) {
+	const url = row.workspaceId ? link(row.workspaceId) : void 0;
+	const withUrl = url ? { url } : {};
+	switch (row.state.kind) {
+		case "ready": return {
+			label: row.label,
+			outcome: "ready",
+			...withUrl
+		};
+		case "existing": return {
+			label: row.label,
+			outcome: row.state.inProgress ? "elsewhere" : "existing",
+			...withUrl
+		};
+		case "duplicate": return {
+			label: row.label,
+			outcome: "duplicate",
+			detail: `same pull request as ${row.state.of}`
+		};
+		case "failed": return {
+			label: row.label,
+			outcome: "failed",
+			detail: row.state.reason,
+			...withUrl
+		};
+		case "stopped": return {
+			label: row.label,
+			outcome: "stopped",
+			...withUrl
+		};
+		default: return {
+			label: row.label,
+			outcome: "not-started"
+		};
+	}
+}
+function realDeps() {
+	return {
+		chooseAgent: (command) => chooseFor(command),
+		resolve: (prUrl, repoPath) => resolveTarget({
+			repoPath,
+			prUrl,
+			resolveRequest: forgeResolver
+		}),
+		prepare: prepareReview,
+		settle: (workspaceId, signal) => settleReview(workspaceId, "standard", signal),
+		jobIdOf: (workspaceId) => loadWorkspace(workspaceId)?.jobId,
+		links: async () => {
+			try {
+				const port = await ensureServer();
+				return {
+					review: (workspaceId) => {
+						const workspace = loadWorkspace(workspaceId);
+						return workspace ? linkTo(port, workspaceId, workspace.token) : void 0;
+					},
+					index: reviewsUrl(port, readIndexToken())
+				};
+			} catch {
+				return {
+					review: () => void 0,
+					index: null
+				};
+			}
+		},
+		follow: (rows, stopping, index) => followBatch(rows, {
+			stopping,
+			index
+		}),
+		onInterrupt: (handler) => {
+			let pressed = false;
+			const listener = () => {
+				if (pressed) {
+					process.off("SIGINT", listener);
+					process.kill(process.pid, "SIGINT");
+					return;
+				}
+				pressed = true;
+				handler();
+			};
+			process.on("SIGINT", listener);
+			return () => process.off("SIGINT", listener);
+		},
+		out
+	};
+}
+//#endregion
+//#region src/review_id.ts
+/**
+* Which review a `--review` value names.
+*
+* A review id is a UUID, and a UUID is not a thing anyone retypes. `open` prints them in full and
+* every other command took nothing else, so `--review a8a9a058` answered "there is no review called
+* a8a9a058" about a review that was right there. Every tool that hands out identifiers this long
+* takes an unambiguous prefix instead, and so does this one now.
+*
+* A prefix that matches two reviews is refused rather than resolved to the newer or the first. It
+* is the same rule the base resolver keeps one directory over: acting on the wrong one of two is
+* not a wasted minute when the operation is `--delete`, it is the work. Anyone who wants the
+* shorthand back has the full id in the refusal.
+*/
+function lookUpReviewId(value, matches = matchingWorkspaceIds) {
+	const found = matches(value);
+	if (found.length === 0) return { kind: "none" };
+	if (found.length === 1) return {
+		kind: "one",
+		id: found[0]
+	};
+	return {
+		kind: "ambiguous",
+		ids: found
+	};
+}
+//#endregion
+//#region src/confirm.ts
+/**
+* A yes or no, asked only when there is somebody to answer.
+*
+* The same shape as `chooseAgent` next door and for the same reasons: hand-rolled on
+* `node:readline` because this binary has no runtime dependencies and one question is not worth
+* acquiring one, and with its input and output injected so the decision is testable without a
+* shell.
+*
+* The default is no. Every caller of this is about to delete something, and a bare Return at a
+* prompt somebody did not read must leave their machine as it was.
+*/
+async function confirm(options) {
+	if (!options.isTTY) return { kind: "unattended" };
+	const reader = createInterface({ input: options.input });
+	const lines = reader[Symbol.asyncIterator]();
+	try {
+		options.write(`${options.question} [y/N] `);
+		const next = await lines.next();
+		if (next.done) return { kind: "no" };
+		const answer = next.value.trim().toLowerCase();
+		return answer === "y" || answer === "yes" ? { kind: "yes" } : { kind: "no" };
+	} finally {
+		reader.close();
+	}
 }
 //#endregion
 //#region src/commands/delete_review.ts
@@ -1547,130 +2137,6 @@ function describe(deps, id) {
 	};
 }
 //#endregion
-//#region src/progress.ts
-/**
-* What the review is doing, while it does it.
-*
-* The job record is the source of truth, and it is the same one the workspace page polls over
-* HTTP. Read here directly from the store rather than through the server, because this process is
-* the one driving the job and a loopback request to ask itself what it is doing would be a strange
-* way to find out.
-*
-* This used to print `job.progress ?? job.phase` whenever it changed, which meant the raw phase
-* enum reached the terminal as a bare `preparing` before the first progress note arrived, and every
-* later note appended a line to a growing log. A reviewer could not tell what had finished, what
-* was running, or how much was left.
-*
-* It now renders one block: a header, then a line per phase with a mark for its state, and the
-* agent's own notes indented under whichever phase is currently running. On a terminal the block is
-* redrawn in place, so the review reads as one task progressing rather than as a transcript. Where
-* stderr is not a terminal (a pipe, a CI log, a file) it falls back to appending only the lines
-* that changed, because cursor movement written into a log is worse than a plain list.
-*
-* Progress goes to stderr and the review's link goes to stdout, so `prreviewbuddy review | pbcopy`
-* copies a URL rather than a transcript.
-*/
-var POLL_INTERVAL_MS = 500;
-/**
-* Colour only where it means something, and never where it cannot be seen.
-*
-* `NO_COLOR` is honoured because this writes to stderr, which people redirect into files and CI
-* logs where escape codes are noise rather than emphasis.
-*/
-function styling(stream) {
-	return stream.isTTY === true && !process.env.NO_COLOR;
-}
-var DIM = "\x1B[2m";
-var GREEN = "\x1B[32m";
-var RED = "\x1B[31m";
-var RESET = "\x1B[0m";
-/** The header above the phases: what is being reviewed, and the facts about how. */
-function header(target, colour, purpose = "review") {
-	const meta = `${target.sha.slice(0, 7)} · isolated checkout · ${target.originRepoPath}`;
-	return [
-		`${purpose === "update" ? "Updating" : "Reviewing"} ${target.branch}`,
-		colour ? `${DIM}${meta}${RESET}` : meta,
-		""
-	];
-}
-/**
-* One line per phase, marked with its state, and the agent's note under the running one.
-*
-* Completed phases stay visible because they are the part that says how far along this is. Their
-* detail does not: a note about a file read two phases ago is history, and history is what the
-* transcript was made of.
-*
-* Which phases there are, what they are called and what has become of each is `progressSteps`,
-* shared with the workspace page so the browser and this block never name one phase two things.
-* What is left here is how a terminal draws that: a mark, a colour, and an indent.
-*/
-function phaseLines(job, colour) {
-	const lines = [];
-	for (const step of progressSteps(job)) {
-		const mark = step.state === "failed" ? "✕" : step.state === "complete" ? "✓" : step.state === "active" ? "⟳" : " ";
-		const paint = step.state === "failed" ? RED : step.state === "complete" ? GREEN : "";
-		if (step.state === "pending") {
-			lines.push(colour ? `${DIM}  ${mark} ${step.label}${RESET}` : `  ${mark} ${step.label}`);
-			continue;
-		}
-		lines.push(colour && paint ? `${paint}${mark}${RESET} ${step.label}` : `${mark} ${step.label}`);
-		if (step.note) lines.push(colour ? `${DIM}    ${step.note}${RESET}` : `    ${step.note}`);
-	}
-	return lines;
-}
-/**
-* How many rows this block will actually occupy, which is not how many strings it is.
-*
-* The redraw moves the cursor up by a count and clears from there, so that count has to be in the
-* unit the terminal moves in: rows on screen, after wrapping. Counting strings instead lands the
-* cursor short and clears output the block never drew. The header's second line carries a full
-* repository path and wraps in any normal window, so this was not a corner case.
-*
-* Escape sequences are removed first because they occupy no columns. A resize between drawing and
-* redrawing still misplaces the cursor; nothing short of tracking the resize can fix that, and the
-* next repaint corrects itself.
-*/
-function rowsOccupied(lines, columns) {
-	if (!columns) return lines.length;
-	const visible = (line) => line.replace(/\u001b\[[0-9;]*m/g, "").length;
-	return lines.reduce((rows, line) => rows + Math.max(1, Math.ceil(visible(line) / columns)), 0);
-}
-/**
-* Watch a job and keep one block on the screen describing it.
-*
-* Returns the stop function the caller must call: nothing here may outlive the command, and a
-* stray interval would make `review` hang after the review finished.
-*/
-function followJob(jobId, target, options = {}) {
-	const stream = options.stream ?? process.stderr;
-	const read = options.read ?? loadJob;
-	const colour = styling(stream);
-	const inPlace = stream.isTTY === true;
-	let drawn = 0;
-	let last = "";
-	const paint = () => {
-		const job = read(jobId);
-		if (!job) return;
-		const lines = [...header(job.target ?? target, colour, purposeOf(job)), ...phaseLines(job, colour)];
-		const block = lines.join("\n");
-		if (block === last) return;
-		if (inPlace && drawn > 0) stream.write(`\u001b[${drawn}A\u001b[0J`);
-		stream.write(`${block}\n`);
-		last = block;
-		drawn = rowsOccupied(lines, stream.columns ?? 0);
-	};
-	const timer = setInterval(paint, POLL_INTERVAL_MS);
-	timer.unref();
-	paint();
-	let stopped = false;
-	return () => {
-		if (stopped) return;
-		stopped = true;
-		clearInterval(timer);
-		paint();
-	};
-}
-//#endregion
 //#region src/commands/review.ts
 /**
 * `prreviewbuddy review`.
@@ -1726,6 +2192,7 @@ function describeReview(id) {
 }
 async function review(command, repoPath) {
 	if (command.operation === "delete") return deleteReview(command);
+	if (command.prUrls) return reviewBatch(command, repoPath);
 	if (command.reviewId) {
 		const workspace = byId(command.reviewId);
 		if (typeof workspace === "number") return workspace;
@@ -1750,24 +2217,25 @@ async function review(command, repoPath) {
 	if (command.lens === "kiss") return kiss(command, target);
 	const agent = await chooseFor(command);
 	if (!agent) return 1;
-	if (command.operation !== "fresh") {
-		const existing = await findExistingReview(target);
-		if (existing) {
-			const url = linkTo(await ensureServer(), existing.id, existing.token);
-			const failed = failureOf(existing.id);
-			if (!failed) {
-				out(existingReview(existing, url));
-				return 0;
-			}
-			err(resumingReview(failed.message, existing));
-			if (command.agentId && command.agentId !== failed.agentId) err(agentUnusedByResume(command.agentId));
-			return drive(existing.id, url);
-		}
+	const prepared = await prepareReview(target, agent.id, command.operation === "fresh", command.requestedModel);
+	if (prepared.kind === "existing") {
+		const url = linkTo(await ensureServer(), prepared.existing.id, prepared.existing.token);
+		out(existingReview(prepared.existing, url));
+		for (const line of unusedSelection("existing", selectionOf(command))) err(line);
+		return 0;
 	}
-	const workspaceId = await startJob({
-		target,
-		agentId: agent.id
-	});
+	if (prepared.kind === "resume") {
+		const { existing, failure } = prepared;
+		const url = linkTo(await ensureServer(), existing.id, existing.token);
+		err(resumingReview(failure.message, existing, failure.stopped));
+		const running = {
+			...failure.agentId ? { agent: failure.agentId } : {},
+			...failure.requestedModel ? { model: failure.requestedModel } : {}
+		};
+		for (const line of unusedSelection("resume", selectionOf(command), running)) err(line);
+		return drive(existing.id, url);
+	}
+	const { workspaceId } = prepared;
 	const url = linkTo(await ensureServer(), workspaceId, loadWorkspace(workspaceId).token);
 	out(startedReview(url, target));
 	return drive(workspaceId, url);
@@ -1799,11 +2267,16 @@ async function kiss(command, target) {
 	const workspace = existing ? loadWorkspace(existing.id) : null;
 	const agent = await chooseFor(command, workspace ?? void 0);
 	if (!agent) return 1;
+	const requestedModel = resolveModel({
+		...command.requestedModel ? { flag: command.requestedModel } : {},
+		...workspace ? { review: { session: workspace.session } } : {}
+	}) ?? void 0;
 	if (workspace) {
 		const job = await recordKissRun({
 			workspaceId: workspace.id,
 			audience,
-			agentId: agent.id
+			agentId: agent.id,
+			...requestedModel ? { requestedModel } : {}
 		});
 		const url = linkTo(await ensureServer(), workspace.id, workspace.token);
 		out(startedReview(url, target));
@@ -1815,7 +2288,8 @@ async function kiss(command, target) {
 			type: "kiss",
 			audience
 		},
-		agentId: agent.id
+		agentId: agent.id,
+		...requestedModel ? { requestedModel } : {}
 	});
 	const fresh = loadWorkspace(workspaceId);
 	const run = (fresh.kissRuns ?? [])[0];
@@ -1847,6 +2321,18 @@ async function audienceFor(command) {
 	return choice.audience;
 }
 /**
+* The command's execution-selection flags, in the shape the answering rule takes.
+*
+* One conversion for every branch that has to answer them, so a third flag is added here and in
+* `selection_flags.ts` rather than at each call site that might forget it.
+*/
+function selectionOf(command) {
+	return {
+		...command.agentId ? { agent: command.agentId } : {},
+		...command.requestedModel ? { model: command.requestedModel } : {}
+	};
+}
+/**
 * Doing something to a review that already exists.
 *
 * Two operations rather than a flag and its modifier, which is what `update.ts` had and what its
@@ -1868,7 +2354,7 @@ async function operate(command, workspace) {
 		try {
 			await reanalyseReview(workspace.id, agent.id, (jobId) => {
 				stopReanalysis = follow(jobId);
-			});
+			}, command.requestedModel);
 		} finally {
 			stopReanalysis?.();
 		}
@@ -1876,7 +2362,7 @@ async function operate(command, workspace) {
 		out(reanalysed(agent.displayName, linkTo(port, workspace.id, workspace.token), actedOn(workspace)));
 		return 0;
 	}
-	if (command.agentId) err(agentUnusedByUpdate(command.agentId));
+	for (const line of unusedSelection("update", selectionOf(command))) err(line);
 	const url = linkTo(await ensureServer(), workspace.id, workspace.token);
 	if (liveUpdateFor(workspace.id)) {
 		out(updateAlreadyRunning(url, actedOn(workspace)));
@@ -1955,16 +2441,6 @@ function makeCommandFor(command) {
 	if (command.prUrl) return `prreviewbuddy review --pr ${command.prUrl}`;
 	return "prreviewbuddy review";
 }
-/**
-* Why this review's job stopped, if it stopped badly. Null for a review that finished, and for one
-* still being made.
-*
-* A job can read as failed and still be driven: the sweep calls a job stopped after half an hour
-* without a write, and an analysis that streams nothing is silent while entirely alive. Resuming
-* that one would start a second driver against the worktree the first is still standing in, so the
-* claim is asked as well as the phase. `runJob` would refuse anyway, but by then this command has
-* printed that it is picking the review up, and would report the refusal as a failed review.
-*/
 function failureOf(workspaceId) {
 	const workspace = loadWorkspace(workspaceId);
 	if (!workspace?.jobId) return null;
@@ -1973,7 +2449,95 @@ function failureOf(workspaceId) {
 	if (isClaimed(job.id)) return null;
 	return {
 		message: job.failure?.message ?? "The reason was not recorded.",
-		agentId: job.env.agentId ?? DEFAULT_AGENT_ID
+		stopped: job.failure?.stopped === true,
+		agentId: job.env.agentId ?? DEFAULT_AGENT_ID,
+		...job.requestedModel ? { requestedModel: job.requestedModel } : {}
+	};
+}
+/**
+* What to run for a resolved target, decided and started, with nothing printed.
+*
+* The first half of `review`, and the half a batch shares: a batch says all of it in one summary
+* at the end rather than as it goes, so the deciding and the saying have to be apart.
+*
+* A review that exists is usually a review that finished, and handing it back rather than making a
+* second one is the whole rule. A review whose job failed is the exception, and handing that one
+* back is worse than useless: the reviewer typed a command and would get a link to a page reporting
+* the failure they just caused, with the way out being a button in a browser. It is the same resume
+* the workspace's Retry offers, taken here because this is where the person is.
+*
+* The target is the one already resolved, not re-derived. A request reference is resolved by
+* spawning an agent, and resolving it twice risks pinning the job to a different commit than the one
+* the existing-review check just looked at. It carries the base too, which is why none is passed
+* alongside it: two copies of one answer make one of them the authority without saying which.
+*
+* The agent is the resolved one, not the flag. They are the same string only when somebody typed
+* one: a machine default, a review's own agent and the first-run picker all reach a decision the
+* flag never held, and passing the flag threw all three away. The harness reads an absent id as
+* "whatever the default is", so a configured default of Codex announced Codex and then analysed
+* with Claude, and nothing said so until the failure named the wrong tool.
+*/
+async function prepareReview(target, agentId, fresh, requestedModel) {
+	if (!fresh) {
+		const existing = await findExistingReview(target);
+		if (existing) {
+			const failure = failureOf(existing.id);
+			return failure ? {
+				kind: "resume",
+				existing,
+				failure
+			} : {
+				kind: "existing",
+				existing
+			};
+		}
+	}
+	return {
+		kind: "new",
+		workspaceId: await startJob({
+			target,
+			agentId,
+			...requestedModel ? { requestedModel } : {}
+		})
+	};
+}
+/**
+* Run a review's job to its end and say whether a review came out of it, with nothing printed.
+*
+* Any ending that is not `done`, not only the one that says `failed`. A run that stopped without
+* recording why still stopped, and reading "not failed" as "finished" is what let a job left at
+* `analysing` print `Review ready` over a review that does not exist.
+*
+* The standard review is also checked for a result. A finished analysis always leaves one -- a
+* reply that could not be read is a failure and never reaches here -- so a null one is a bug, and
+* `Review ready . Risk not rated . 0 findings` is the one sentence it must never be reported as:
+* that reads as a clean bill of health, which is the opposite of what happened. A KISS run's
+* answer is checked by `drive`, which knows which run it is.
+*/
+async function settleReview(workspaceId, reviewType = "standard", signal) {
+	let job;
+	try {
+		job = await runJob(workspaceId, {}, reviewType, signal ? { signal } : {});
+	} catch (error) {
+		return {
+			ok: false,
+			reason: error instanceof Error ? error.message : String(error),
+			stopped: false
+		};
+	}
+	if (job.phase !== "done") return {
+		ok: false,
+		reason: failureMessage(job),
+		stopped: job.failure?.stopped === true
+	};
+	if (reviewType === "standard" && !loadWorkspace(workspaceId)?.session?.result) return {
+		ok: false,
+		reason: "The analysis finished without recording a review.",
+		stopped: false
+	};
+	return {
+		ok: true,
+		job
 	};
 }
 /**
@@ -1998,22 +2562,17 @@ async function drive(workspaceId, url, kissRun) {
 		sha: "",
 		originRepoPath: ""
 	});
-	let finished;
+	let settled;
 	try {
-		finished = await runJob(workspaceId, {}, kissRun ? "kiss" : "standard");
-		if (finished.phase !== "done") {
-			stop();
-			err(reviewFailed(failureMessage(finished), await linkNow(workspace, url)));
-			return 1;
-		}
-	} catch (error) {
-		stop();
-		err(reviewFailed(error instanceof Error ? error.message : String(error), await linkNow(workspace, url)));
-		return 1;
+		settled = await settleReview(workspaceId, kissRun ? "kiss" : "standard");
 	} finally {
 		stop();
 	}
 	const link = await linkNow(workspace, url);
+	if (!settled.ok) {
+		err(reviewFailed(settled.reason, link));
+		return 1;
+	}
 	const done = loadWorkspace(workspaceId);
 	if (kissRun) {
 		const answer = (done.kissRuns ?? []).find((candidate) => candidate.jobId === kissRun.jobId)?.result;
@@ -2024,11 +2583,7 @@ async function drive(workspaceId, url, kissRun) {
 		out(kissFinished(link, answer.recommendations.length));
 		return 0;
 	}
-	if (!done.session.result) {
-		err(reviewFailed("The analysis finished without recording a review.", link));
-		return 1;
-	}
-	out(reviewFinished(link, summarise(done), finished.conversation));
+	out(reviewFinished(link, summarise(done), settled.job.conversation));
 	return 0;
 }
 /**