prreviewbuddy 0.31.0 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,82 @@
 # Changelog
 
+## 0.34.0
+
+**The Guide shows one theme at a time.** The workspace Guide used to stack every theme in one
+column, so reading the second one meant scrolling past the whole of the first. The rail already
+lists the themes, so it now drives the page: choosing one shows that theme on its own, and the
+rail says how long each is likely to take. The theme tag on an issue or question opens its theme,
+which it always named and never did. In a window too narrow for the rail, the same themes appear
+above the theme itself.
+
+A theme now reads in the order the work happens: why it matters, then what to check, then the files
+it touches. That order is better on both surfaces, so the browser extension's Guide gets it too, and
+is unchanged otherwise. Its parts stand apart rather than running together, and the theme itself is
+no longer drawn as a card: with one theme on the page, the outline had nothing on the other side of
+it. Nothing folds a theme away any more either, since there is now nothing behind it to reveal.
+
+**The rail says what is left, in words.** A theme row gives the time it takes and, when something is
+still open on it, how much: "~22 min, 1 of 2 issues left". That count used to be a bare digit whose
+meaning only a screen reader was told. The file count has gone from the rail, which is what leaves
+room to spell the rest out. Clicking the words "Review path" folds the list, not just the caret.
+
+**The Overview's numbers read as numbers.** Each stat card leads with the figure and sets the label
+beside it, so the four cards line up whether or not one of them carries a second line.
+
+Two things that were wrong wherever you looked. The document pane was painted a slightly different
+grey from the page behind it, leaving a seam down every view. And in a window too narrow for the
+rail, the review was squeezed into the width the rail had vacated, with half the window empty beside
+it.
+
+The progress line no longer counts what it cannot change: completing a theme is part of guided
+review, which the workspace does not have, so the Guide states the size of the job rather than
+reporting nothing done.
+
+## 0.33.0
+
+**A type scale, a palette for the review, and fewer boxes.** Text in the workspace now comes from
+seven named sizes rather than fifteen ad-hoc ones, so a heading, a sentence, a piece of metadata and
+a status chip differ by size instead of by weight, and ordinary text is ordinary weight again. The
+review itself now has its own light palette: three greys where one grey had been written several
+ways, a single hairline where six different border shades were drawing the same line, and one purple
+where there were five. Seven panels that were a box drawn inside another box have lost their
+outline and sit on the page as white cards against a slightly deeper background. Purple now marks
+what you have selected, what has keyboard focus, and the main action on a page, so hovering a row no
+longer shouts as loudly as choosing one. The browser extension is unchanged.
+
+## 0.32.1
+
+**The rail on every workspace page.** The reviews list, Notifications and Settings now carry the
+same rail a review does, so Reviews, Notifications and Settings are always one click away without
+opening a review first. A review's rail keeps everything it had, with the workspace places beneath
+it. The unread count sits beside Notifications wherever the rail is. In a window too narrow for the
+rail, the same places appear in the header instead.
+
+## 0.32.0
+
+**Notifications.** When a review, reanalysis, update or KISS analysis finishes or fails, PR Review
+Buddy now records it on a new Notifications page in the workspace, so you can start a review, or a
+batch of them, get on with something else, and see what finished when you come back. The reviews
+list shows how many are unread, and every review's rail links to the page. Opening a notification
+takes you to its review and marks it read, and Mark all read clears the rest; visiting the review
+some other way leaves it unread. A review you stop with Ctrl-C is not recorded as a failure.
+Notifications are kept for thirty days, on this machine only, and nothing about them is sent
+anywhere.
+
+**Toasts in the workspace.** While any workspace page is open, a notification also appears for a
+few seconds in the bottom-right corner, with Open beside it. It stays while your pointer is on it,
+and no more than three show at once: when a batch finishes together, the last one says how many more
+there are, with View all. Letting a toast go or dismissing it leaves the notification unread on the
+Notifications page.
+
+**Closing the terminal no longer strands a review.** The CLI used to say a review continues if its
+terminal closes. It did not: the review stopped with the terminal, and running the command again
+said it was still being made for the next half hour. The message now asks you to keep the terminal
+open, and running the same command again picks the review up at once from the step it reached.
+
+Also fixed: a review picked up part way through its analysis showed that step as finished while it
+was still running.
+
 ## 0.31.0
 
 **Review a single commit.** `prreviewbuddy review --commit <commit>` reviews the change one commit

