prreviewbuddy 0.31.0 → 0.36.3

package/CHANGELOG.md

@@ -1,5 +1,170 @@
 # Changelog
 
+## 0.36.3
+
+**The reviews list is one click away from anywhere.** The strip at the top of every workspace page
+now opens it, beside the notifications bell. Until now the only way back to the list was the rail,
+which a narrow window hides, so from a review page it was the browser's Back button or nothing.
+
+Every workspace place now has an icon up there, so the text links that used to appear in the strip
+on a narrow window are gone: each of them was the same destination as the icon beside it.
+
+## 0.36.2
+
+The note saying where your settings are kept now ends the settings, above the Server section rather
+than below it. Between Stop server and the foot of the page it read as a footnote about the server,
+which is the one thing on that page it says nothing about.
+
+## 0.36.1
+
+**A status dot says whether the workspace server is there.** It sits beside the restart button:
+green while the server is answering, amber while a restart is in flight, red once nothing is. It is
+small on purpose — while you are reading a page, the page itself is the proof the server is up, so
+the dot earns its place in the other two states.
+
+**A restart now says it worked.** The page comes back with "Server restarted. Workspace is back
+online." rather than simply blinking. There is still nothing to confirm beforehand: it is one click
+when the server is idle.
+
+If a restart does not come back, the page says so and stays saying so. It tells the two cases apart:
+a restart the server refused before stopping anything leaves it running and says that, and only a
+restart that actually lost the server names the command that brings it back.
+
+## 0.36.0
+
+**The workspace can restart its own server.** A restart button sits in the global strip on every
+page: the running server starts its replacement, hands over the port and goes, and the page reloads
+itself onto the new one. It needs no terminal, and because the replacement is read from disk it is
+how you pick up a new build without leaving the browser. While the server is making a review of its
+own the button is disabled and says why, since that work would end with the process; a review being
+made from a terminal is a different process and never stands in the way.
+
+If the replacement cannot be started, nothing is stopped. The server refuses before it tears
+anything down, keeps serving, and the page says so rather than reloading into nothing.
+
+**Stop server has moved to Settings.** It used to sit at the foot of the rail on every page, one
+press from ending every open review, next to the links you navigate with. It is the one thing the
+workspace cannot undo — the page it leaves behind has no server to ask — so it now lives on the
+Settings page with the sentence that matters beside it: start it again with `prreviewbuddy open`,
+from any directory. The rail is navigation again, and the strip offers the recoverable action
+instead.
+
+`prreviewbuddy open` has always worked from any directory and starts the server if it is not
+running; it is now tested to keep doing so. The workspace is global; only reviews belong to a
+repository.
+
+## 0.35.0
+
+**Notifications have a home in the top-right corner.** A bell sits in the workspace's new global
+strip, on every page including a review, and shows a dot when something is waiting. It was reachable
+only from the foot of the rail before, which is not where anybody looks for it. The bell opens the
+Notifications page and marks nothing read: that still happens only by a deliberate act. How many are
+waiting is still said in words in the rail, which is where there is room to say it; the dot is only
+the news that there is something to look at.
+
+The caret on a menu is ours now rather than the browser's. The native one sat hard against the
+control's right edge in a colour used nowhere else in the product; this one is inset by the same
+distance the text has on the other side, and drawn in the muted grey everything quiet here shares.
+
+**Settings is in that strip too**, as an icon beside the bell, reachable from any page without
+going to the rail for it. It still sits in the rail with its name beside it.
+
+**The workspace has two bars instead of one.** The product's own controls and the review's identity
+used to share a single header, which is why there was no room for the bell. They are separated now:
+a thin strip carries the wordmark, the bell and the build, and the bar below it belongs entirely to
+what you are looking at. On a review that is the branch, the size, the freshness and Mark reviewed,
+exactly as before but with the product's chrome lifted out of it. On the other pages it names the
+page and carries that page's own controls, which have moved up out of the column they act on rather
+than being added: the reviews search and filters, the Notifications count and Mark all read, and the
+way back out of Settings.
+
+The build version now sits in the strip on every page, including a review, where it used to be at
+the foot of the rail.
+
+Two things that had never worked in a window too narrow for the rail, both found by looking at the
+real thing. The workspace links meant to replace the hidden rail were never shown at all, so at that
+width there was no way to Notifications, Settings or the feedback form. And the reviews list,
+Notifications and Settings were squeezed into the width the rail had vacated, with the rest of the
+window empty beside them: the same fault the review itself had, fixed there in 0.34.0 and missed
+here.
+
+## 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/README.md

