prreviewbuddy 0.15.2 → 0.18.0

package/dist/main.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { $ as positionInLineage, B as isTerminal, E as startJob, F as checkFreshness, I as WORK_PHASES, J as followedRefName, K as agentIdOf, O as forgeResolver, Q as loadWorkspace, T as runJob, U as displayRef, V as loadJob, W as resolveTarget, X as lineageKeyFor, Y as groupByLineage, _t as detectAgents, c as reviewsUrl, d as BUILD_VERSION, h as LANDING_PAGE, ht as agentById, i as bootstrapUrl, it as summarise, j as isClaimed, l as workspaceUrl, mt as AGENT_IDS, o as ensureServer, q as STORE_ROOT, r as record, rt as saveWorkspace, s as readServerRecord, t as relativeTime, tt as recentWorkspaces, w as reanalyseReview, y as updateReview } from "./relative_time-Dh7GvPvk.js";
-import { basename, join } from "node:path";
+import { $ as agentIdOf, B as MANAGED_ROOT, C as LANDING_PAGE, Ct as agentById, D as updateReview, G as allJobs, H as removeWorktree, I as forgeResolver, J as loadJob, M as reanalyseReview, N as runJob, P as startJob, Q as git, R as clearClaim, St as AGENT_IDS, Tt as detectAgents, U as checkFreshness, V as readMarker, W as WORK_PHASES, X as resolveTarget, Z as displayRef, a as liveJobsFor, at as positionInLineage, bt as STORE_ROOT, dt as summarise, et as followedRefName, f as ensureServer, g as workspaceUrl, h as stopServer, it as loadWorkspace, l as record, lt as reviewedRepositories, m as reviewsUrl, nt as lineageKeyFor, o as runningJobs, p as readServerRecord, q as isTerminal, r as deleteReview$1, st as recentWorkspaces, t as relativeTime, tt as groupByLineage, u as bootstrapUrl, ut as saveWorkspace, v as BUILD_VERSION, y as PACKAGE_NAME, z as isClaimed } from "./relative_time-Ckbb4Srd.js";
+import { basename, dirname, join, resolve } from "node:path";
 import { spawn } from "node:child_process";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { hostname } from "node:os";
 import { createInterface } from "node:readline";
 import { platform } from "node:process";
 //#region src/args.ts
@@ -17,18 +18,26 @@ var VALUED = {
 	],
 	open: [],
 	agents: [],