package/dist/{delete_review-C2wax0ED.js → delete_review-TNIFNct3.js}

@@ -2759,7 +2759,7 @@ async function resolveTarget(input) {
 			...named
 		};
 	}
-	const branch = await branchOf(root);
+	const branch = await branchOf$1(root);
 	let sha;
 	try {
 		sha = (await git(root, ["rev-parse", "HEAD"])).trim();
@@ -2941,7 +2941,7 @@ async function refuseEmptyTarget(target) {
 async function uncommittedIn(root, target) {
 	if (target.pullRequest) return 0;
 	try {
-		if ((await git(root, ["rev-parse", "HEAD"])).trim() !== target.sha || await branchOf(root) !== target.branch) return 0;
+		if ((await git(root, ["rev-parse", "HEAD"])).trim() !== target.sha || await branchOf$1(root) !== target.branch) return 0;
 		return (await git(root, ["status", "--porcelain"])).split("\n").filter((line) => line.trim()).length;
 	} catch {
 		return 0;
@@ -3023,7 +3023,7 @@ async function repositoryRoot(repoPath) {
 	} catch {}
 	throw new TargetError(`${repoPath} is not inside a git repository.`);
 }
-async function branchOf(root) {
+async function branchOf$1(root) {
 	let branch = "";
 	try {
 		branch = (await git(root, [
@@ -4766,6 +4766,18 @@ function isClaimed(jobId, now = Date.now()) {
 	return liveClaim(jobId, now) !== null;
 }
 /**
+* Whether a driver took this job and is no longer there to finish it.
+*
+* The claim file is the evidence. A job minted a moment ago and not yet driven has no claim at all,
+* and a driver that finished released its claim on the way out, so a claim that is still on disk
+* with nobody live behind it can only belong to a run that ended without finishing: a terminal that
+* closed, a process that was killed. Answered at once rather than after the sweep's half hour,
+* because the reviewer asking is usually the one who just closed that terminal.
+*/
+function driverGone(jobId, now = Date.now()) {
+	return readClaim(jobId) !== null && liveClaim(jobId, now) === null;
+}
+/**
 * Take the claim on a job, or return null because another driver holds it.
 *
 * Two retries fired together, a retry racing the run `startJob` already kicked off, or a retry
@@ -5034,7 +5046,7 @@ function deleteJob(id) {
 }
 function advance(job, phase, progress) {
 	const leaving = job.phase;
-	const completed = WORK_PHASES.includes(leaving) && !job.completed.includes(leaving) ? [...job.completed, leaving] : job.completed;
+	const completed = WORK_PHASES.includes(leaving) && leaving !== phase && !job.completed.includes(leaving) ? [...job.completed, leaving] : job.completed;
 	return {
 		...job,
 		phase,
@@ -9493,6 +9505,229 @@ async function withUsageRecorded(workspaceId, kind, env, body, runId, requestedM
 	}
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/notifications.ts
+/**
+* What happened while the reviewer was looking at something else, kept until they have seen it.
+*
+* **One file per notification, not one list.** Notifications are written by whichever process
+* drove the work to its end: the CLI for a review typed at a terminal, the workspace server for one
+* started from the page, the sweep for one whose driver died. A single `notifications.json` read,
+* modified and written by several processes loses whichever entry was written second, and the lost
+* one is by definition something the reviewer was not watching. `jobs/` is laid out the same way for
+* the same reason.
+*
+* **Created once, with `wx`.** The id is derived from the transition it records, so a second attempt
+* to record the same transition fails at the filesystem and returns null, and a caller that only
+* delivers what it created cannot deliver twice. Nothing that reads a job ever creates one: a page
+* reloading, a client polling or a review being reopened cannot announce anything.
+*
+* Imports only `store_root`, for the cycle `queue.ts` describes.
+*/
+var NOTIFICATIONS_DIR = join(STORE_ROOT, "notifications");
+/** As long as a review is kept, so the list never names a review nobody can open for that reason. */
+var NOTIFICATION_RETENTION_MS = 2592e6;
+var OPERATION_NAMES = {
+	review: "Review",
+	reanalysis: "Reanalysis",
+	update: "Review update",
+	kiss: "KISS analysis"
+};
+/** What happened, in the words the list uses: `Review ready`, `Review update failed`. */
+function eventName(notification) {
+	return `${OPERATION_NAMES[notification.operation]} ${notification.outcome}`;
+}
+/** The whole line, for anything that shows one event on its own: what happened, then to what. */
+function headline(notification) {
+	return `${eventName(notification)} · ${notification.subject}`;
+}
+var OPERATIONS = [
+	"review",
+	"reanalysis",
+	"update",
+	"kiss"
+];
+var OUTCOMES = ["ready", "failed"];
+/** An id is a file name, so it is held to a shape that cannot leave the directory. */
+var ID = /^[A-Za-z0-9-]{1,200}$/;
+function pathOf(id) {
+	return join(NOTIFICATIONS_DIR, `${id}.json`);
+}
+/**
+* Record one event, or return null because it is already recorded or could not be written.
+*
+* Never throws. A notification that could not be written is a notification the reviewer does not
+* get, which is a smaller loss than the review job that was being announced.
+*/
+function createNotification(input, now = Date.now()) {
+	if (!ID.test(input.id)) return null;
+	const record = {
+		version: 1,
+		kind: "analysis",
+		...input,
+		createdAt: now
+	};
+	try {
+		mkdirSync(NOTIFICATIONS_DIR, { recursive: true });
+		writeFileSync(pathOf(input.id), JSON.stringify(record), {
+			flag: "wx",
+			mode: 384
+		});
+		return record;
+	} catch {
+		return null;
+	}
+}
+/** Every notification, newest first. Unreadable and malformed files are skipped, not reported. */
+function listNotifications() {
+	let names;
+	try {
+		names = readdirSync(NOTIFICATIONS_DIR);
+	} catch {
+		return [];
+	}
+	const found = [];
+	for (const name of names) {
+		if (!name.endsWith(".json")) continue;
+		const record = readNotification(name.slice(0, -5));
+		if (record) found.push(record);
+	}
+	return found.sort((a, b) => b.createdAt - a.createdAt || (a.id < b.id ? -1 : 1));
+}
+function readNotification(id) {
+	if (!ID.test(id)) return null;
+	try {
+		const parsed = JSON.parse(readFileSync(pathOf(id), "utf8"));
+		return isNotification(parsed) && parsed.id === id ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function unreadCount() {
+	return listNotifications().filter((notification) => notification.readAt === void 0).length;
+}
+/**
+* Mark these read, and say how many changed.
+*
+* Only ever by something the reviewer did to the notification itself: opening it, or one of the two
+* mark buttons. Opening the review it points at is not the same act and does not come through here.
+*/
+function markRead(ids, now = Date.now()) {
+	let changed = 0;
+	for (const id of ids) {
+		const record = readNotification(id);
+		if (!record || record.readAt !== void 0) continue;
+		try {
+			writeFileSync(pathOf(id), JSON.stringify({
+				...record,
+				readAt: now
+			}), { mode: 384 });
+			changed += 1;
+		} catch {}
+	}
+	return changed;
+}
+function markAllRead(now = Date.now()) {
+	return markRead(listNotifications().filter((notification) => notification.readAt === void 0).map((notification) => notification.id), now);
+}
+/**
+* Forget what is older than the retention, and anything past the cap, oldest first.
+*
+* Files that do not parse are removed once they are as old as the retention, judged by their
+* modification time, so a stray file neither lingers for ever nor disappears the moment it is seen.
+*/
+function pruneNotifications(now = Date.now()) {
+	let names;
+	try {
+		names = readdirSync(NOTIFICATIONS_DIR);
+	} catch {
+		return 0;
+	}
+	const kept = listNotifications();
+	const keep = new Set(kept.filter((notification) => now - notification.createdAt < NOTIFICATION_RETENTION_MS).slice(0, 200).map((notification) => `${notification.id}.json`));
+	const valid = new Set(kept.map((notification) => `${notification.id}.json`));
+	let removed = 0;
+	for (const name of names) {
+		if (!name.endsWith(".json") || keep.has(name)) continue;
+		const path = join(NOTIFICATIONS_DIR, name);
+		try {
+			if (!valid.has(name) && now - statSync(path).mtimeMs < 2592e6) continue;
+			unlinkSync(path);
+			removed += 1;
+		} catch {}
+	}
+	return removed;
+}
+function isNotification(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return record.version === 1 && record.kind === "analysis" && typeof record.id === "string" && OPERATIONS.includes(record.operation) && OUTCOMES.includes(record.outcome) && typeof record.reviewId === "string" && typeof record.subject === "string" && (record.branch === void 0 || typeof record.branch === "string") && typeof record.repo === "string" && typeof record.createdAt === "number" && (record.readAt === void 0 || typeof record.readAt === "number");
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/announce.ts
+/**
+* Tell the reviewer a job ended, once, after the ending has been written.
+*
+* Called by the three places that write an ending: `drive` in `review_job.ts`, `updateReview`, and
+* the sweep for a job whose driver died. Each calls it with the record it has just saved, in the
+* process that saved it, so the answer never depends on who happens to be looking.
+*
+* The id is the job and the moment it ended, so two calls about the same ending make one record,
+* and a job picked up again that ends later is a new event with its own.
+*
+* The record is the event. The Notifications page and the workspace's toasts both read it. Any
+* delivery that has to be pushed rather than read belongs here, after `createNotification`, and only
+* for a record this call created, which carries the once-only guarantee over to it for free. Desktop
+* delivery is written that way and parked outside the product: see `desktop_preference.ts`.
+*
+* Never throws. This runs on the success path of a review that has already been saved, and the
+* accounting must not break the thing it accounts for.
+*/
+function announceJob(job) {
+	try {
+		if (!isTerminal(job) || job.failure?.stopped || purposeOf(job) === "ask") return;
+		const workspace = loadWorkspace(job.workspaceId);
+		if (!workspace) return;
+		const branch = branchOf(workspace);
+		createNotification({
+			id: `${job.id}-${endedAt(job)}`,
+			operation: operationOf(job),
+			outcome: job.phase === "done" ? "ready" : "failed",
+			reviewId: workspace.id,
+			subject: subjectOf(workspace),
+			...branch ? { branch } : {},
+			repo: basename(workspace.repoPath)
+		});
+	} catch {}
+}
+function operationOf(job) {
+	if (job.reviewType === "kiss") return "kiss";
+	if (purposeOf(job) === "update") return "update";
+	return job.reanalysis ? "reanalysis" : "review";
+}
+/**
+* What was reviewed, as the reviewer would name it, and nothing that locates it on disk.
+*
+* A pull request by its number, spelled the way its forge spells it; a commit by its short sha; a
+* branch by the ref it follows, which is the same rule the reviews list and the CLI use.
+*/
+function subjectOf(workspace) {
+	const changeSet = workspace.changeSet;
+	if (changeSet.targetType === "commit") return `commit ${changeSet.data.pullRequest.head.sha.slice(0, 7)}`;
+	const number = changeSet.data.pullRequest?.number || workspace.prContext?.pullRequest.number;
+	if (number) return /\/merge_requests\//.test(workspace.prContext?.pullRequest.url ?? "") ? `MR !${number}` : `PR #${number}`;
+	return followedRefName(changeSet.headRef, changeSet.headResolvedRef) ?? changeSet.headRef;
+}
+/**
+* The branch beside a pull request's number, which alone does not say what the change is. Nothing
+* for a branch review, whose subject already is the branch, or for a commit, which has none.
+*/
+function branchOf(workspace) {
+	const changeSet = workspace.changeSet;
+	if (changeSet.targetType === "commit") return void 0;
+	if (!(changeSet.data.pullRequest?.number || workspace.prContext?.pullRequest.number)) return void 0;
+	return (followedRefName(changeSet.headRef, changeSet.headResolvedRef) ?? changeSet.headRef) || void 0;
+}
+//#endregion
 //#region ../../packages/review-harness/src/telemetry/consent.ts
 /**
 * Who this machine is counted as, and what it has agreed to.
@@ -9815,6 +10050,7 @@ async function reanalyseReview(workspaceId, agentId, onStarted, requestedModel)
 			target,
 			env: agent.captureEnv(),
 			purpose: "review",
+			reanalysis: true,
 			...model ? { requestedModel: model } : {}
 		});
 		saveJob(job);
@@ -10030,6 +10266,7 @@ async function drive(jobId, workspaceId, runners, driver, signal) {
 		else await applyGuide(job, workspaceId, payload, observedModel);
 		job = update(job, "done");
 		finished(job, workspaceId, startedAt, true);
+		announceJob(job);
 		return job;
 	} catch (error) {
 		if (error instanceof AgentCancelledError || signal?.aborted) {
@@ -10043,6 +10280,7 @@ async function drive(jobId, workspaceId, runners, driver, signal) {
 		job = recordFailure(job, explain(job, raw), driver, kind, raw);
 		if (job.reviewType === "kiss") failCurrentKissRun(workspaceId, job, job.failure?.message ?? raw, kind, error instanceof KissRejected ? error.answer : void 0);
 		finished(job, workspaceId, startedAt, false);
+		announceJob(job);
 		return job;
 	}
 }
@@ -11221,10 +11459,14 @@ async function updateReview(workspace, runners = {}) {
 	const step = (phase) => saveJob(advance(current(), phase));
 	try {
 		const outcome = await bringForward(workspace, runners, reviewedSha, held, step);
-		saveJob(outcome.stop === "analysis-failed" ? fail(current(), outcome.message) : advance(current(), "done", outcome.message));
+		const ended = outcome.stop === "analysis-failed" ? fail(current(), outcome.message) : advance(current(), "done", outcome.message);
+		saveJob(ended);
+		announceJob(ended);
 		return outcome;
 	} catch (error) {
-		saveJob(fail(current(), error instanceof Error ? error.message : String(error)));
+		const failed = fail(current(), error instanceof Error ? error.message : String(error));
+		saveJob(failed);
+		announceJob(failed);
 		throw error;
 	} finally {
 		held.claim.release();
@@ -11814,4 +12056,4 @@ function lineageIds(id) {
 	return [.../* @__PURE__ */ new Set([id, ...lineage.map((review) => review.id)])];
 }
 //#endregion
-export { fillFileUrlTemplate as $, writeAgentPreference as $t, removeWorktree as A, workspaceRevision as At, workspaceUrl as B, isQuestionOutstanding as Bt, recordTelemetryUploadConsent as C, previousKissResult as Ct, ReviewBeingDeletedError as D, saveWorkspace as Dt, EXPLAIN_SIMPLY_PROMPT as E, reviewedRepositories as Et, clearServerRecord as F, queueStamp as Ft, DEFAULT_WORKSPACE_PORT as G, describeAuthorship as Gt, BUILD_VERSION as H, questionsOutstanding as Ht, ensureServer as I, readQueue as It, parseWorkspacePort as J, git as Jt, MAX_WORKSPACE_PORT as K, resolveTarget as Kt, readServerRecord as L, writeQueue as Lt, relativeTime as M, dequeueOnComplete as Mt, readIndexToken as N, queueAdd as Nt, MANAGED_ROOT as O, summarise as Ot, bootstrapUrl as P, queueRemove as Pt, forgeResolver as Q, readAgentPreference as Qt, reviewsUrl as R, doneVerb as Rt, record as S, positionInLineage as St, withUsageRecorded as T, reviewedCommit as Tt, PACKAGE_NAME as U, reviewerDispositions as Ut, writeServerRecord as V, issuesOutstanding as Vt, feedbackUrl as W, processDiscussion as Wt, statedWorkspacePort as X, resolveModel as Xt, resolveWorkspacePort as Y, resolveAgent as Yt, writePortPreference as Z, clearAgentPreference as Zt, startKissJob as _, latestKissRun as _t, wasBlocked as a, agentFor as an, isTerminal as at, startJob as b, loadWorkspace as bt, updateReview as c, AgentUnavailableError as cn, PHASES as ct, askCheckout as d, purposeOf as dt, CONFIG_PATH as en, checkCodeFreshness as et, UpdateAlreadyRunningError as f, clearClaim as ft, recordKissRun as g, indexReviewGroups as gt, agentEnvOf as h, groupByLineage as ht, liveJobsFor as i, agentById as in, fail as it, modelHelpLines as j, workspaceStamps as jt, readMarker as k, touchWorkspace as kt, refreshPrContext as l, phasesFor as lt, runningJobs as m, followedRefName as mt, deleteReview as n, AGENT_IDS as nn, allJobs as nt, discardJob as o, detectAgents as on, loadJob as ot, liveUpdateFor as p, isClaimed as pt, MIN_WORKSPACE_PORT as q, displayRef as qt, lineageIds as r, DEFAULT_AGENT_ID as rn, endedAt as rt, RefreshUnavailableError as s, AgentCancelledError as sn, saveJob as st, deleteLineage as t, STORE_ROOT as tn, checkReview as tt, isUnchanged as u, progressSteps as ut, reanalyseReview as v, lineageKeyFor as vt, telemetryUploadConsent as w, recentWorkspaces as wt, readEvents as x, matchingWorkspaceIds as xt, runJob as y, lineagePosition as yt, stopServer as z, isIssueOutstanding as zt };
+export { feedbackUrl as $, reviewerDispositions as $t, markRead as A, loadWorkspace as At, modelHelpLines as B, workspaceRevision as Bt, recordTelemetryUploadConsent as C, isClaimed as Ct, headline as D, latestKissRun as Dt, eventName as E, indexReviewGroups as Et, EXPLAIN_SIMPLY_PROMPT as F, reviewedCommit as Ft, ensureServer as G, queueStamp as Gt, readIndexToken as H, dequeueOnComplete as Ht, ReviewBeingDeletedError as I, reviewedRepositories as It, stopServer as J, doneVerb as Jt, readServerRecord as K, readQueue as Kt, MANAGED_ROOT as L, saveWorkspace as Lt, readNotification as M, positionInLineage as Mt, unreadCount as N, previousKissResult as Nt, listNotifications as O, lineageKeyFor as Ot, withUsageRecorded as P, recentWorkspaces as Pt, PACKAGE_NAME as Q, questionsOutstanding as Qt, readMarker as R, summarise as Rt, record as S, driverGone as St, announceJob as T, groupByLineage as Tt, bootstrapUrl as U, queueAdd as Ut, relativeTime as V, workspaceStamps as Vt, clearServerRecord as W, queueRemove as Wt, writeServerRecord as X, isQuestionOutstanding as Xt, workspaceUrl as Y, isIssueOutstanding as Yt, BUILD_VERSION as Z, issuesOutstanding as Zt, startKissJob as _, AgentCancelledError as _n, PHASES as _t, wasBlocked as a, resolveAgent as an, statedWorkspacePort as at, startJob as b, purposeOf as bt, updateReview as c, readAgentPreference as cn, fillFileUrlTemplate as ct, askCheckout as d, STORE_ROOT as dn, allJobs as dt, processDiscussion as en, DEFAULT_WORKSPACE_PORT as et, UpdateAlreadyRunningError as f, AGENT_IDS as fn, endedAt as ft, recordKissRun as g, detectAgents as gn, saveJob as gt, agentEnvOf as h, agentFor as hn, loadJob as ht, liveJobsFor as i, git as in, resolveWorkspacePort as it, pruneNotifications as j, matchingWorkspaceIds as jt, markAllRead as k, lineagePosition as kt, refreshPrContext as l, writeAgentPreference as ln, checkCodeFreshness as lt, runningJobs as m, agentById as mn, isTerminal as mt, deleteReview as n, resolveTarget as nn, MIN_WORKSPACE_PORT as nt, discardJob as o, resolveModel as on, writePortPreference as ot, liveUpdateFor as p, DEFAULT_AGENT_ID as pn, fail as pt, reviewsUrl as q, writeQueue as qt, lineageIds as r, displayRef as rn, parseWorkspacePort as rt, RefreshUnavailableError as s, clearAgentPreference as sn, forgeResolver as st, deleteLineage as t, describeAuthorship as tn, MAX_WORKSPACE_PORT as tt, isUnchanged as u, CONFIG_PATH as un, checkReview as ut, reanalyseReview as v, AgentUnavailableError as vn, phasesFor as vt, telemetryUploadConsent as w, followedRefName as wt, readEvents as x, clearClaim as xt, runJob as y, progressSteps as yt, removeWorktree as z, touchWorkspace as zt };

package/dist/main.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $t as writeAgentPreference, A as removeWorktree, B as workspaceUrl, C as recordTelemetryUploadConsent, Dt as saveWorkspace, Et as reviewedRepositories, G as DEFAULT_WORKSPACE_PORT, H as BUILD_VERSION, I as ensureServer, J as parseWorkspacePort, Jt as git, K as MAX_WORKSPACE_PORT, Kt as resolveTarget, M as relativeTime, N as readIndexToken, O as MANAGED_ROOT, Ot as summarise, P as bootstrapUrl, Q as forgeResolver, Qt as readAgentPreference, R as reviewsUrl, S as record$1, St as positionInLineage, U as PACKAGE_NAME, X as statedWorkspacePort, Xt as resolveModel, Yt as resolveAgent, Z as writePortPreference, a as wasBlocked, at as isTerminal, b as startJob, bt as loadWorkspace, c as updateReview, ct as PHASES, dt as purposeOf, en as CONFIG_PATH, f as UpdateAlreadyRunningError, ft as clearClaim, g as recordKissRun, ht as groupByLineage, i as liveJobsFor, in as agentById, j as modelHelpLines, k as readMarker, m as runningJobs, mt as followedRefName, n as deleteReview$1, nn as AGENT_IDS, nt as allJobs, on as detectAgents, ot as loadJob, p as liveUpdateFor, pt as isClaimed, q as MIN_WORKSPACE_PORT, qt as displayRef, rn as DEFAULT_AGENT_ID, tn as STORE_ROOT, tt as checkReview, ut as progressSteps, v as reanalyseReview, vt as lineageKeyFor, w as telemetryUploadConsent, wt as recentWorkspaces, xt as matchingWorkspaceIds, y as runJob, z as stopServer } from "./delete_review-C2wax0ED.js";
+import { At as loadWorkspace, B as modelHelpLines, C as recordTelemetryUploadConsent, Ct as isClaimed, G as ensureServer, H as readIndexToken, It as reviewedRepositories, J as stopServer, L as MANAGED_ROOT, Lt as saveWorkspace, Mt as positionInLineage, Ot as lineageKeyFor, Pt as recentWorkspaces, Q as PACKAGE_NAME, R as readMarker, Rt as summarise, S as record$1, St as driverGone, Tt as groupByLineage, U as bootstrapUrl, V as relativeTime, Y as workspaceUrl, Z as BUILD_VERSION, _t as PHASES, a as wasBlocked, an as resolveAgent, at as statedWorkspacePort, b as startJob, bt as purposeOf, c as updateReview, cn as readAgentPreference, dn as STORE_ROOT, dt as allJobs, et as DEFAULT_WORKSPACE_PORT, f as UpdateAlreadyRunningError, fn as AGENT_IDS, g as recordKissRun, gn as detectAgents, ht as loadJob, i as liveJobsFor, in as git, jt as matchingWorkspaceIds, ln as writeAgentPreference, m as runningJobs, mn as agentById, mt as isTerminal, n as deleteReview$1, nn as resolveTarget, nt as MIN_WORKSPACE_PORT, on as resolveModel, ot as writePortPreference, p as liveUpdateFor, pn as DEFAULT_AGENT_ID, q as reviewsUrl, rn as displayRef, rt as parseWorkspacePort, st as forgeResolver, tt as MAX_WORKSPACE_PORT, un as CONFIG_PATH, ut as checkReview, v as reanalyseReview, w as telemetryUploadConsent, wt as followedRefName, xt as clearClaim, y as runJob, yt as progressSteps, z as removeWorktree } from "./delete_review-TNIFNct3.js";
 import { basename, dirname, join, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
@@ -705,11 +705,17 @@ function madeAgainst(requested) {
 	const wanted = displayRef(requested);
 	return (review) => review.baseRef !== "" && displayRef(review.baseRef) === wanted;
 }
-/** Whether the job behind a stored review is still working. A review with no job never was. */
+/**
+* Whether the job behind a stored review is still working. A review with no job never was.
+*
+* A job whose driver has gone is not working, whatever phase its record was left at. Calling it in
+* progress told the reviewer who had just closed a terminal that there was "nothing to do but wait",
+* for a process that no longer existed, until the sweep called it failed half an hour later.
+*/
 function isRunning(jobId) {
 	if (!jobId) return false;
 	const job = loadJob(jobId);
-	return !!job && !isTerminal(job);
+	return !!job && !isTerminal(job) && !driverGone(job.id);
 }
 /**
 * What the review is of, as the clause both surfaces hang off "Made two hours ago".
@@ -1264,7 +1270,7 @@ function unknownAgent(id, known) {
 * mistake; `Open workspace now` and `Review ready` read as a beginning and an end.
 */
 function startedReview(url, _target) {
-	return [`Open workspace now  ${url}`, "The review continues if this terminal closes."].join("\n");
+	return [`Open workspace now  ${url}`, "Keep this terminal open while it runs. If it closes, run the same command again to carry on."].join("\n");
 }
 /**
 * The one-review-per-branch rule, said to a person rather than to a session.
@@ -1517,8 +1523,9 @@ function commitReviewCannotUpdate(sha) {
 * Said before the update starts, so the command answers at once and the link is there to open while
 * it works. The same label the creation path uses, because it is the same offer.
 *
-* Not "continues if this terminal closes", which the creation path can say and this cannot: the
-* update runs in this process, so closing the terminal stops it.
+* Without the creation path's line about carrying on if the terminal closes. An update runs in this
+* process and ends with it, and running the command again starts the update over rather than
+* picking one up, because `liveUpdateFor` reads a dead driver as nothing running.
 */
 function startedUpdate(url, acted) {
 	return `${subjectLine(acted)}\nOpen workspace now  ${url}`;
@@ -2178,8 +2185,10 @@ function describe(deps, id) {
 * One thing differs, and it is a property of the surface rather than of the review. An MCP tool
 * returns to a session that must not sit and wait, so it fires `runJob` and returns the link at
 * once. A person who typed a command is already waiting, so this awaits the job and reports what
-* it is doing. Either way the job is durable and either way the link works from the moment it is
-* printed, so a terminal closed halfway through loses nothing.
+* it is doing. Either way the job is durable and the link works from the moment it is printed. The
+* job does not outlive this process, though: the agent shares the terminal's process group, so a
+* terminal closed halfway through ends both. What it loses is time, not work. The claim it leaves
+* behind is `driverGone`, and running the command again carries on from the phase it reached.
 *
 * **Two axes, and this file is where they meet.** A command names a target and an operation, and
 * the operations are `update` and `reanalyse`, which were `prreviewbuddy update` until 0.15.0.
@@ -2480,15 +2489,19 @@ function makeCommandFor(command) {
 	if (command.commitRef) return `prreviewbuddy review --commit ${command.commitRef}`;
 	return "prreviewbuddy review";
 }
+/** Why an unfinished review is being picked up, when nothing recorded a failure because nothing could. */
+var DRIVER_GONE = "the command that was running it ended before it finished, most often because its terminal closed.";
 function failureOf(workspaceId) {
 	const workspace = loadWorkspace(workspaceId);
 	if (!workspace?.jobId) return null;
 	const job = loadJob(workspace.jobId);
-	if (!job || !isTerminal(job) || job.phase !== "failed") return null;
+	if (!job) return null;
+	const abandoned = !isTerminal(job) && driverGone(job.id);
+	if (!abandoned && (!isTerminal(job) || job.phase !== "failed")) return null;
 	if (isClaimed(job.id)) return null;
 	return {
-		message: job.failure?.message ?? "The reason was not recorded.",
-		stopped: job.failure?.stopped === true,
+		message: abandoned ? DRIVER_GONE : job.failure?.message ?? "The reason was not recorded.",
+		stopped: !abandoned && job.failure?.stopped === true,
 		agentId: job.env.agentId ?? DEFAULT_AGENT_ID,
 		...job.requestedModel ? { requestedModel: job.requestedModel } : {}
 	};
@@ -3202,8 +3215,7 @@ async function cleanUp(options) {
 *
 * 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.
+* the workspace outlives the terminal that opened it, and there are no reviews left to serve 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