@@ -82,6 +82,8 @@ prreviewbuddy agents                    which coding agents you have
 prreviewbuddy config set agent <agent>  remember which to use when you do not name one
 prreviewbuddy config set telemetry-upload on|off
                                         send usage telemetry, or stop. On by default
+prreviewbuddy config get port           the port the workspace runs on
+prreviewbuddy config set port <port>    move it, from the next start onwards
 
 prreviewbuddy uninstall                 remove everything this put on your machine
 ```
@@ -113,9 +115,11 @@ started with.
 The job is durable: closing the terminal does not stop it, and running the same command again after
 an interruption carries on from the phase that stopped rather than starting over.
 
-Reviews are kept in `~/.prreviewbuddy` for thirty days. A local server holds them open and outlives
-the terminal that started it, taking a new port each time it starts, so bookmark
-`file://~/.prreviewbuddy/reviews.html` rather than a port number.
+Reviews are kept in `~/.prreviewbuddy` for thirty days. A local server holds them open at
+`http://localhost:7726` and outlives the terminal that started it, so a link to a review is worth
+keeping: the address does not move, and the same link still opens after a restart. Run
+`prreviewbuddy open` from any directory to get back to the list, and
+`prreviewbuddy config set port <port>` if 7726 is taken on your machine.
 
 The isolated checkout a review was made in is kept for six hours after it finishes, because that is
 what the assistant reads when you ask it questions, and is then removed.