-	config: []
+	config: [],
+	uninstall: []
 };
 /** Flags that stand alone, per command. */
 var BARE = {
 	review: [
 		"--fresh",
 		"--update",
-		"--reanalyse"
+		"--reanalyse",
+		"--delete",
+		"--yes"
 	],
 	open: [],
 	agents: [],
-	config: []
+	config: [],
+	uninstall: [
+		"--yes",
+		"--force",
+		"--keep-reviews"
+	]
 };
 /**
 * How many positionals each command takes.
@@ -44,7 +53,8 @@ var POSITIONALS = {
 	review: 0,
 	open: 1,
 	agents: 1,
-	config: 3
+	config: 3,
+	uninstall: 0
 };
 /** The three flags that say what is being acted on, and the field each becomes. */
 var TARGETS = {
@@ -62,7 +72,8 @@ var TARGETS = {
 var OPERATIONS = {
 	"--fresh": ["fresh", "reviews the target again, keeping the review that exists"],
 	"--update": ["update", "brings the existing review up to date with new commits"],
-	"--reanalyse": ["reanalyse", "analyses the same commit again, for a fresh judgement"]
+	"--reanalyse": ["reanalyse", "analyses the same commit again, for a fresh judgement"],
+	"--delete": ["delete", "removes the review and everything it was made in"]
 };
 function parse(argv) {
 	if (argv.length === 0) return { name: "help" };
@@ -107,6 +118,10 @@ function parse(argv) {
 		name: "error",
 		message: strayArgument(positional[0])
 	};
+	if (head === "uninstall" && positional[0]) return {
+		name: "error",
+		message: `\`uninstall\` removes everything on this machine, so it takes no target and \`${positional[0]}\` means nothing to it. It takes \`--keep-reviews\`, \`--yes\` and \`--force\`.`
+	};
 	const allowed = POSITIONALS[head] ?? 1;
 	if (positional.length > allowed) return {
 		name: "error",
@@ -126,9 +141,16 @@ function parse(argv) {
 			...target ? { [TARGETS[target]]: values[target] } : {},
 			...values["--base"] ? { base: values["--base"] } : {},
 			...values["--agent"] ? { agentId: values["--agent"] } : {},
-			...operation ? { operation: OPERATIONS[operation][0] } : {}
+			...operation ? { operation: OPERATIONS[operation][0] } : {},
+			...flags.has("--yes") ? { yes: true } : {}
 		};
 	}
+	if (head === "uninstall") return {
+		name: "uninstall",
+		yes: flags.has("--yes"),
+		force: flags.has("--force"),
+		keepReviews: flags.has("--keep-reviews")
+	};
 	if (head === "agents") return {
 		name: "agents",
 		...first ? { id: first } : {}
@@ -180,10 +202,18 @@ function refuseCombination(values, flags) {
 		return `\`${one}\` ${OPERATIONS[one][1]}, and \`${two}\` ${OPERATIONS[two][1]}. Ask for one of them.`;
 	}
 	if (values["--pr"] && values["--base"]) return "A pull request is compared against the branch it is asking to merge into, so `--base` would stop the diff being the pull request's. To compare its branch against something else, review the branch: `prreviewbuddy review --branch <branch> --base <ref>`.";
+	if (flags.has("--delete")) {
+		if (!values["--review"]) {
+			const named = values["--branch"] ?? values["--pr"];
+			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 (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"]) {
 		if (values["--base"]) return "A review's base is settled when it is made and is part of what identifies it, so `--base` cannot move it. Review the branch against that base instead, and you will have both.";
 		if (flags.has("--fresh")) return `\`--fresh\` makes another review of a target, and \`--review ${values["--review"]}\` names a review rather than a target. Name the branch or the pull request you want reviewed again.`;
-		if (!flags.has("--update") && !flags.has("--reanalyse")) return `\`--review ${values["--review"]}\` says which review but not what to do with it. To read it, run \`prreviewbuddy open ${values["--review"]}\`; to act on it, add \`--update\` or \`--reanalyse\`.`;
+		if (!flags.has("--update") && !flags.has("--reanalyse") && !flags.has("--delete")) return `\`--review ${values["--review"]}\` says which review but not what to do with it. To read it, run \`prreviewbuddy open ${values["--review"]}\`; to act on it, add \`--update\`, \`--reanalyse\` or \`--delete\`.`;
 	}
 	return null;
 }
@@ -203,7 +233,7 @@ function strayArgument(argument) {
 }
 function unknownCommand(head) {
 	if (head === "update") return "Updating a review is something you do to a target now, rather than a command of its own. Run `prreviewbuddy review --update` for the branch you are on, or `prreviewbuddy review --branch feat/foo --update` for one you are not.";
-	return `There is no \`${head}\` command. This does four things: review, open, agents and config. Run \`prreviewbuddy --help\` for what each one takes.`;
+	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/workspace/agent_preference.ts
@@ -554,167 +584,31 @@ function describeMovement(existing) {
 	return `${subject} has moved ${existing.commitsBehind} commit${existing.commitsBehind === 1 ? "" : "s"} since.`;
 }
 //#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;
-/**
-* Two forms per phase, because a finished step and a running one are different sentences.
-*
-* The page says these differently again (`job_view.ts`), and deliberately: it is describing a
-* review to someone who arrived after the fact, while this is narrating one to someone watching it
-* happen. Sharing the strings would force one of the two to read wrongly.
-*/
-var PHASES = {
-	preparing: {
-		doing: "Preparing isolated checkout",
-		done: "Prepared isolated checkout"
-	},
-	context: {
-		doing: "Reading what changed",
-		done: "Read what changed"
-	},
-	conversation: {
-		doing: "Reading pull request conversation",
-		done: "Read pull request conversation"
-	},
-	analysing: {
-		doing: "Analysing the change",
-		done: "Analysed the change"
-	},
-	done: {
-		doing: "Finishing",
-		done: "Finished"
-	},
-	failed: {
-		doing: "Stopped",
-		done: "Stopped"
-	}
-};
+//#region src/confirm.ts
 /**
-* Colour only where it means something, and never where it cannot be seen.
+* A yes or no, asked only when there is somebody to answer.
 *
-* `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) {
-	const meta = `${target.sha.slice(0, 7)} · isolated checkout · ${target.originRepoPath}`;
-	return [
-		`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.
+* 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.
 *
-* 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.
+* 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.
 */
-function phaseLines(job, colour) {
-	const lines = [];
-	const failedAt = job.phase === "failed" ? job.failure?.phase : void 0;
-	for (const phase of WORK_PHASES) {
-		const complete = job.completed.includes(phase) || job.phase === "done";
-		const failed = failedAt === phase;
-		const current = !complete && !failed && job.phase === phase;
-		const mark = failed ? "✕" : complete ? "✓" : current ? "⟳" : " ";
-		const label = complete || failed ? PHASES[phase].done : PHASES[phase].doing;
-		const paint = failed ? RED : complete ? GREEN : "";
-		if (!complete && !current && !failed) {
-			lines.push(colour ? `${DIM}  ${mark} ${label}${RESET}` : `  ${mark} ${label}`);
-			continue;
-		}
-		lines.push(colour && paint ? `${paint}${mark}${RESET} ${label}` : `${mark} ${label}`);
-		if (current && job.progress && !restates(job.progress, label)) lines.push(colour ? `${DIM}    ${job.progress}${RESET}` : `    ${job.progress}`);
+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();
 	}
-	return lines;
-}
-/** Same words as the phase heading, give or take the articles and the trailing full stop. */
-function restates(note, label) {
-	const bare = (text) => text.toLowerCase().replace(/\bthe\b/g, "").replace(/[^a-z]/g, "");
-	return bare(note) === bare(label);
-}
-/**
-* 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(target, colour), ...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/text.ts
@@ -761,6 +655,8 @@ your own checkout is never read or written while it works.
   prreviewbuddy review --fresh            review the target again, keeping the existing review
   prreviewbuddy review --review <review> --update
                                           act on one review by its review ID
+  prreviewbuddy review --review <review> --delete
+                                          delete one review and its isolated checkouts
 
   prreviewbuddy open                      list your reviews and open the index
   prreviewbuddy open <review>             open a review by its review ID
@@ -770,11 +666,16 @@ your own checkout is never read or written while it works.
   prreviewbuddy config get agent          the coding agent used when you do not name one
   prreviewbuddy config set agent <agent>  remember ${AGENT_NAMES}
 
+  prreviewbuddy uninstall                 remove everything this put on your machine
+  prreviewbuddy uninstall --keep-reviews  keep your reviews and settings, clear the rest
+
 Anything in the first group says what to review. Anything in the second says what to do to it, and
 they go together: \`prreviewbuddy review --branch feat/foo --update\` brings the review of feat/foo up
-to date without checking it out. A review ID is the identifier in a workspace URL, which
-\`prreviewbuddy open\` prints for each one, and you need it only to tell two reviews of one branch
-apart.
+to date without checking it out. \`prreviewbuddy open\` prints a review ID beside each review, and
+you need one to tell two reviews of the same branch apart or to delete one. Deleting a review
+removes its record and the checkouts it was made in, and never touches your branch or its commits.
+
+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
 and that agent's existing authentication, and nothing here ever asks you for a credential.
@@ -1035,8 +936,19 @@ function noReviews() {
 * The position appears only where there is something to position against. "Review 1 of 1" on the
 * common case is noise dressed as precision.
 */
+/**
+* The reviews, with the ID said out loud.
+*
+* The ID used to be visible only as a fragment of the URL below it, which was fine while it was
+* optional: `--review` is a tiebreaker and `open` works without one. Deleting a review requires it,
+* so a person now has to be able to read one off without dissecting a link, and this is where they
+* are already standing when they want it.
+*
+* Above the URL rather than below, because the URL is the long line: a label sitting under it reads
+* as belonging to whatever comes next.
+*/
 function reviewList(reviews) {
-	return reviews.map((review) => `${review.summary.branch}  ${review.summary.title}\n  ${describeListed(review)}\n  ${review.url}`).join("\n\n");
+	return reviews.map((review) => `${review.summary.branch}  ${review.summary.title}\n  ${describeListed(review)}\n  Review ID: ${review.summary.id}\n  ${review.url}`).join("\n\n");
 }
 /**
 * Answered in the order the questions get asked, which is the order the browser's card answers
@@ -1103,6 +1015,155 @@ function updateFinished(outcome, url, acted) {
 function count(value, noun) {
 	return `${value} ${noun}${value === 1 ? "" : "s"}`;
 }
+/**
+* What `uninstall` says, and the one rule running through all of it: say what happened to the
+* machine, not what this program did internally.
+*
+* A reviewer removing a tool is at the least invested they will ever be in its vocabulary, so
+* nothing here mentions jobs, claims, drivers, the store or the daemon. It mentions their reviews,
+* their settings, the checkouts and the repositories, because those are things they own.
+*/
+/**
+* The refusal when a review is still being made.
+*
+* Names the branch, because "a job is running" sends somebody to a process list to find out which
+* of their afternoon's work is at stake. Both ways out are offered in the same breath: the one that
+* costs nothing is first, and the one that costs the analysis says plainly that it stops it.
+*/
+function uninstallRunning(running) {
+	return [
+		`${running.length === 1 ? `A review of ${running[0].branch} is still being made` : `${count(running.length, "review")} are still being made (${running.map((one) => one.branch).join(", ")})`}, so nothing was removed.`,
+		"",
+		"Wait for it to finish, or run `prreviewbuddy uninstall --force` to stop it and uninstall anyway."
+	].join("\n");
+}
+/** What is about to go, in the reviewer's own terms, and the question. */
+function uninstallPlan(keepReviews) {
+	return keepReviews ? [
+		"This clears the isolated checkouts and the workspace server, and cleans up the git",
+		"bookkeeping in the repositories PR Review Buddy has reviewed.",
+		"",
+		"Your reviews and settings stay in ~/.prreviewbuddy."
+	].join("\n") : [
+		"This removes every review on this machine, your settings, the isolated checkouts, and the",
+		"git bookkeeping PR Review Buddy left in the repositories it has reviewed.",
+		"",
+		"It cannot be undone."
+	].join("\n");
+}
+/** The question itself, kept separate so the prompt reads as one line whatever precedes it. */
+var UNINSTALL_QUESTION = "Continue?";
+/**
+* A review that is still being analysed, and cannot be deleted yet.
+*
+* Names the branch rather than a job or a pid, because that is the thing the person recognises, and
+* offers no way past it. Deleting a record and stopping an analysis are separate decisions and only
+* one of them was asked for: `uninstall --force` exists because tearing the whole runtime down is a
+* coherent thing to want, and there is no equivalent want here.
+*
+* The review would come back anyway. A driver holds the review in memory for the length of the
+* analysis and writes it back when it finishes, so a deletion now is a deletion the reviewer would
+* watch undo itself, which is worse than being told to wait.
+*/
+function deleteRunning(branch) {
+	return [
+		`A review of ${branch} is still being analysed, so nothing was deleted.`,
+		"",
+		"Wait for it to finish, then delete it. There is no way to delete a review out from under the",
+		"analysis making it."
+	].join("\n");
+}
+/** What is about to go, before the question. Said in the reviewer's terms, not the store's. */
+function deletePlan(summary) {
+	return [
+		`This deletes the review of ${summary.branch} from ${relativeTime(summary.createdAt)}, along`,
+		"with the isolated checkouts it was made in.",
+		"",
+		"Your branch and its commits are untouched. It cannot be undone."
+	].join("\n");
+}
+/** The question itself, kept separate so the prompt reads as one line whatever precedes it. */
+var DELETE_QUESTION = "Delete it?";
+function deleteUnattended(id) {
+	return `Deleting a review asks for confirmation, and there is nothing here to ask. Run \`prreviewbuddy review --review ${id} --delete --yes\` if you meant it.`;
+}
+function deleteCancelled() {
+	return "Nothing was deleted.";
+}
+/**
+* What went.
+*
+* The checkouts are counted because they are the part with a size: a review's record is small and
+* the working trees beside it are the repository over again. A refusal from the removal guard is
+* printed verbatim, because it names a directory somebody has to look at.
+*/
+function deleteFinished(report) {
+	const lines = [report.worktreesRemoved > 0 ? `Deleted, along with ${count(report.worktreesRemoved, "isolated checkout")}.` : "Deleted."];
+	if (report.refusals.length > 0) lines.push("", ...report.refusals);
+	return lines.join("\n");
+}
+/** Asked to delete something that is not there. Not a failure: it is the state they wanted. */
+function deleteAlreadyGone(id) {
+	return `There is no review called ${id}, so there was nothing to delete.`;
+}
+/**
+* Piped, redirected, or in a script, where a question is a hang rather than a question.
+*
+* Says which flag, because the alternative is a person discovering the flag by reading `--help` for
+* a command they have already decided to run.
+*/
+function uninstallUnattended() {
+	return "Uninstalling asks for confirmation, and there is nothing here to ask. Run `prreviewbuddy uninstall --yes` if you meant it.";
+}
+function uninstallCancelled() {
+	return "Nothing was removed.";
+}
+/**
+* What was done, and then the one thing left to do.
+*
+* The npm line is last and is not run for them. A binary that deletes its own package while running
+* from inside it is at the mercy of whichever package manager put it there, and the failure mode is
+* a half-removed install nobody can diagnose. Printing the line costs the reader one paste and
+* costs nobody a broken machine.
+*/
+function uninstallFinished(report, keepReviews, packageName) {
+	const lines = [];
+	const cleaned = [];
+	if (report.worktreesRemoved > 0) cleaned.push(`removed ${count(report.worktreesRemoved, "isolated checkout")}`);
+	if (report.repositoriesPruned.length > 0) {
+		const repositories = report.repositoriesPruned.length;
+		cleaned.push(`cleaned up ${repositories} ${repositories === 1 ? "repository" : "repositories"}`);
+	}
+	if (keepReviews) {
+		lines.push(cleaned.length > 0 ? `${cap(cleaned.join(", and "))}.` : "There was no runtime state to clear.");
+		lines.push("Your reviews and settings are still in ~/.prreviewbuddy.");
+	} else if (report.storeRemoved) {
+		lines.push(cleaned.length > 0 ? `${cap(cleaned.join(", and "))}.` : "PR Review Buddy is removed.");
+		lines.push("~/.prreviewbuddy is gone.");
+	} else lines.push("There was nothing to remove: PR Review Buddy is keeping nothing on this machine.");
+	if (report.refusals.length > 0) {
+		const left = report.refusals.length === 1 ? "One thing was" : `${count(report.refusals.length, "thing")} were`;
+		lines.push("", `${left} left alone, and each says why:`, ...report.refusals.map((one) => `  ${one}`));
+	}
+	lines.push("", "To remove the command itself:", `  npm rm -g ${packageName}`);
+	return lines.join("\n");
+}
+/**
+* What somebody sees the first time they run this, above whatever they asked for.
+*
+* Short because they typed a command rather than asking to be onboarded. Two lines of it, both
+* pointing at somewhere fuller, and then out of the way for the rest of the install's life. It
+* names the version because the next thing this person does about a problem is quote a number.
+*/
+function firstRun(version) {
+	return [
+		`PR Review Buddy ${version}`,
+		"",
+		"  prreviewbuddy agents   which coding agents you have",
+		"  prreviewbuddy --help   everything it does",
+		""
+	].join("\n");
+}
 //#endregion
 //#region src/write.ts
 /**
@@ -1118,6 +1179,228 @@ function err(text) {
 	process.stderr.write(`${text}\n`);
 }
 //#endregion
+//#region src/commands/delete_review.ts
+/**
+* `prreviewbuddy review --review <review> --delete`.
+*
+* An operation on the review axis rather than a command of its own, because that is what it is:
+* one target, one operation, the same sentence shape as `--update` and `--reanalyse`. A top-level
+* `delete` would have needed its own way of saying which review, and there is already one.
+*
+* **The target must be an ID.** `--branch feat/foo --delete` is refused in the parser, and the
+* reason is `--fresh`: reviewing a branch twice on purpose leaves two reviews of it, so a branch
+* names a set rather than a review. Every other operation can pick the newest and be right, because
+* updating the wrong one of two is a wasted minute. Deleting the wrong one is the work.
+*
+* The order is the design, and it is `uninstall`'s: is anything running, then does the person mean
+* it, then act. Nothing on disk is touched before both answers are in.
+*/
+var REAL$1 = {
+	load: (id) => loadWorkspace(id),
+	liveJobs: (id) => liveJobsFor(id),
+	ask: (question) => confirm({
+		question,
+		isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+		input: process.stdin,
+		write: (chunk) => process.stderr.write(chunk)
+	}),
+	remove: (id) => deleteReview$1(id)
+};
+async function deleteReview(command, deps = REAL$1) {
+	const id = command.reviewId;
+	const workspace = deps.load(id);
+	if (!workspace) {
+		out(deleteAlreadyGone(id));
+		return 0;
+	}
+	const running = deps.liveJobs(id);
+	if (running.length > 0) {
+		err(deleteRunning(running[0]?.job.target.branch ?? workspace.changeSet.headRef));
+		return 1;
+	}
+	if (!command.yes) {
+		err(deletePlan({
+			branch: workspace.changeSet.headRef,
+			createdAt: workspace.createdAt
+		}));
+		err("");
+		const answer = await deps.ask(DELETE_QUESTION);
+		if (answer.kind === "unattended") {
+			err(deleteUnattended(id));
+			return 1;
+		}
+		if (answer.kind === "no") {
+			err(deleteCancelled());
+			return 1;
+		}
+	}
+	out(deleteFinished(await deps.remove(id)));
+	return 0;
+}
+//#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;
+/**
+* Two forms per phase, because a finished step and a running one are different sentences.
+*
+* The page says these differently again (`job_view.ts`), and deliberately: it is describing a
+* review to someone who arrived after the fact, while this is narrating one to someone watching it
+* happen. Sharing the strings would force one of the two to read wrongly.
+*/
+var PHASES = {
+	preparing: {
+		doing: "Preparing isolated checkout",
+		done: "Prepared isolated checkout"
+	},
+	context: {
+		doing: "Reading what changed",
+		done: "Read what changed"
+	},
+	conversation: {
+		doing: "Reading pull request conversation",
+		done: "Read pull request conversation"
+	},
+	analysing: {
+		doing: "Analysing the change",
+		done: "Analysed the change"
+	},
+	done: {
+		doing: "Finishing",
+		done: "Finished"
+	},
+	failed: {
+		doing: "Stopped",
+		done: "Stopped"
+	}
+};
+/**
+* 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) {
+	const meta = `${target.sha.slice(0, 7)} · isolated checkout · ${target.originRepoPath}`;
+	return [
+		`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.
+*/
+function phaseLines(job, colour) {
+	const lines = [];
+	const failedAt = job.phase === "failed" ? job.failure?.phase : void 0;
+	for (const phase of WORK_PHASES) {
+		const complete = job.completed.includes(phase) || job.phase === "done";
+		const failed = failedAt === phase;
+		const current = !complete && !failed && job.phase === phase;
+		const mark = failed ? "✕" : complete ? "✓" : current ? "⟳" : " ";
+		const label = complete || failed ? PHASES[phase].done : PHASES[phase].doing;
+		const paint = failed ? RED : complete ? GREEN : "";
+		if (!complete && !current && !failed) {
+			lines.push(colour ? `${DIM}  ${mark} ${label}${RESET}` : `  ${mark} ${label}`);
+			continue;
+		}
+		lines.push(colour && paint ? `${paint}${mark}${RESET} ${label}` : `${mark} ${label}`);
+		if (current && job.progress && !restates(job.progress, label)) lines.push(colour ? `${DIM}    ${job.progress}${RESET}` : `    ${job.progress}`);
+	}
+	return lines;
+}
+/** Same words as the phase heading, give or take the articles and the trailing full stop. */
+function restates(note, label) {
+	const bare = (text) => text.toLowerCase().replace(/\bthe\b/g, "").replace(/[^a-z]/g, "");
+	return bare(note) === bare(label);
+}
+/**
+* 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(target, colour), ...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`.
@@ -1141,6 +1424,7 @@ function err(text) {
 * and it is the same `findExistingReview` the default operation already asked.
 */
 async function review(command, repoPath) {
+	if (command.operation === "delete") return deleteReview(command);
 	if (command.reviewId) {
 		const workspace = loadWorkspace(command.reviewId);
 		if (!workspace) {
@@ -1531,6 +1815,365 @@ function config(command) {
 	return 0;
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/uninstall.ts
+/**
+* Undoing an install, which is more than deleting a directory.
+*
+* Everything this product keeps on a machine is under `STORE_ROOT`, with one exception, and the
+* exception is the whole reason this file exists: `git worktree add` writes an admin entry into the
+* repository being reviewed, so a reviewer who deletes `~/.prreviewbuddy` by hand is left with
+* entries pointing at nothing, in repositories nobody told them we had touched. They would have to
+* discover that from `git worktree list` in a repository they had no reason to suspect.
+*
+* So the order here is not decoration. Worktrees are removed while the records that name them still
+* exist, because those records are the only thing that says which repositories to clean and which
+* directory belonged to which. Delete the store first and the information needed to finish the job
+* is gone with it.
+*
+* **On deleting.** `worktree.ts` is the module that deletes, and it stays that: every managed
+* checkout here goes through `removeWorktree` and its guard, not through a recursive remove that
+* happens to know a path. The one removal this file performs itself is `STORE_ROOT`, and the
+* evidence it rests on is different in kind: that path is not derived from a record, a repository,
+* an argument or anything else that could be wrong. It is `homedir()` joined to a constant, it is
+* ours by construction, and removing it is the entire thing the reviewer asked for.
+*
+* Nothing here prints. The copy lives in the surface that calls it.
+*/
+/**
+* End the processes making those reviews. `--force` only, and never reached by default.
+*
+* A claim written on another host says nothing about a pid here, which is the same reasoning
+* `job_claim.ts:ownerAlive` states: `~/.prreviewbuddy` can sit on a synced home directory. Those are
+* left alone; the claim is cleared regardless, because the store it lives in is about to go.
+*
+* SIGTERM to the driver, and no further. The coding agent is that driver's child and may outlive it
+* by moments, with nothing left to write into; chasing a process group would buy a tidier `ps` at
+* the cost of a signal delivery this file cannot make portable.
+*/
+function stopDrivers(running) {
+	let stopped = 0;
+	for (const { job, claim } of running) {
+		if (claim.host === hostname()) try {
+			process.kill(claim.pid, "SIGTERM");
+			stopped += 1;
+		} catch {}
+		clearClaim(job.id);
+	}
+	return stopped;
+}
+/**
+* Every repository this machine has a record of having reviewed.
+*
+* Three sources because they expire at different rates and any one of them can be the last witness.
+* A job record is deleted six hours after the review finishes; a worktree marker goes with its
+* directory; a review is kept for thirty days. The reviews are usually the only thing left, and a
+* repository we cannot name is a repository we cannot clean.
+*/
+function touchedRepositories() {
+	const paths = [
+		...allJobs().map((job) => job.target.originRepoPath),
+		...managedDirectories().flatMap((path) => {
+			const marker = readMarker(path);
+			return marker ? [marker.originRepoPath] : [];
+		}),
+		...reviewedRepositories()
+	];
+	return [...new Set(paths.filter(Boolean).map((path) => resolve(path)))];
+}
+/** Directories under the managed root, or none if there is no managed root. */
+function managedDirectories() {
+	try {
+		return readdirSync(MANAGED_ROOT).map((name) => join(MANAGED_ROOT, name)).filter((path) => {
+			try {
+				return statSync(path).isDirectory();
+			} catch {
+				return false;
+			}
+		});
+	} catch {
+		return [];
+	}
+}
+/**
+* Remove every managed checkout, through the guard that owns removal.
+*
+* Both sources again: the job records name the directories that jobs still know about, and the
+* managed root holds the ones whose record has already gone. A directory reachable both ways is
+* removed once, and the second attempt would refuse rather than delete something else, so the
+* deduplication is for the report rather than for safety.
+*
+* `minAgeMs: 0` because the caller has established that nothing is running. See `removeWorktree`.
+*/
+async function removeAllWorktrees() {
+	const fromJobs = allJobs().flatMap((job) => job.worktreePath ? [{
+		path: job.worktreePath,
+		repo: job.target.originRepoPath
+	}] : []);
+	const fromDisk = managedDirectories().flatMap((path) => {
+		const marker = readMarker(path);
+		return marker ? [{
+			path,
+			repo: marker.originRepoPath
+		}] : [];
+	});
+	const seen = /* @__PURE__ */ new Set();
+	let removed = 0;
+	const refusals = [];
+	for (const candidate of [...fromJobs, ...fromDisk]) {
+		const path = resolve(candidate.path);
+		if (seen.has(path)) continue;
+		seen.add(path);
+		if (!existsSync(path)) continue;
+		const outcome = await removeWorktree({
+			originRepoPath: candidate.repo,
+			worktreePath: path,
+			minAgeMs: 0
+		});
+		if (outcome.removed) removed += 1;
+		else refusals.push({
+			path,
+			message: outcome.message
+		});
+	}
+	return {
+		removed,
+		refusals
+	};
+}
+/**
+* Clear the bookkeeping git keeps about worktrees of ours that no longer exist.
+*
+* Scoped by asking first. `git worktree prune` takes no path and drops every registered worktree
+* whose directory has gone, which in somebody else's repository may include one of theirs, so it is
+* run only where the listing shows a missing worktree inside our own managed root. A repository
+* with none of ours to clean is never touched at all.
+*
+* This is the step that clears a checkout which vanished without git being told: a retirement that
+* was interrupted, a directory somebody deleted themselves, a machine that lost power. What it
+* cannot do is help a reviewer who has already deleted the whole store, because the records naming
+* their repositories went with it and nothing left on the machine knows where to look. That is the
+* argument for this command existing rather than for a paragraph in a README.
+*/
+async function pruneStale(repositories) {
+	const pruned = [];
+	for (const repository of repositories) try {
+		if (!(await git(repository, [
+			"worktree",
+			"list",
+			"--porcelain"
+		])).split("\n").some((line) => isOurMissingWorktree(line))) continue;
+		await git(repository, ["worktree", "prune"]);
+		pruned.push(repository);
+	} catch {}
+	return pruned;
+}
+/** A `worktree <path>` line from the porcelain listing, naming a directory of ours that is gone. */
+function isOurMissingWorktree(line) {
+	if (!line.startsWith("worktree ")) return false;
+	const path = resolve(line.slice(9).trim());
+	return isInside(path, realManagedRoot()) && !existsSync(path);
+}
+/**
+* The managed root as git would have written it, whether or not it is still there.
+*
+* By the time this runs the store has usually been removed, so the root cannot simply be resolved:
+* `realpathSync` throws on a path that is gone, and falling back to the unresolved spelling is how
+* this quietly stopped matching anything at all. Resolving the deepest ancestor that does exist,
+* the home directory at worst, gives the same answer with the directory present or absent.
+*/
+function realManagedRoot() {
+	const resolved = resolve(MANAGED_ROOT);
+	let existing = resolved;
+	const missing = [];
+	while (!existsSync(existing)) {
+		const parent = dirname(existing);
+		if (parent === existing) return resolved;
+		missing.unshift(basename(existing));
+		existing = parent;
+	}
+	try {
+		return join(realpathSync(existing), ...missing);
+	} catch {
+		return resolved;
+	}
+}
+function isInside(path, root) {
+	return path === root || path.startsWith(`${root}/`) || path.startsWith(`${root}\\`);
+}
+/**
+* What a reviewer means by runtime state, which is what `--keep-reviews` removes.
+*
+* Named removals rather than a keep-list, and the direction is the point: a file some later version
+* of this product puts in the store is kept by a build that has never heard of it. The other way
+* round deletes somebody's data to satisfy a list written before the data existed.
+*
+* So what stays is everything else, and today that means their reviews (`workspaces`,
+* `reviews.html`), their settings (`config.json`, `prompts.json`) and the two records of having
+* been told something once (`onboarding-shown`, `telemetry-notice-shown`). Those last two are not
+* runtime state: it is the same person on the same machine, they have read both notices, and
+* showing either again would be this product forgetting a conversation rather than clearing one.
+* The usage log itself (`events.jsonl`) does go, because that is data about them rather than a note
+* to ourselves.
+*/
+var RUNTIME_ENTRIES = [
+	"jobs",
+	"claims",
+	"worktrees",
+	"no-hooks",
+	"server.json",
+	"server.lock",
+	"events.jsonl"
+];
+/**
+* Remove the store, or the ephemeral half of it.
+*
+* The only unguarded deletion in the product, and the only path it will ever name. See the note at
+* the top of this file for what that rests on.
+*/
+function removeStore(options) {
+	if (!existsSync(STORE_ROOT)) return {
+		removed: false,
+		kept: []
+	};
+	if (!options.keepReviews) {
+		rmSync(STORE_ROOT, {
+			recursive: true,
+			force: true
+		});
+		return {
+			removed: true,
+			kept: []
+		};
+	}
+	for (const entry of RUNTIME_ENTRIES) rmSync(join(STORE_ROOT, entry), {
+		recursive: true,
+		force: true
+	});
+	return {
+		removed: false,
+		kept: readdirSync(STORE_ROOT)
+	};
+}
+/**
+* The removal itself, once the decision to do it has been taken.
+*
+* Stopping the server and stopping any driver happen before this and belong to the surface, because
+* they are what the reviewer was asked about. What is left is mechanical and ordered: clean the
+* repositories while the records still name them, then remove the records.
+*/
+async function cleanUp(options) {
+	const repositories = touchedRepositories();
+	const worktrees = await removeAllWorktrees();
+	const store = removeStore({ keepReviews: options.keepReviews });
+	const repositoriesPruned = await pruneStale(repositories);
+	return {
+		worktreesRemoved: worktrees.removed,
+		repositoriesPruned,
+		refusals: worktrees.refusals.filter((refusal) => existsSync(refusal.path)).map((refusal) => refusal.message),
+		kept: store.kept,
+		storeRemoved: store.removed
+	};
+}
+//#endregion
+//#region src/commands/uninstall.ts
+/**
+* `prreviewbuddy uninstall`.
+*
+* The order is the design. Nothing is touched before the two questions have been answered: is any
+* work in progress, and does the person actually mean it. After that the sequence is fixed by what
+* each step needs from the one before, and `cleanUp` holds that half.
+*
+* It stops the workspace server, which the help screen says on purpose there is no command to do.
+* That is not a hole in the rule but the end of it: "no command to stop the server" exists so that
+* a review outlives the terminal that asked for it, and there are no reviews left to outlive
+* anything here.
+*
+* What it does not do is remove its own npm package. A running binary deleting the install it is
+* executing from depends on which package manager put it there and fails in ways that leave a
+* half-removed command behind, so the last thing printed is the line to type. See
+* `text.uninstallFinished`.
+*/
+var REAL = {
+	runningJobs: () => runningJobs(),
+	ask: (question) => confirm({
+		question,
+		isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+		input: process.stdin,
+		write: (chunk) => process.stderr.write(chunk)
+	}),
+	stopServer: () => {
+		stopServer();
+	},
+	stopDrivers: (running) => {
+		stopDrivers(running);
+	},
+	cleanUp: (options) => cleanUp(options)
+};
+async function uninstall(command, deps = REAL) {
+	const running = deps.runningJobs();
+	if (running.length > 0 && !command.force) {
+		err(uninstallRunning(running.map((one) => ({ branch: one.job.target.branch }))));
+		return 1;
+	}
+	if (!command.yes) {
+		err(uninstallPlan(command.keepReviews));
+		err("");
+		const answer = await deps.ask(UNINSTALL_QUESTION);
+		if (answer.kind === "unattended") {
+			err(uninstallUnattended());
+			return 1;
+		}
+		if (answer.kind === "no") {
+			err(uninstallCancelled());
+			return 1;
+		}
+	}
+	deps.stopServer();
+	if (running.length > 0) deps.stopDrivers(running);
+	out(uninstallFinished(await deps.cleanUp({ keepReviews: command.keepReviews }), command.keepReviews, PACKAGE_NAME));
+	return 0;
+}
+//#endregion
+//#region src/first_run.ts
+/**
+* The two lines somebody needs the first time they run this, and never again.
+*
+* This began as a `postinstall` script, which is the obvious place for it and the wrong one: npm 11
+* does not run install scripts unless they are allow-listed, so the banner would have reached
+* almost nobody, and its mere presence in the manifest adds an install-scripts warning to every
+* install of a package that asks for nothing and holds no credential. That is a bad trade in both
+* directions.
+*
+* The first command is a better moment anyway. It reaches every user however they installed this,
+* and it arrives while they are using the product rather than while they are watching a package
+* manager count files.
+*
+* A marker file rather than a flag in `config.json`: that file holds settings a person may edit,
+* and this is not a setting. It is a fact about the machine, of the same kind and in the same place
+* as the telemetry notice next to it. A home directory that cannot be written to costs somebody a
+* repeated banner and never a review, which is why nothing here throws.
+*/
+var MARKER = join(STORE_ROOT, "onboarding-shown");
+/**
+* Whether this machine has been greeted.
+*
+* Unreadable reads as greeted. Getting this wrong in one direction repeats a banner, and in the
+* other it prints one over somebody's output every single time, so the failure goes quiet.
+*/
+function greeted() {
+	try {
+		return existsSync(MARKER);
+	} catch {
+		return true;
+	}
+}
+function recordGreeting() {
+	try {
+		mkdirSync(STORE_ROOT, { recursive: true });
+		writeFileSync(MARKER, `${(/* @__PURE__ */ new Date()).toISOString()}\n`, { mode: 384 });
+	} catch {}
+}
+//#endregion
 //#region src/main.ts
 /**
 * PR Review Buddy at the command line.
@@ -1545,8 +2188,27 @@ function config(command) {
 * asks for one. There is a little configuration now, and it holds a preference rather than a
 * secret: which agent to use when you do not name one.
 */
+/**
+* The one-off hello, printed above the first command somebody runs and never again.
+*
+* Not for `--help`, which is the fuller version of what it says, and not for `uninstall`, where
+* greeting somebody on their way out would be a joke at their expense. To stderr, like every other
+* line that is not a result, so `prreviewbuddy review | pbcopy` still copies a URL.
+*/
+var GREETED = [
+	"review",
+	"open",
+	"agents",
+	"config"
+];
+function greet(command) {
+	if (!GREETED.includes(command.name) || greeted()) return;
+	err(firstRun(BUILD_VERSION));
+	recordGreeting();
+}
 async function main(argv) {
 	const command = parse(argv);
+	greet(command);
 	switch (command.name) {
 		case "help":
 			out(HELP);
@@ -1561,6 +2223,7 @@ async function main(argv) {
 		case "open": return open(command);
 		case "agents": return agents(command);
 		case "config": return config(command);
+		case "uninstall": return uninstall(command);
 	}
 }
 process.exitCode = await main(process.argv.slice(2)).catch((error) => {