prreviewbuddy 0.92.0 → 0.95.2

package/dist/main.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { $ as readAskRequest, $a as runnableAgents, $i as explanationOf, Aa as TargetError, Ar as attemptIdOf, At as UpdateAlreadyRunningError, Ba as agentIdOf, Bt as append, Da as resolveTarget, Dt as parkedUpdateRefusal, E as relativeTime, Ea as kissOutcome, Er as forgeResolver, F as spawnRunner, Ft as prepareReview, G as reviewTag, Ga as STORE_ROOT, Gr as isClaimed, Gt as recordTelemetryUploadConsent, H as findingRef, Ha as readAgentPreference, Hr as purposeOf, I as applyUpdate, Ia as git, It as settleReview, J as forgetAskRequest, Ji as reviewerDispositions, Jr as followedRefName, Jt as BUILD_VERSION, Ka as AGENT_IDS, Kt as telemetryUploadConsent, L as modelProvenanceOf, Lr as PHASES, Lt as reanalyseReview, Mt as runningJobs, Na as AmbiguousRefError, Nr as isTerminal$1, Nt as failureOf, P as runDetached, Pr as loadJob, Qa as parkedReason, Ra as resolveAgent, T as runBatch, Ta as WITHHELD_REASON, Ua as writeAgentPreference, Ui as isIssueOutstanding, Ur as clearClaim, Ut as stamp, Vr as progressSteps, Wa as CONFIG_PATH, Wi as isQuestionOutstanding, Wr as driverGone, Wt as deliver, Xa as detectAgents, Y as interruption, Ya as agentIdentityOf, Yi as verdictClosure, Yt as PACKAGE_NAME, Z as isTerminalAsk, Za as isAgentId, _t as parseWorkspacePort, at as healthyPort, br as findExistingReview, bt as writePortPreference, ca as findingAssessment, di as reviewedRepositories, dr as MANAGED_ROOT, dt as stopServer, et as recordAskAccepted, fi as summarise, ft as workspaceUrl, gr as removeWorktree, gt as MIN_WORKSPACE_PORT, hr as readMarker, ht as MAX_WORKSPACE_PORT, i as deleteReview$1, ii as matchingWorkspaceIds, it as ensureServer, j as RUNNER_KINDS, jt as liveUpdateFor, k as queueForReview, kr as allJobs, li as recentWorkspaces, mi as workspaceRevision, mt as DEFAULT_WORKSPACE_PORT, ni as lineagePosition, nt as bootstrapUrl, o as liveJobsFor, oi as positionInLineage, ot as readServerRecord, q as endAskRequest, qa as agentById, qt as telemetryUploadEnabled, ri as loadWorkspace, s as wasBlocked, sr as modelHelpLines, st as reviewsUrl, t as MCP_SERVER_INFO_NAME, tt as readIndexToken, u as recordKissRun, ua as findingStatus, ui as reviewedCommit, vr as describeMovement, x as batchIdentity, xt as COMMIT_REVIEW_CANNOT_UPDATE, yr as describeSubject, yt as statedWorkspacePort, za as resolveModel, zt as startJob } from "./mcp_tools-BKPpd9dN.js";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
-import { spawn } from "node:child_process";
+import { $a as TargetError, $r as findExistingReview, $t as statedWorkspacePort, An as BUILD_VERSION, Br as modelHelpLines, Bt as readServerRecord, Ci as driverGone, Di as followedRefName, Dn as recordTelemetryUploadConsent, Dt as endAskRequest, E as relativeTime, En as deliver$1, Eo as cleanName, Fi as loadWorkspace, Fo as STORE_ROOT, Ft as readIndexToken, Gt as stopServer, Hi as reviewedCommit, I as collectionHash, Ii as matchingWorkspaceIds, It as bootstrapUrl, Ja as WITHHELD_REASON, Jr as readMarker, Jt as DEFAULT_WORKSPACE_PORT, Ki as workspaceRevision, Kt as workspaceUrl, Na as findingStatus, Nt as readAskRequest, On as telemetryUploadConsent, Ot as forgetAskRequest, Pi as lineagePosition, Pt as recordAskAccepted, Qr as describeSubject, Ri as positionInLineage, Rt as ensureServer, Sa as explanationOf, Si as clearClaim, Sn as append, St as findingRef, T as runBatch, Tn as stamp, Tt as reviewTag, Ui as reviewedRepositories, Vi as recentWorkspaces, Vt as reviewsUrl, Wi as summarise, Wr as MANAGED_ROOT, Xa as resolveTarget, Xt as MIN_WORKSPACE_PORT, Ya as kissOutcome, Yr as removeWorktree, Yt as MAX_WORKSPACE_PORT, Zr as describeMovement, Zt as parseWorkspacePort, _a as reviewerDispositions, _n as prepareReview, _o as agentIdentityOf, _t as modelProvenanceOf, ai as forgeResolver, ao as git, bi as progressSteps, bo as parkedReason, ci as allJobs, co as resolveModel, do as readAgentPreference, dt as RUNNER_KINDS, en as writePortPreference, et as deliver, fa as isIssueOutstanding, fi as isTerminal$1, fn as UpdateAlreadyRunningError, fo as writeAgentPreference, gi as PHASES, gt as applyUpdate, hn as failureOf, ho as agentById, ht as spawnRunner, i as deleteReview$1, ja as findingAssessment, jn as PACKAGE_NAME, jt as isTerminalAsk, kn as telemetryUploadEnabled, kt as interruption, li as attemptIdOf, lo as agentIdOf, lt as queueForReview, mn as runningJobs, mo as AGENT_IDS, mt as runDetached, no as AmbiguousRefError, nt as missedDelivery, o as liveJobsFor, pa as isQuestionOutstanding, pi as loadJob, pn as liveUpdateFor, po as CONFIG_PATH, rt as openDestination, s as wasBlocked, sn as parkedUpdateRefusal, so as resolveAgent, t as MCP_SERVER_INFO_NAME, tn as COMMIT_REVIEW_CANNOT_UPDATE, tt as isDelivered, u as recordKissRun, va as verdictClosure, vn as settleReview, vo as detectAgents, wi as isClaimed, x as batchIdentity, xi as purposeOf, xn as startJob, xo as runnableAgents, yn as reanalyseReview, yo as isAgentId, zt as healthyPort } from "./mcp_tools-DDbcXys2.js";
+import { createHash, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { hostname } from "node:os";
-import { createHash, randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import process$1, { platform } from "node:process";
 //#region \0rolldown/runtime.js
@@ -61,7 +61,9 @@ var VALUED = {
 		"--review",
 		"--audience",
 		"--lens",
-		"--concurrency"
+		"--concurrency",
+		"--collection",
+		"--new-collection"
 	],
 	open: [],
 	agents: [],
@@ -94,6 +96,7 @@ var BARE = {
 		"--resume",
 		"--yes",
 		"--queue",
+		"--also-queue",
 		"--json",
 		"--no-wait"
 	],
@@ -292,6 +295,11 @@ function parse$2(argv) {
 	};
 	const first = positional[0];
 	if (head === "review") {
+		const destination = refuseDestination(prs, values, flags);
+		if (destination) return {
+			name: "error",
+			message: destination
+		};
 		const batch = refuseBatch(prs, values, flags);
 		if (batch) return {
 			name: "error",
@@ -309,7 +317,9 @@ function parse$2(argv) {
 			...values["--agent"] ? { agentId: values["--agent"] } : {},
 			...values["--model"] ? { requestedModel: values["--model"] } : {},
 			...flags.has("--fresh") ? { operation: "fresh" } : {},
-			...flags.has("--queue") ? { queue: true } : {}
+			...flags.has("--queue") ? { queue: true } : {},
+			...collectionOf(values, flags),
+			...flags.has("--json") && (values["--collection"] !== void 0 || values["--new-collection"] !== void 0) ? { json: true } : {}
 		};
 		const target = Object.keys(TARGETS).find((flag) => values[flag]);
 		const operation = Object.keys(OPERATIONS).find((flag) => flags.has(flag));
@@ -324,6 +334,7 @@ function parse$2(argv) {
 			...values["--audience"] ? { audience: values["--audience"] } : {},
 			...flags.has("--yes") ? { yes: true } : {},
 			...flags.has("--queue") ? { queue: true } : {},
+			...collectionOf(values, flags),
 			...flags.has("--json") ? { json: true } : {},
 			...flags.has("--no-wait") ? { noWait: true } : {}
 		};
@@ -368,6 +379,48 @@ function parse$2(argv) {
 		...first ? { id: first } : {}
 	};
 }
+/** The collection fields, present only when a collection option was typed. */
+function collectionOf(values, flags) {
+	const name = values["--collection"];
+	const create = values["--new-collection"];
+	if (name === void 0 && create === void 0) return {};
+	return {
+		collection: name !== void 0 ? { name: cleanName(name) } : { create: cleanName(create) },
+		...flags.has("--also-queue") ? { alsoQueue: true } : {}
+	};
+}
+/**
+* What a collection option cannot be asked with, or null. Everything that needs no store is
+* checked here, so a refusal never follows a write: whether a name exists, or is taken, is the one
+* thing left to `openDestination`, and it too runs before any pull request is touched.
+*
+* A collection holds the reviews a batch of pull requests starts or finds, so it goes with `--pr`
+* and with nothing that acts on one review, asks a different question of it, or answers in JSON.
+*/
+function refuseDestination(prs, values, flags) {
+	const name = values["--collection"];
+	const create = values["--new-collection"];
+	const option = name !== void 0 ? "--collection" : create !== void 0 ? "--new-collection" : null;
+	if (name !== void 0 && create !== void 0) return "`--collection` adds the reviews to a collection you have, and `--new-collection` makes a new one for them. Keep the one you meant.";
+	if (!option) {
+		if (flags.has("--also-queue")) return "`--also-queue` puts the reviews on your review queue as well as in a collection, and no collection is named. Add `--collection <name>` or `--new-collection <name>`, or use `--queue` to put them on the queue alone.";
+		return null;
+	}
+	const typed = name ?? create;
+	if (flags.has("--queue")) return `With \`${option}\`, the reviews go into the collection only, and the queue is asked for with \`--also-queue\`. Use \`--also-queue\` in place of \`--queue\`.`;
+	if (cleanName(typed) === "") return `\`${option}\` needs a collection name after it.`;
+	if (create !== void 0 && cleanName(create).length > 60) return `\`--new-collection\` takes a name of 60 characters at most, and this one has ${cleanName(create).length}.`;
+	if (prs.length === 0) return `\`${option}\` collects the reviews of pull requests named with \`--pr\`, and this names none. Name them: \`prreviewbuddy review --pr <url> <url> ${option} "${cleanName(typed)}"\`.`;
+	const operation = [
+		"--update",
+		"--reanalyse",
+		"--delete",
+		"--resume"
+	].find((flag) => flags.has(flag));
+	if (operation) return `\`${option}\` collects the reviews a command starts or finds, and \`${operation}\` acts on one review that already exists. Run them as separate commands.`;
+	if (values["--lens"] || values["--audience"]) return `\`${option}\` collects standard reviews, and \`${values["--lens"] ? "--lens" : "--audience"}\` asks for a different one. Drop one of them.`;
+	return null;
+}
 /**
 * What several pull requests at once cannot be asked for, or null.
 *
@@ -382,6 +435,7 @@ function refuseBatch(prs, values, flags) {
 		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;
+	if (flags.has("--no-wait")) return "`--no-wait` hands one review to a background runner, and several pull requests are run here until every review has ended. Drop `--no-wait`, or run each pull request on its own with `prreviewbuddy review --pr <url> --no-wait`.";
 	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 = [
@@ -461,9 +515,15 @@ function refuseCombination(values, flags) {
 * date, and resume one that stopped. The rest are refused by name rather than half-supported: a
 * lens and a batch answer in shapes the contract does not have yet, `--delete` asks a question, and
 * `--reanalyse` replaces the analysis an agent's finding ids belong to.
+*
+* `--no-wait` says whether to wait and `--json` how to answer, so each goes without the other. It
+* covers the same operations, because those are the ones the background runner drives.
 */
 function refuseMachineFlags(values, flags) {
-	if (flags.has("--no-wait") && !flags.has("--json")) return "`--no-wait` hands the work to a background runner and answers with its job, which only makes sense with `--json`. Add `--json`, or drop `--no-wait` to watch it here.";
+	if (flags.has("--no-wait") && !flags.has("--json")) {
+		if (values["--lens"]) return "`--no-wait` does not cover lens reviews yet. Run `--lens` without `--no-wait`.";
+		for (const flag of ["--delete", "--reanalyse"]) if (flags.has(flag)) return `\`--no-wait\` covers starting, updating and resuming a review, and not \`${flag}\`. Run \`${flag}\` without \`--no-wait\`.`;
+	}
 	if (flags.has("--resume") && !values["--review"]) return "`--resume` carries on one review whose analysis stopped, so it needs `--review <review>`. A plain `prreviewbuddy review` already resumes the review of the branch you are on.";
 	if (!flags.has("--json")) return null;
 	if (values["--lens"]) return "`--json` does not cover lens reviews yet. Run `--lens` without `--json`.";
@@ -1388,17 +1448,9 @@ async function statusNow(id, request, deps) {
 		...request.askId ? { ask: await askNow(workspace, request.askId, deps) } : {}
 	};
 }
-/**
-* Start a review, or resume one, and hand the work to a detached runner.
-*
-* Never a duplicate: a target that already has a healthy review gets it back with `started: false`,
-* which is the default operation's rule at the terminal too. `fresh` asks for a second one anyway.
-* Named by `reviewId`, it resumes that review's own stopped analysis and nothing else, so recovering
-* from a dead runner can never start an unrelated review.
-*/
-async function startReview(input, deps = defaultDeps) {
+async function startReview(input, deps = defaultDeps, hooks = {}) {
 	guard("run", deps.env);
-	if (input.reviewId) return resumeReview(input.reviewId, input, deps);
+	if (input.reviewId) return resumeReview(input.reviewId, input, deps, hooks);
 	let target;
 	try {
 		target = await resolveTarget({
@@ -1415,7 +1467,8 @@ async function startReview(input, deps = defaultDeps) {
 	if (!input.fresh) {
 		const existing = await findExistingReview(target);
 		if (existing) {
-			if (failureOf(existing.id)) return resumeReview(existing.id, input, deps);
+			if (failureOf(existing.id)) return resumeReview(existing.id, input, deps, hooks);
+			hooks.ready?.();
 			return {
 				review: await getReview(existing.id, deps),
 				job: null,
@@ -1426,6 +1479,7 @@ async function startReview(input, deps = defaultDeps) {
 	}
 	const resolution = await resolveAgent({ flag: input.agent });
 	if (resolution.kind !== "resolved") throw new ApiError("refused", deps.explainAgent(resolution));
+	hooks.ready?.();
 	const prepared = await prepareReview(target, resolution.agent.id, true, input.model, input.source);
 	return handOff(prepared.kind === "new" ? prepared.workspaceId : prepared.existing.id, input.source, deps);
 }
@@ -1438,10 +1492,11 @@ function declinedSelection(input, what, running = {}) {
 	if (!declined.length) return "";
 	return ` The ${declined.join(" and ")} you named ${declined.length > 1 ? "were" : "was"} not used: the ${what} keeps its own. Pass fresh to analyse it again with them.`;
 }
-async function resumeReview(id, input, deps) {
+async function resumeReview(id, input, deps, hooks = {}) {
 	const workspace = findReview(id);
 	const failure = failureOf(workspace.id);
 	if (!failure) {
+		hooks.ready?.();
 		const job = workspace.jobId ? loadJob(workspace.jobId) : null;
 		const running = job !== null && !isTerminal$1(job) && isClaimed(job.id);
 		return {
@@ -1456,6 +1511,7 @@ async function resumeReview(id, input, deps) {
 	} catch (error) {
 		throw new ApiError("refused", error instanceof Error ? error.message : String(error));
 	}
+	hooks.ready?.();
 	const handed = await handOff(workspace.id, input.source, deps);
 	const note = declinedSelection(input, "resumed job", {
 		agent: failure.agentId,
@@ -1526,7 +1582,7 @@ async function requestUpdate(id, source, deps = defaultDeps) {
 		};
 		const latest = loadWorkspace(workspace.id)?.lastUpdate;
 		if (latest && latest.at !== before) {
-			const finished = jobsOf(workspace.id).find((candidate) => purposeOf(candidate) === "update" && candidate.startedAt >= (before ?? 0));
+			const finished = jobsOf(workspace.id).find((candidate) => purposeOf(candidate) === "update" && !candidate.scope && candidate.startedAt >= (before ?? 0));
 			return {
 				review: await getReview(workspace.id, deps),
 				job: finished ? toJobRecord(finished, false) : null,
@@ -1683,85 +1739,6 @@ function pidAlive(pid) {
 	}
 }
 //#endregion
-//#region src/exit.ts
-/**
-* What a command's exit status means, for every command.
-*
-* One table, the contract's own (`EXIT_CODES`), so a script reads the same number for the same
-* failure whether or not it asked for `--json`, and an MCP error and an exit status name the same
-* thing. A review that finds problems is a review that worked, and exits 0: these say whether the
-* command did what was asked, never what the code under review is like.
-*
-* The sentence printed beside a failure is unchanged by any of this. The number only sorts it.
-*/
-var EXIT = {
-	ok: EXIT_CODES.ok,
-	/** Something nobody anticipated. The message is still printed. */
-	unexpected: EXIT_CODES.internal,
-	/** The command, a flag or an argument was not one this can act on. */
-	usage: EXIT_CODES.invalid_argument,
-	/** No review, job or finding by that name, or a prefix that names more than one. */
-	notFound: EXIT_CODES.not_found,
-	/** Understood, and declined: already running, nothing to update, an agent that cannot run here, a question nobody answered. */
-	refused: EXIT_CODES.refused,
-	/** The analysis, update or question ran and failed. */
-	failed: EXIT_CODES.analysis_failed,
-	/** The local workspace server could not be started or reached. */
-	unavailable: EXIT_CODES.service_unavailable,
-	timeout: EXIT_CODES.timeout,
-	/** Started from inside an agent run, which cannot start reviews. */
-	recursion: EXIT_CODES.recursion_blocked
-};
-function exitFor(code) {
-	return EXIT_CODES[code];
-}
-/** A failure that reached the top unclassified. Naming a target that does not resolve is a usage error, not a crash. */
-function exitForThrown(error) {
-	if (error instanceof TargetError || error instanceof AmbiguousRefError) return EXIT.usage;
-	return EXIT.unexpected;
-}
-//#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`);
-}
-//#endregion
-//#region src/json.ts
-/**
-* The one document a `--json` command writes, and how it answers a failure.
-*
-* Exactly one JSON value on stdout, success or not, so a caller can always parse what it gets and
-* branch on `error.code` rather than on a sentence. The sentence still goes to stderr, where a
-* person watching the command reads it.
-*/
-function emit(document) {
-	out(JSON.stringify({
-		schema_version: "1",
-		...document
-	}));
-}
-/** A failure, as a document on stdout and a sentence on stderr, and the exit status it maps to. */
-function emitError(error) {
-	const document = errorDocument(error);
-	out(JSON.stringify(document));
-	err(document.error.message);
-	return error instanceof ApiError ? exitFor(error.code) : exitForThrown(error);
-}
-/** The same failure without `--json`: the sentence alone, and the same exit status. */
-function reportError(error) {
-	err(error instanceof Error ? error.message : String(error));
-	return error instanceof ApiError ? exitFor(error.code) : exitForThrown(error);
-}
-//#endregion
 //#region src/text.ts
 /**
 * The agent names, in the help, taken from the registry that actually has them.
@@ -1918,15 +1895,27 @@ Options
                               reviewer (somebody reviewing it). Required with --lens kiss
   --concurrency <n>           with several --pr URLs, how many are reviewed at once. Default 2
   --queue                     put each review on your review queue as soon as it exists
+  --collection <name>         with --pr, put each review in a collection you have, and not on
+                              the queue. Add --also-queue for both
+  --new-collection <name>     with --pr, make a collection with that name and put each review in it
+  --also-queue                with a collection option, put each review on your review queue too
   --json                      write one JSON document to stdout and nothing else: the review
-                              and its job, once the job ends. Never asks a question
-  --no-wait                   with --json, answer as soon as the job has started. It carries
-                              on in the background; follow it with \`prreviewbuddy status\`
+                              and its job, once the job ends. Never asks a question. With a
+                              collection option, also the collection and where each pull
+                              request went, for one --pr URL or several
+  --no-wait                   answer as soon as the job has started, rather than waiting for
+                              the review. It carries on in the background after this exits;
+                              check on it with \`prreviewbuddy status <review>\`. With --json,
+                              the review and its job as a document
 
 A target and an operation go together:
   prreviewbuddy review --branch feat/foo --update
   prreviewbuddy review --base origin/main
   prreviewbuddy review --pr <url> <url> --queue
+  prreviewbuddy review --pr <url> <url> --collection "Release review"
+  prreviewbuddy review --pr <url> <url> --new-collection "Friday batch"
+  prreviewbuddy review --pr <url> <url> --collection "Release review" --also-queue
+  prreviewbuddy review --pr <url> --no-wait
   prreviewbuddy review --lens kiss --audience author
   prreviewbuddy review --review <review> --delete
 
@@ -2437,7 +2426,7 @@ 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) {
+function batchFinished(rows, index, destination) {
 	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(", ")}`];
@@ -2447,7 +2436,8 @@ function batchFinished(rows, index) {
 		if (row.detail && row.url) lines.push(`${" ".repeat(lead.length)}${row.url}`);
 	}
 	const unfinished = rows.some((row) => row.outcome === "stopped" || row.outcome === "not-started" || row.outcome === "failed" && row.url);
-	lines.push(...batchQueueLines(rows));
+	lines.push(...batchCollectionLines(rows, destination));
+	lines.push(...batchQueueLines(rows, destination?.strict === true && destination.queue));
 	if (unfinished) 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);
@@ -2460,18 +2450,129 @@ function batchFinished(rows, index) {
 * ended, and the queue is where the reviewer goes next, so it is said once, together. What was left
 * out is named with its reason, because each reason has a different way round it.
 */
-function batchQueueLines(rows) {
+function batchQueueLines(rows, strict = false) {
 	const asked = rows.filter((row) => row.queue !== void 0);
-	if (asked.length === 0) return [];
+	const never = strict ? rows.filter((row) => row.queue === void 0 && row.outcome !== "duplicate") : [];
+	if (asked.length === 0 && never.length === 0) return [];
 	const lines = [""];
 	const queued = asked.filter((row) => row.queue === "added" || row.queue === "already");
 	if (queued.length > 0) lines.push(`In your review queue: ${queued.map((row) => row.label).join(", ")}`);
-	for (const row of asked) {
+	for (const row of rows) {
+		if (row.queue === void 0) {
+			if (never.includes(row)) lines.push(`Not added to your review queue: ${row.label}, because ${noReviewReason(row.outcome)}.`);
+			continue;
+		}
 		if (row.queue === "added" || row.queue === "already") continue;
 		lines.push(`Not added to your review queue: ${notQueuedBecause(row.label, row.queue)}`);
 	}
 	return lines;
 }
+/** Why a pull request has no review to put anywhere: it ended before one existed. */
+function noReviewReason(outcome) {
+	return outcome === "not-started" ? "it did not start" : "it failed before it had a review";
+}
+/**
+* What the collection holds of a batch, what it is missing and why, and where to open it.
+*
+* A duplicate is never named: the pull request it repeats is the one in the collection. A collection
+* this command made is named with the flag that adds to it, because running the same command again
+* would refuse the name as taken, by this very command.
+*/
+function batchCollectionLines(rows, destination) {
+	const collection = destination?.collection;
+	if (!collection) return [];
+	const lines = [""];
+	const inside = rows.filter((row) => isDelivered(row.collection));
+	if (inside.length > 0) lines.push(`In ${collection.name}: ${inside.map((row) => row.label).join(", ")}`);
+	let missed = false;
+	for (const row of rows) {
+		if (row.outcome === "duplicate" || isDelivered(row.collection)) continue;
+		missed = true;
+		lines.push(row.collection === void 0 ? `Not added to ${collection.name}: ${row.label}, because ${noReviewReason(row.outcome)}.` : `Not added to ${collection.name}: ${row.label}, because ${collectReason(row.collection)}.`);
+	}
+	if (collection.url) lines.push(`Open collection: ${collection.url}`);
+	if (collection.created) lines.push(createdCollectionLine(collection.name, missed || rows.some((row) => row.queue !== void 0 && !isDelivered(row.queue))));
+	return lines;
+}
+/** Why a review is not in a collection, as the end of a sentence. */
+function collectReason(result) {
+	switch (result) {
+		case "missing": return "the collection no longer exists";
+		case "full": return `the collection is full. It holds 500 reviews at most`;
+		case "gone": return "its review could not be found";
+		default: return "the collection could not be saved";
+	}
+}
+/**
+* `review --no-wait` without `--json`: what was handed to the background runner, and the command
+* that follows it. The runner is detached, so the terminal can close; `status` takes the whole id.
+*
+* Said from the job's state, not from whether anything was asked to start: an update can end before
+* this answers, most often with nothing new to reassess, and then the service's `note` says how.
+* Only an update's note is shown. The others are written for MCP callers and name its tools, and
+* what they say about a declined agent or model is already said on stderr.
+*
+* A review that was found rather than started comes with no job, so whether it is still being made
+* is read from the review's own state.
+*/
+function reviewInBackground(record, operation) {
+	const { review, job } = record;
+	const repository = review.repository;
+	const subject = repository.target_type === "pull-request" && repository.pr_url ? repository.pr_url : repository.target_type === "commit" ? `commit ${repository.head_sha.slice(0, 7)}` : repository.branch;
+	const live = job !== null && (job.state === "queued" || job.state === "running");
+	const updating = operation === "update" || job?.purpose === "update";
+	let head;
+	if (updating) head = live ? `Started updating the review of ${subject}.` : job ? `The update of the review of ${subject} ended before this could answer: ${job.state}.` : `The review of ${subject} was not updated.`;
+	else if (!record.started) {
+		const beingMade = review.state === "analysing";
+		head = operation === "resume" ? beingMade ? `The review of ${subject} is being made right now, so there is nothing to resume.` : `The review of ${subject} has no stopped analysis to resume.` : beingMade ? `A review of ${subject} is already being made, so nothing new was started.` : `A review of ${subject} already exists, so nothing new was started.`;
+	} else {
+		const verb = operation === "resume" ? "Resumed" : "Started";
+		head = live ? `${verb} the analysis of ${subject}.` : `${verb} the analysis of ${subject}, and it ended before this could answer: ${job ? job.state : "no job"}.`;
+	}
+	return [
+		head,
+		...updating && record.note && !live ? [record.note] : [],
+		...live && (record.started || updating) ? ["It carries on in the background, so you can close this terminal."] : [],
+		`Review  ${review.id}`,
+		`Job     ${job ? job.state : "none running"}`,
+		`Check   prreviewbuddy status ${review.id}`,
+		...review.workspace_url ? [`Open    ${review.workspace_url}`] : []
+	].join("\n");
+}
+/** A collection this command made before it failed, named so a retry goes to it. */
+function collectionMadeBeforeFailure(name) {
+	return createdCollectionLine(name, true);
+}
+function createdCollectionLine(name, missed) {
+	return missed ? `Created collection "${name}". To add what is missing, run the same command with --collection "${name}" in place of --new-collection.` : `Created collection "${name}".`;
+}
+/**
+* What a collection did with the one review a single command acted on, and where to open it. To
+* stderr, like `reviewQueued`. `missed` says whether anything the command asked for was left out,
+* so a collection this command made is named with the flag that retries against it.
+*/
+function reviewCollected(collection, result, missed) {
+	const lines = [result === "added" ? `Added to ${collection.name}.` : result === "already" ? `Already in ${collection.name}.` : `Not added to ${collection.name}: ${collectReason(result)}.`];
+	if (collection.url) lines.push(`Open collection: ${collection.url}`);
+	if (collection.created) lines.push(createdCollectionLine(collection.name, missed));
+	return lines.join("\n");
+}
+/** Why a collection option could not be used, before anything was reviewed. */
+function destinationRefused(refusal) {
+	const after = " Nothing was reviewed.";
+	switch (refusal.reason) {
+		case "missing": {
+			const named = `"${refusal.requested}"`;
+			return `No collection is named ${named}.${refusal.candidates.length > 0 ? ` Your collections: ${refusal.candidates.map((name) => `"${name}"`).join(", ")}.` : " You have no collections yet."} To make one, use --new-collection ${named}.${after}`;
+		}
+		case "duplicate": return `A collection named "${refusal.requested}" already exists. To add to it, use --collection "${refusal.requested}".${after}`;
+		case "empty": return `--new-collection needs a collection name after it.${after}`;
+		case "too-long": return `Use at most 60 characters for the collection name.${after}`;
+		case "full": return `You have 100 collections, which is as many as there can be. Delete one in the workspace, or add to one you have with --collection.${after}`;
+		default: return `The collection could not be saved.${after} Try again.`;
+	}
+}
 function notQueuedBecause(subject, result) {
 	switch (result) {
 		case "full": return `${subject}, because the review queue is full. It holds 50 reviews at most.`;
@@ -2832,9 +2933,165 @@ function askShown(ask) {
 	return `Question ${ask.ask_id}: ${ask.state}${ask.message ? `. ${ask.message}` : ""}`;
 }
 //#endregion
+//#region src/commands/destination.ts
+/**
+* Where a review command sends what it starts or finds, as the shared rule takes it. The parser has
+* already refused every combination that cannot be honoured; this only spells what was typed.
+*
+* A typed collection is always a name. The workspace sends ids; a person never does, and a name that
+* happens to look like one is still a name.
+*/
+function destinationRequest(command) {
+	const queue = command.collection ? command.alsoQueue === true : command.queue === true;
+	if (command.collection && "name" in command.collection) return {
+		collectionName: command.collection.name,
+		queue
+	};
+	if (command.collection) return {
+		newCollection: command.collection.create,
+		queue
+	};
+	return { queue };
+}
+/**
+* Settle the destination, or say why not and answer null. Called after every check that can refuse
+* without writing (the target, the agent), and before any review is prepared, so a refusal there
+* leaves no empty collection and a refusal here leaves no review.
+*/
+function openFor(command, say, open = openDestination) {
+	const opened = open(destinationRequest(command));
+	if (!opened.ok) {
+		say(destinationRefused(opened));
+		return null;
+	}
+	return opened.destination;
+}
+/** The Reviews page showing one collection, from the index's own link. Null when there is no index. */
+function collectionUrl(index, id) {
+	return index ? `${index}${collectionHash(id)}` : null;
+}
+//#endregion
+//#region src/commands/destination_json.ts
+/**
+* Where a `--collection` or `--new-collection` command with `--json` sent its reviews, as fields of
+* the one document it writes. The same two fields for one pull request and for several, so an agent
+* reads both the same way.
+*
+* Present only on collection commands. A command without one writes the document it always has.
+*/
+function destinationDocument(destination, index) {
+	const { id, name, created } = destination.collection;
+	return {
+		collection: {
+			id,
+			name,
+			created,
+			url: collectionUrl(index, id)
+		},
+		queue: destination.queue
+	};
+}
+/** One pull request's deliveries. No review id means it never had a review to deliver. */
+function deliveryOf(pr, reviewId, delivered, destination) {
+	const outcome = (result) => reviewId ? result ?? "unsaved" : "no_review";
+	return {
+		pr,
+		review_id: reviewId ?? null,
+		collection: outcome(delivered?.collection),
+		...destination.queue ? { queue: outcome(delivered?.queue) } : {},
+		delivered: reviewId !== void 0 && !missedDelivery(delivered, destination)
+	};
+}
+//#endregion
+//#region src/exit.ts
+/**
+* What a command's exit status means, for every command.
+*
+* One table, the contract's own (`EXIT_CODES`), so a script reads the same number for the same
+* failure whether or not it asked for `--json`, and an MCP error and an exit status name the same
+* thing. A review that finds problems is a review that worked, and exits 0: these say whether the
+* command did what was asked, never what the code under review is like.
+*
+* The sentence printed beside a failure is unchanged by any of this. The number only sorts it.
+*/
+var EXIT = {
+	ok: EXIT_CODES.ok,
+	/** Something nobody anticipated. The message is still printed. */
+	unexpected: EXIT_CODES.internal,
+	/** The command, a flag or an argument was not one this can act on. */
+	usage: EXIT_CODES.invalid_argument,
+	/** No review, job or finding by that name, or a prefix that names more than one. */
+	notFound: EXIT_CODES.not_found,
+	/** Understood, and declined: already running, nothing to update, an agent that cannot run here, a question nobody answered. */
+	refused: EXIT_CODES.refused,
+	/** The analysis, update or question ran and failed. */
+	failed: EXIT_CODES.analysis_failed,
+	/** The local workspace server could not be started or reached. */
+	unavailable: EXIT_CODES.service_unavailable,
+	timeout: EXIT_CODES.timeout,
+	/** Started from inside an agent run, which cannot start reviews. */
+	recursion: EXIT_CODES.recursion_blocked
+};
+function exitFor(code) {
+	return EXIT_CODES[code];
+}
+/** A failure that reached the top unclassified. Naming a target that does not resolve is a usage error, not a crash. */
+function exitForThrown(error) {
+	if (error instanceof TargetError || error instanceof AmbiguousRefError) return EXIT.usage;
+	return EXIT.unexpected;
+}
+//#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`);
+}
+//#endregion
+//#region src/json.ts
+/**
+* The one document a `--json` command writes, and how it answers a failure.
+*
+* Exactly one JSON value on stdout, success or not, so a caller can always parse what it gets and
+* branch on `error.code` rather than on a sentence. The sentence still goes to stderr, where a
+* person watching the command reads it.
+*/
+function emit(document) {
+	out(JSON.stringify({
+		schema_version: "1",
+		...document
+	}));
+}
+/**
+* A failure, as a document on stdout and a sentence on stderr, and the exit status it maps to.
+* `extra` adds what the command had already settled before it failed, such as a collection it made.
+*/
+function emitError(error, extra = {}) {
+	const document = {
+		...errorDocument(error),
+		...extra
+	};
+	out(JSON.stringify(document));
+	err(document.error.message);
+	return error instanceof ApiError ? exitFor(error.code) : exitForThrown(error);
+}
+/** The same failure without `--json`: the sentence alone, and the same exit status. */
+function reportError(error) {
+	err(error instanceof Error ? error.message : String(error));
+	return error instanceof ApiError ? exitFor(error.code) : exitForThrown(error);
+}
+//#endregion
 //#region src/commands/review_json.ts
 /**
-* `prreviewbuddy review --json`: the same operations as the MCP tools, and through the same calls.
+* `prreviewbuddy review --json`, and `--no-wait` with or without it: the same operations as the MCP
+* tools, and through the same calls.
 *
 * Start (or find) a review, bring one up to date, or resume one that stopped. Each goes through
 * `api/service.ts`, which mints the job here, under this terminal's environment, and hands it to a
@@ -2842,6 +3099,11 @@ function askShown(ask) {
 * follows the job to its end on the store and answers with how it ended, so a script that waits
 * gets the finished review rather than a job to poll.
 *
+* `--json` says how it answers and `--no-wait` whether it waits, and neither implies the other.
+* `--no-wait` alone comes here rather than to the terminal path because that path runs the job in
+* its own process, which ends with the terminal; the runner here is detached and outlives it. It
+* answers in sentences: what was started, its job's state, and the `status` command to check it.
+*
 * Never a question, never a progress block on stdout, never a browser: an ambiguous agent is a
 * refusal that names the agents, and everything a person would watch goes to stderr.
 */
@@ -2851,32 +3113,97 @@ function selectionOf$1(command) {
 		...command.requestedModel ? { model: command.requestedModel } : {}
 	};
 }
-var DEPS = {
-	...defaultDeps,
-	explainAgent: unresolvedAgent
+var JSON_DEPS = {
+	service: {
+		...defaultDeps,
+		explainAgent: unresolvedAgent
+	},
+	start: startReview,
+	update: async (command, repoPath, deps) => requestUpdate(await reviewToUpdate(command, repoPath), "cli", deps),
+	follow: (started, deps) => follow$1(started, deps),
+	open: openDestination,
+	deliver,
+	index: async () => {
+		try {
+			return reviewsUrl(await ensureServer(), readIndexToken());
+		} catch {
+			return null;
+		}
+	}
 };
-async function reviewJson(command, repoPath, deps = DEPS) {
+async function reviewByService(command, repoPath, overrides = {}) {
+	const jsonDeps = {
+		...JSON_DEPS,
+		...overrides
+	};
+	const deps = jsonDeps.service;
+	/** Settled once the target and agent are, and before the review is written: see `StartHooks`. */
+	let destination = null;
+	const hooks = command.collection ? { ready: () => {
+		const opened = jsonDeps.open(destinationRequest(command));
+		if (!opened.ok) throw new ApiError("refused", destinationRefused(opened));
+		if (opened.destination.collection) destination = {
+			...opened.destination,
+			collection: opened.destination.collection
+		};
+	} } : {};
+	/** What was delivered and to which review, once it was: a failure after that still reports it. */
+	let reached = null;
 	try {
-		let started = await operate$1(command, repoPath, deps);
+		let started = await operate$1(command, repoPath, deps, jsonDeps, hooks);
 		const continuation = command.operation === "update" ? "update" : command.operation === "resume" ? "resume" : started.started ? null : "existing";
 		if (continuation) for (const line of unusedSelection(continuation, selectionOf$1(command))) err(line);
 		if (command.queue) err(reviewQueued(queueForReview(started.review.id)));
-		if (!command.noWait && started.started && started.job) started = await follow$1(started, deps);
-		emit({ ...started });
-		return exitOf$1(started.job);
+		const sent = destination;
+		const delivered = sent ? jsonDeps.deliver(started.review.id, sent) : void 0;
+		if (delivered) reached = {
+			reviewId: started.review.id,
+			delivered
+		};
+		const index = sent ? await jsonDeps.index() : null;
+		if (sent && delivered) {
+			if (delivered.queue) err(reviewQueued(delivered.queue));
+			const { name, created, id } = sent.collection;
+			err(reviewCollected({
+				name,
+				created,
+				url: collectionUrl(index, id)
+			}, delivered.collection ?? "unsaved", missedDelivery(delivered, sent)));
+		}
+		if (!command.noWait && started.started && started.job) started = await jsonDeps.follow(started, deps);
+		if (command.json) emit({
+			...started,
+			...sent ? {
+				destination: destinationDocument(sent, index),
+				pull_requests: [deliveryOf(command.prUrl, started.review.id, delivered, sent)]
+			} : {}
+		});
+		else out(reviewInBackground(started, command.operation === "update" || command.operation === "resume" ? command.operation : "start"));
+		const code = exitOf$1(started.job);
+		return code === EXIT.ok && sent && missedDelivery(delivered, sent) ? EXIT.failed : code;
 	} catch (error) {
-		return emitError(error);
+		const sent = destination;
+		if (!command.json) {
+			if (sent?.collection.created && !reached) err(collectionMadeBeforeFailure(sent.collection.name));
+			return reportError(error);
+		}
+		if (!sent) return emitError(error);
+		const got = reached;
+		return emitError(error, {
+			destination: destinationDocument(sent, await jsonDeps.index()),
+			pull_requests: [deliveryOf(command.prUrl, got?.reviewId, got?.delivered, sent)]
+		});
 	}
 }
-async function operate$1(command, repoPath, deps) {
+async function operate$1(command, repoPath, deps, { start, update }, hooks = {}) {
 	if (command.prUrls) throw new ApiError("invalid_argument", "`--json` reviews one target at a time. Run it once for each pull request.");
-	if (command.operation === "resume") return startReview({
+	if (command.operation === "resume") return start({
 		repoPath,
 		reviewId: command.reviewId,
 		source: "cli"
-	}, deps);
-	if (command.operation === "update") return requestUpdate(await reviewToUpdate(command, repoPath), "cli", deps);
-	return startReview({
+	}, deps, {});
+	if (command.operation === "update") return update(command, repoPath, deps);
+	return start({
 		repoPath,
 		...command.branchRef ? { branch: command.branchRef } : {},
 		...command.prUrl ? { pr: command.prUrl } : {},
@@ -2886,7 +3213,7 @@ async function operate$1(command, repoPath, deps) {
 		...command.requestedModel ? { model: command.requestedModel } : {},
 		fresh: command.operation === "fresh",
 		source: "cli"
-	}, deps);
+	}, deps, hooks);
 }
 /** The review an update acts on: the one named, or the one this target already has. */
 async function reviewToUpdate(command, repoPath) {
@@ -3223,8 +3550,24 @@ function labelsFor(urls) {
 }
 async function reviewBatch(command, repoPath, deps = realDeps()) {
 	const urls = command.prUrls ?? [];
-	const agent = await deps.chooseAgent(command);
+	/**
+	* `--json`, which the parser lets through only beside a collection option: one document on stdout
+	* at the end, refusals included, and no question asked of anybody.
+	*/
+	const json = command.json === true;
+	let agent;
+	try {
+		agent = await deps.chooseAgent(command);
+	} catch (error) {
+		if (json) return refuseJson(deps, error);
+		throw error;
+	}
 	if (!agent) return EXIT.refused;
+	let refusal = "";
+	const destination = openFor(command, json ? (line) => refusal = line : deps.err, deps.open);
+	if (!destination) return json ? refuseJson(deps, new ApiError("refused", refusal)) : EXIT.refused;
+	/** A collection was asked for, so a review that missed a destination fails the command. */
+	const strict = command.collection !== void 0;
 	const rows = labelsFor(urls).map((label) => ({
 		label,
 		state: { kind: "queued" }
@@ -3264,7 +3607,7 @@ async function reviewBatch(command, repoPath, deps = realDeps()) {
 		const prepared = await deps.prepare(target, agent.id, command.operation === "fresh", command.requestedModel);
 		const workspaceId = prepared.kind === "new" ? prepared.workspaceId : prepared.existing.id;
 		row.workspaceId = workspaceId;
-		if (command.queue) row.reviewQueue = deps.enqueue(workspaceId);
+		if (destination.queue || destination.collection) row.delivered = deps.deliver(workspaceId, destination);
 		if (prepared.kind === "existing") {
 			row.state = {
 				kind: "existing",
@@ -3297,13 +3640,74 @@ async function reviewBatch(command, repoPath, deps = realDeps()) {
 		stopDrawing();
 		stopListening();
 	}
-	deps.out(batchFinished(rows.map((row) => summaryRow(row, links.review)), links.index));
+	if (json && destination.collection) {
+		const sent = {
+			...destination,
+			collection: destination.collection
+		};
+		deps.out(JSON.stringify({
+			schema_version: "1",
+			destination: destinationDocument(sent, links.index),
+			pull_requests: rows.map((row, index) => pullRequestJson(rows, index, urls, sent, links.review))
+		}));
+	} else deps.out(batchFinished(rows.map((row) => summaryRow(row, links.review)), links.index, {
+		queue: destination.queue,
+		strict,
+		...destination.collection ? { collection: {
+			name: destination.collection.name,
+			created: destination.collection.created,
+			url: collectionUrl(links.index, destination.collection.id)
+		} } : {}
+	}));
 	if (signal.aborted) return 130;
-	return rows.some((row) => row.state.kind === "failed") ? EXIT.failed : EXIT.ok;
+	if (rows.some((row) => row.state.kind === "failed")) return EXIT.failed;
+	if (strict && rows.some((row) => row.state.kind !== "duplicate" && missedDelivery(row.delivered, destination))) return EXIT.failed;
+	return EXIT.ok;
+}
+/** A refusal before anything ran, as the one document `--json` writes, and its exit status. */
+function refuseJson(deps, error) {
+	const document = errorDocument(error);
+	deps.out(JSON.stringify(document));
+	deps.err(document.error.message);
+	return error instanceof ApiError ? exitFor(error.code) : exitForThrown(error);
+}
+/** How each row ended, in the words a document uses. */
+var OUTCOMES = {
+	queued: "not_started",
+	"looking-up": "not_started",
+	running: "not_started",
+	"not-started": "not_started",
+	ready: "ready",
+	existing: "existing",
+	duplicate: "duplicate",
+	failed: "failed",
+	stopped: "stopped"
+};
+/**
+* One pull request of a `--json` batch: how its review ended, and where it went. A duplicate reports
+* the review and the deliveries of the row it repeats, which are its own too.
+*/
+function pullRequestJson(rows, index, urls, destination, link) {
+	const row = rows[index];
+	const state = row.state;
+	const first = state.kind === "duplicate" ? rows.findIndex((other) => other.label === state.of && other.state.kind !== "duplicate") : -1;
+	const source = first >= 0 ? rows[first] : row;
+	const url = source.workspaceId ? link(source.workspaceId) : void 0;
+	const outcome = state.kind === "existing" && state.inProgress ? "in_progress" : OUTCOMES[state.kind];
+	return {
+		...deliveryOf(urls[index], source.workspaceId, source.delivered, destination),
+		outcome,
+		...url ? { review_url: url } : {},
+		...state.kind === "failed" ? { detail: state.reason } : {},
+		...first >= 0 ? { duplicate_of: urls[first] } : {}
+	};
 }
 function summaryRow(row, link) {
 	const url = row.workspaceId ? link(row.workspaceId) : void 0;
-	const queued = row.reviewQueue ? { queue: row.reviewQueue } : {};
+	const queued = {
+		...row.delivered?.queue ? { queue: row.delivered.queue } : {},
+		...row.delivered?.collection ? { collection: row.delivered.collection } : {}
+	};
 	const withUrl = {
 		...url ? { url } : {},
 		...queued
@@ -3342,9 +3746,18 @@ function summaryRow(row, link) {
 		};
 	}
 }
+/**
+* The agent for a `--json` batch, never asked for: the one named, or the default, or a refusal that
+* says which agents there are. As the service resolves one for `review --json` on a single target.
+*/
+async function agentForJson(command) {
+	const resolution = await resolveAgent({ flag: command.agentId });
+	if (resolution.kind !== "resolved") throw new ApiError("refused", unresolvedAgent(resolution));
+	return resolution.agent;
+}
 function realDeps() {
 	return {
-		chooseAgent: (command) => chooseFor(command),
+		chooseAgent: (command) => command.json ? agentForJson(command) : chooseFor(command),
 		resolve: (prUrl, repoPath) => resolveTarget({
 			repoPath,
 			prUrl,
@@ -3353,7 +3766,9 @@ function realDeps() {
 		prepare: (target, agentId, fresh, requestedModel) => prepareReview(target, agentId, fresh, requestedModel, "cli"),
 		settle: (workspaceId, signal) => settleReview(workspaceId, "standard", signal, "cli"),
 		jobIdOf: (workspaceId) => loadWorkspace(workspaceId)?.jobId,
-		enqueue: queueForReview,
+		open: openDestination,
+		deliver,
+		err,
 		links: async () => {
 			try {
 				const port = await ensureServer();
@@ -3588,8 +4003,17 @@ function describeReview(id) {
 		createdAt: workspace?.createdAt ?? 0
 	};
 }
+/**
+* Whether a command goes through the service rather than the terminal path. `--json` does, to
+* answer in a document. `--no-wait` does with or without it, because only the service's runner is
+* detached and outlives this process. Neither, and the terminal path shows progress and waits. A
+* batch into a collection answers `--json` itself.
+*/
+function answersThroughService(command) {
+	return (command.json === true || command.noWait === true) && !(command.prUrls && command.collection);
+}
 async function review(command, repoPath) {
-	if (command.json) return reviewJson(command, repoPath);
+	if (answersThroughService(command)) return reviewByService(command, repoPath);
 	if (command.operation === "delete") return deleteReview(command);
 	if (command.prUrls) return reviewBatch(command, repoPath);
 	if (command.reviewId) {
@@ -3617,13 +4041,15 @@ async function review(command, repoPath) {
 	if (command.lens === "kiss") return kiss(command, target);
 	const agent = await chooseFor(command);
 	if (!agent) return EXIT.refused;
+	const destination = openFor(command, err);
+	if (!destination) return EXIT.refused;
 	const prepared = await prepareReview(target, agent.id, command.operation === "fresh", command.requestedModel, "cli");
-	enqueue(command, prepared.kind === "new" ? prepared.workspaceId : prepared.existing.id);
+	const missed = await deliverTo(command, destination, prepared.kind === "new" ? prepared.workspaceId : prepared.existing.id);
 	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;
+		return missed ? EXIT.failed : 0;
 	}
 	if (prepared.kind === "resume") {
 		const { existing, failure } = prepared;
@@ -3634,12 +4060,47 @@ async function review(command, repoPath) {
 			...failure.requestedModel ? { model: failure.requestedModel } : {}
 		};
 		for (const line of unusedSelection("resume", selectionOf(command), running)) err(line);
-		return drive(existing.id, url);
+		return failedIfMissed(await drive(existing.id, url), missed);
 	}
 	const { workspaceId } = prepared;
 	const url = linkTo(await ensureServer(), workspaceId, loadWorkspace(workspaceId).token);
 	out(startedReview(url, target));
-	return drive(workspaceId, url);
+	return failedIfMissed(await drive(workspaceId, url), missed);
+}
+/**
+* A review that ended well is still a failed command when a collection was asked for and it, or the
+* queue beside it, does not have the review. A review that failed keeps its own status, which says
+* more. `missed` is only ever true for a collection invocation: see `deliverTo`.
+*/
+function failedIfMissed(code, missed) {
+	return code === 0 && missed ? EXIT.failed : code;
+}
+/**
+* Put the review where the command sends it, now, and say how that went. Answers whether a
+* destination that was asked for is missing it.
+*
+* Without a collection this is `enqueue`, exactly: `--queue` alone has never failed a command, and
+* does not start now. With one, both destinations are reported, the collection with its link.
+*/
+async function deliverTo(command, destination, workspaceId) {
+	if (!command.collection || !destination.collection) {
+		enqueue(command, workspaceId);
+		return false;
+	}
+	const delivered = deliver(workspaceId, destination);
+	if (delivered.queue) err(reviewQueued(delivered.queue));
+	const missed = missedDelivery(delivered, destination);
+	let index = null;
+	try {
+		index = reviewsUrl(await ensureServer(), readIndexToken());
+	} catch {}
+	const { id, name, created } = destination.collection;
+	err(reviewCollected({
+		name,
+		created,
+		url: collectionUrl(index, id)
+	}, delivered.collection ?? "unsaved", missed));
+	return missed;
 }
 /**
 * `--lens kiss`: the other question, asked of the same change.
@@ -4724,7 +5185,7 @@ async function announceInstallation() {
 		if (!telemetryUploadEnabled()) return;
 		if (announced()) return;
 		const line = stamp({ event: "installation_started" });
-		if (!line || !await deliver(line)) return;
+		if (!line || !await deliver$1(line)) return;
 		writeMarker();
 		append(line);
 	} catch {}