package/dist/{delete_review-C2wax0ED.js → delete_review-Kup1LXD_.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,
@@ -6972,7 +6984,7 @@ async function waitForPortToFree(port) {
 async function ensureServer() {
 	const running = await healthyPort();
 	if (running !== null) return running;
-	if (!existsSync(SERVER_ENTRY)) throw new Error(`The workspace server is not built. Expected it at ${SERVER_ENTRY}.${buildInstruction(SURFACE.client)}`);
+	if (!serverEntryExists()) throw new Error(`The workspace server is not built. Expected it at ${serverEntry()}.${buildInstruction(SURFACE.client)}`);
 	if (!acquireSpawnLock()) {
 		const shared = await waitForHealthyServer();
 		if (shared !== null) return shared;
@@ -6991,11 +7003,7 @@ async function ensureServer() {
 		}
 		if (occupant === "foreign") throw new Error(portTakenMessage(port));
 		clearServerRecord();
-		spawn(process.execPath, [SERVER_ENTRY], {
-			detached: true,
-			stdio: "ignore",
-			cwd: STORE_ROOT
-		}).unref();
+		spawnServer();
 		const started = await waitForHealthyServer();
 		if (started !== null) return started;
 		if (await occupantOf(port) === "foreign") throw new Error(portTakenMessage(port));
@@ -7005,6 +7013,32 @@ async function ensureServer() {
 	}
 }
 /**
+* Start a detached workspace server and let go of it.
+*
+* One function rather than one per caller: the launcher starts the first server, and a server being
+* restarted starts its own replacement, and those must be the same process in the same place with
+* the same entry — a second spawn written separately is how the two quietly drift apart.
+*
+* `serverEntry()` is read at call time rather than captured, so a restart after a rebuild picks up
+* the new file at the same path, which is the main reason anybody wants one.
+*/
+function spawnServer() {
+	const child = spawn(process.execPath, [serverEntry()], {
+		detached: true,
+		stdio: "ignore",
+		cwd: STORE_ROOT
+	});
+	child.unref();
+	return child;
+}
+/** Whether there is anything to start. The one foreseeable reason a restart cannot be attempted. */
+function serverEntryExists() {
+	return existsSync(serverEntry());
+}
+function serverEntry() {
+	return SERVER_ENTRY;
+}
+/**
 * The recorded server's port, if it is actually answering *and* is this build's.
 *
 * A server from another version is stopped rather than left alone. Two servers cannot both hold
@@ -9493,6 +9527,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 +10072,7 @@ async function reanalyseReview(workspaceId, agentId, onStarted, requestedModel)
 			target,
 			env: agent.captureEnv(),
 			purpose: "review",
+			reanalysis: true,
 			...model ? { requestedModel: model } : {}
 		});
 		saveJob(job);
@@ -10030,6 +10288,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 +10302,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 +11481,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 +12078,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 { BUILD_VERSION as $, issuesOutstanding as $t, markRead as A, lineageKeyFor as At, modelHelpLines as B, summarise as Bt, recordTelemetryUploadConsent as C, clearClaim as Ct, headline as D, groupByLineage as Dt, eventName as E, followedRefName as Et, EXPLAIN_SIMPLY_PROMPT as F, previousKissResult as Ft, ensureServer as G, queueAdd as Gt, readIndexToken as H, workspaceRevision as Ht, ReviewBeingDeletedError as I, recentWorkspaces as It, serverEntryExists as J, readQueue as Jt, readServerRecord as K, queueRemove as Kt, MANAGED_ROOT as L, reviewedCommit as Lt, readNotification as M, loadWorkspace as Mt, unreadCount as N, matchingWorkspaceIds as Nt, listNotifications as O, indexReviewGroups as Ot, withUsageRecorded as P, positionInLineage as Pt, writeServerRecord as Q, isQuestionOutstanding as Qt, readMarker as R, reviewedRepositories as Rt, record as S, purposeOf as St, announceJob as T, isClaimed as Tt, bootstrapUrl as U, workspaceStamps as Ut, relativeTime as V, touchWorkspace as Vt, clearServerRecord as W, dequeueOnComplete as Wt, stopServer as X, doneVerb as Xt, spawnServer as Y, writeQueue as Yt, workspaceUrl as Z, isIssueOutstanding as Zt, startKissJob as _, agentFor as _n, loadJob as _t, wasBlocked as a, displayRef as an, parseWorkspacePort as at, startJob as b, AgentUnavailableError as bn, phasesFor as bt, updateReview as c, resolveModel as cn, writePortPreference as ct, askCheckout as d, writeAgentPreference as dn, checkCodeFreshness as dt, questionsOutstanding as en, PACKAGE_NAME as et, UpdateAlreadyRunningError as f, CONFIG_PATH as fn, checkReview as ft, recordKissRun as g, agentById as gn, isTerminal as gt, agentEnvOf as h, DEFAULT_AGENT_ID as hn, fail as ht, liveJobsFor as i, resolveTarget as in, MIN_WORKSPACE_PORT as it, pruneNotifications as j, lineagePosition as jt, markAllRead as k, latestKissRun as kt, refreshPrContext as l, clearAgentPreference as ln, forgeResolver as lt, runningJobs as m, AGENT_IDS as mn, endedAt as mt, deleteReview as n, processDiscussion as nn, DEFAULT_WORKSPACE_PORT as nt, discardJob as o, git as on, resolveWorkspacePort as ot, liveUpdateFor as p, STORE_ROOT as pn, allJobs as pt, reviewsUrl as q, queueStamp as qt, lineageIds as r, describeAuthorship as rn, MAX_WORKSPACE_PORT as rt, RefreshUnavailableError as s, resolveAgent as sn, statedWorkspacePort as st, deleteLineage as t, reviewerDispositions as tn, feedbackUrl as tt, isUnchanged as u, readAgentPreference as un, fillFileUrlTemplate as ut, reanalyseReview as v, detectAgents as vn, saveJob as vt, telemetryUploadConsent as w, driverGone as wt, readEvents as x, progressSteps as xt, runJob as y, AgentCancelledError as yn, PHASES as yt, removeWorktree as z, saveWorkspace as zt };