prreviewbuddy 0.30.0 → 0.34.0

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

@@ -2060,6 +2060,17 @@ var EmptyChangeError = class extends Error {
 	}
 };
 /**
+* Whether a stored change set is a review of one commit. See `ChangeSet.targetType`.
+*
+* A function rather than the comparison written out, and not only for tidiness:
+* `freshness_read_only.test.ts` refuses any quoted git subcommand in `freshness.ts`, and the
+* discriminator's value is spelled the same as one. That guard is right to be blunt, so the
+* comparison lives here, beside the field it reads.
+*/
+function isCommitReview(changeSet) {
+	return changeSet.targetType === "commit";
+}
+/**
 * Decide what this change is being compared against.
 *
 * Refuses rather than guessing. A base we picked wrongly produces a guide that looks completely
@@ -2142,7 +2153,7 @@ async function defaultRemoteBranch(repoPath) {
 async function buildChangeSet(options) {
 	const repoPath = (await git(options.repoPath, ["rev-parse", "--show-toplevel"])).trim();
 	const base = options.resolvedBase ?? await resolveBase(repoPath, options.base);
-	const mergeBase = await mergeBaseOf(repoPath, base, "HEAD");
+	const mergeBase = base.exact ? base.revision : await mergeBaseOf(repoPath, base, "HEAD");
 	const headRef = await currentBranch(repoPath);
 	const isLinkedWorktree = await linkedWorktree(repoPath);
 	const files = await collectFiles(repoPath, [mergeBase, "HEAD"]);
@@ -2150,7 +2161,7 @@ async function buildChangeSet(options) {
 	disagreement(files.length, base.display, options.expected);
 	const blobShas = await headBlobShas(repoPath);
 	for (const file of files) file.sha = blobShas.get(file.name) ?? "";
-	const { subjects, authors } = await commitLog(repoPath, mergeBase);
+	const { subjects, authors } = await commitLog(repoPath, base.exact && !await refExists(repoPath, mergeBase) ? "HEAD" : `${mergeBase}..HEAD`);
 	return {
 		data: {
 			pullRequest: {
@@ -2286,12 +2297,12 @@ async function currentBranch(repoPath) {
 * Uncommitted work has no author in the log, and needs none. It belongs to whoever is sitting at
 * this checkout, and that is the person reading the page.
 */
-async function commitLog(repoPath, mergeBase) {
+async function commitLog(repoPath, range) {
 	const out = await git(repoPath, [
 		"log",
 		"--reverse",
 		"--format=%an%x1f%s",
-		`${mergeBase}..HEAD`
+		range
 	]);
 	const subjects = [];
 	const counts = /* @__PURE__ */ new Map();
@@ -2365,7 +2376,7 @@ async function mergeBaseOf(repoPath, base, head) {
 */
 async function hasCommittedChanges(repoPath, base, head) {
 	return parseNameStatus(await git(repoPath, [
-		...rangeDiff([await mergeBaseOf(repoPath, base, head), head]),
+		...rangeDiff([base.exact ? base.revision : await mergeBaseOf(repoPath, base, head), head]),
 		"--name-status",
 		"-z"
 	])).length > 0;
@@ -2610,6 +2621,97 @@ function ambiguous(named, found) {
 	].join("\n");
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/commit_target.ts
+/**
+* One commit the reviewer named, resolved to what it introduced, or refused.
+*
+* `prreviewbuddy review --commit 9907c64` reviews *the change that commit made*, which is the diff
+* against its first parent. That is a different object from everything else this product reviews,
+* and the difference is not the spelling of the target but what can be done to it afterwards.
+*
+* **A branch is followed; a commit is not.** `branch_target.ts` refuses a commit and says why: a
+* review follows its branch so it can be brought up to date as commits arrive, and a commit has
+* nowhere to move to. That refusal stands. This module is the other surface that docblock asked for,
+* and the thing it has to supply that `--branch` could not is an answer to what the lineage key is:
+* the commit's own full sha, never a ref manufactured from it. See `lineageKeyFor`.
+*
+* **The parent is the base, and the reviewer cannot name another one.** `--commit` with `--base` is
+* refused in the parser, because the two together are arbitrary range review arriving by the back
+* door: the findings would be about a different change under a page still naming the commit.
+*
+* **Nothing fetches,** for the same reason as `branch_target.ts`: the reviewer named something they
+* believe is here, and a commit-ish that does not resolve locally is far more often a typo than a
+* missing fetch.
+*/
+async function resolveNamedCommit(repoPath, value) {
+	const named = value.trim();
+	if (!named) throw new TargetError("No commit was named. Give `--commit` a commit, such as `--commit 9907c64` or `--commit HEAD~2`.");
+	const sha = await peel(repoPath, named);
+	const parents = (await git(repoPath, [
+		"rev-list",
+		"--parents",
+		"-n",
+		"1",
+		sha
+	])).trim().split(/\s+/).slice(1);
+	const subject = (await git(repoPath, [
+		"log",
+		"-1",
+		"--format=%s",
+		sha
+	])).trim();
+	return {
+		sha,
+		parentSha: parents[0] ?? null,
+		parentCount: parents.length,
+		subject
+	};
+}
+/**
+* The empty tree, asked of the repository rather than written down.
+*
+* A root commit is compared against nothing, and git spells nothing as the empty tree object. The
+* constant everybody knows, `4b825dc642cb6eb9a060e54bf8d69288fbee4904`, is the **sha-1** spelling of
+* it, and a repository created with `--object-format=sha256` has a different one. Hardcoding it
+* would make root-commit review silently wrong there rather than loudly broken, so the repository is
+* asked. `/dev/null` is an empty file, and hashing one as a tree is the documented way to name it.
+*/
+async function emptyTreeSha(repoPath) {
+	return (await git(repoPath, [
+		"hash-object",
+		"-t",
+		"tree",
+		"/dev/null"
+	])).trim();
+}
+/**
+* The full commit sha behind whatever was typed, or a refusal naming what it found instead.
+*
+* A tree or a blob is refused **by name**, the way `branch_target.ts` refuses `refs/tags/v1` by
+* name: `--commit HEAD^{tree}` resolves perfectly well to an object that is right there, and telling
+* the reviewer it could not be found would send them looking for a commit they have.
+*/
+async function peel(repoPath, named) {
+	try {
+		return (await git(repoPath, [
+			"rev-parse",
+			"--verify",
+			"--quiet",
+			`${named}^{commit}`
+		])).trim();
+	} catch {}
+	let type = "";
+	try {
+		type = (await git(repoPath, [
+			"cat-file",
+			"-t",
+			named
+		])).trim();
+	} catch {}
+	if (type === "tree" || type === "blob") throw new TargetError(`\`${named}\` is a ${type}, and a review is of a commit.\n\nA commit review is the change that commit introduced, which is its diff against its parent. A ${type} is a snapshot with nothing to compare it to. Name the commit instead.`);
+	throw new TargetError(`There is nothing called \`${named}\` in this repository.\n\n\`--commit\` takes anything git can resolve to a commit: a sha, \`HEAD~2\`, a tag. If the commit is on a remote this clone has not seen, run \`git fetch\` and try again.`);
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/target.ts
 /**
 * What is being reviewed, decided once and used everywhere.
@@ -2628,6 +2730,7 @@ function ambiguous(named, found) {
 */
 async function resolveTarget(input) {
 	const root = await repositoryRoot(input.repoPath);
+	if (input.commitRef) return commitTarget(root, input.commitRef);
 	if (input.base) await verifyBase(root, input.base);
 	else await verifyDefaultBase(root);
 	const named = input.base ? { base: input.base } : {};
@@ -2656,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();
@@ -2684,6 +2787,46 @@ async function resolveTarget(input) {
 	};
 }
 /**
+* One commit, and the parent it will be compared against, settled here and never re-derived.
+*
+* The base is built as a `ResolvedBase` rather than left as a name for `resolveBase` to work out,
+* which is the seam the pull request path already uses: `ChangeSetOptions.resolvedBase` is
+* documented as "a base already decided by the caller... The caller that set it had an authority
+* this module does not". The forge is that authority there. Here it is git's own commit graph, which
+* is a stronger one still, and there is nothing for a ladder of branch names to contribute to it.
+*
+* `followRef` is deliberately absent. It exists so a later rebuild can re-resolve a moving base, and
+* this base cannot move: a commit's parent is the same commit for ever. Recording a ref here would
+* invite exactly the re-resolution the immutability is for.
+*
+* `exact` is set because the parent *is* the comparison point. For an ordinary commit that agrees
+* with `merge-base(parent, commit)` anyway; for a merge it is what pins the diff to the first parent
+* rather than to wherever the two histories converge, and for a root commit it is the only way the
+* empty tree can be a base at all.
+*/
+async function commitTarget(root, commitRef) {
+	const commit = await resolveNamedCommit(root, commitRef);
+	const short = commit.sha.slice(0, 7);
+	const parent = commit.parentSha;
+	const resolvedBase = parent ? {
+		revision: parent,
+		display: parent.slice(0, 7),
+		exact: true
+	} : {
+		revision: await emptyTreeSha(root),
+		display: "the empty tree",
+		exact: true
+	};
+	return {
+		originRepoPath: root,
+		branch: short,
+		sha: commit.sha,
+		base: resolvedBase.display,
+		resolvedBase,
+		commit
+	};
+}
+/**
 * Which commit this request was cut from, decided before anything expensive happens.
 *
 * Strict, and it refuses rather than falling back to a local branch of the right name. The local
@@ -2798,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;
@@ -2818,6 +2961,14 @@ async function uncommittedIn(root, target) {
 * to the display name, which `resolveBase` now resolves remote-first anyway.
 */
 function baseOf(changeSet) {
+	if (changeSet.targetType === "commit" && changeSet.mergeBase) return {
+		base: changeSet.baseRef,
+		resolvedBase: {
+			revision: changeSet.mergeBase,
+			display: changeSet.baseRef,
+			exact: true
+		}
+	};
 	if (!changeSet.baseRef) return {};
 	const followRef = changeSet.baseResolvedRef;
 	return {
@@ -2872,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, [
@@ -2885,7 +3036,7 @@ async function branchOf(root) {
 		branch = "";
 	}
 	if (branch) return branch;
-	throw new TargetError("This checkout is on a detached HEAD, so there is no branch to file a review under. Check out a branch, or name the pull request you want reviewed.");
+	throw new TargetError("This checkout is on a detached HEAD, so there is no branch to file a review under. To review the commit you are on, run `prreviewbuddy review --commit HEAD`. Otherwise check out a branch, or name the pull request you want reviewed.");
 }
 /**
 * The commit has to be here before a worktree can be pinned to it.
@@ -4036,9 +4187,22 @@ function reviewedRepositories() {
 *
 * A newline separates the halves because it cannot appear in any of them, so no set of values can
 * collide by running together.
+*
+* **A commit review keys by the commit, not by a branch.** It follows nothing, so the ref half has
+* no meaning for it, and its display name is a short sha that two different commits can share.
 */
 function lineageKey(review) {
-	return lineageKeyFor(review.repoPath, review.branch, review.headResolvedRef);
+	if (review.targetType === "commit") return lineageKeyFor({
+		kind: "commit",
+		repoPath: review.repoPath,
+		sha: review.commitSha ?? ""
+	});
+	return lineageKeyFor({
+		kind: "branch",
+		repoPath: review.repoPath,
+		branch: review.branch,
+		followedRef: review.headResolvedRef
+	});
 }
 /**
 * The same key, from the pieces, so a target and a stored review cannot arrive at it differently.
@@ -4047,8 +4211,19 @@ function lineageKey(review) {
 * asks whether a target is the target of a stored review, and if it compared its own three fields
 * by hand then widening the key here and widening the match there would be two changes that have
 * to stay in step forever.
+*
+* **The commit arm is decided before the branch arm's defaulting, and that order is the point.** The
+* branch arm reads an absent ref as `refs/heads/<branch>`, so a commit reaching it would derive
+* `refs/heads/<sha>` and file under a ref nobody has. The middle segment is the literal `commit`,
+* which no branch key can produce in that position with a full sha after it, because a branch key's
+* last segment always starts with `refs/`.
+*
+* The branch arm is byte-for-byte the key every review on disk already has. Changing it re-files
+* every stored review under a new card, silently, on every machine.
 */
-function lineageKeyFor(repoPath, branch, followedRef) {
+function lineageKeyFor(subject) {
+	if (subject.kind === "commit") return `${subject.repoPath}\ncommit\n${subject.sha}`;
+	const { repoPath, branch, followedRef } = subject;
 	return `${repoPath}\n${branch}\n${followedRef ?? `refs/heads/${branch}`}`;
 }
 /**
@@ -4206,6 +4381,11 @@ function summarise(workspace) {
 		branch: workspace.changeSet.headRef,
 		baseRef: workspace.changeSet.baseRef ?? "",
 		...workspace.changeSet.headResolvedRef ? { headResolvedRef: workspace.changeSet.headResolvedRef } : {},
+		...workspace.changeSet.targetType === "commit" ? {
+			targetType: "commit",
+			parentSha: workspace.changeSet.parentSha ?? null,
+			...workspace.changeSet.parentCount !== void 0 ? { parentCount: workspace.changeSet.parentCount } : {}
+		} : {},
 		repoPath: workspace.repoPath,
 		changedFiles: totalChangedFiles(workspace.changeSet.data),
 		additions: files.reduce((total, file) => total + (file.additions ?? 0), 0),
@@ -4224,7 +4404,7 @@ function summarise(workspace) {
 		pinned: workspace.pinned === true,
 		paths: files.slice(0, MAX_INDEXED_PATHS).map((file) => file.name),
 		prNumber: workspace.changeSet.data.pullRequest?.number || workspace.prContext?.pullRequest.number,
-		commitSha: workspace.session.metadata?.commitSha || void 0,
+		commitSha: workspace.session.metadata?.commitSha || (workspace.changeSet.targetType === "commit" ? workspace.changeSet.data.pullRequest.head.sha : "") || void 0,
 		author: describeAuthorship(workspace.changeSet, workspace.prContext?.pullRequest)?.label,
 		authorHandle: workspace.prContext?.pullRequest.author?.handle || void 0
 	};
@@ -4586,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
@@ -4854,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,
@@ -5110,18 +5302,47 @@ async function refSha(repoPath, ref) {
 * - **Describe, do not re-analyse.** The workspace says what changed. Deciding what it means for
 *   the findings is the analyser's job, and the analyser is Claude Code.
 */
-async function checkFreshness(workspace) {
+/**
+* Freshness, and for a commit review whether its commit is still here, in one pass.
+*
+* **`latest()` is never asked about a commit review.** Its null already means "the branch is not in
+* this repository", a real answer with two documented causes. A commit review has no branch to look
+* for at all, and teaching that function to return null for this too would make one value mean two
+* unrelated things, told apart only by knowing the target type: the ambiguity a commit target exists
+* to remove. So this path does not reach it.
+*/
+async function checkReview(workspace) {
 	const reviewedSha = workspace.session.metadata?.commitSha || workspace.changeSet.data.pullRequest.head.sha || null;
 	const headSha = await readHead(workspace.repoPath);
+	const commitReview = isCommitReview(workspace.changeSet);
 	return {
-		checkedAt: Date.now(),
-		code: await codeFreshness(workspace, reviewedSha, headSha, await latest(workspace)),
-		checkout: await checkoutFreshness(workspace, headSha),
-		conversation: workspace.prContext ? {
-			attached: true,
-			state: "unknown",
-			importedAt: workspace.prContext.discussion.fetchedAt
-		} : { attached: false }
+		freshness: {
+			checkedAt: Date.now(),
+			code: commitReview ? fixedCode(reviewedSha) : await codeFreshness(workspace, reviewedSha, headSha, await latest(workspace)),
+			checkout: await checkoutFreshness(workspace, headSha),
+			conversation: workspace.prContext ? {
+				attached: true,
+				state: "unknown",
+				importedAt: workspace.prContext.discussion.fetchedAt
+			} : { attached: false }
+		},
+		availability: commitReview && reviewedSha ? {
+			state: await commitExists(workspace.repoPath, reviewedSha) ? "available" : "missing",
+			sha: reviewedSha
+		} : null
+	};
+}
+/** The code answer for a commit review. Nothing is compared, so every count is absent rather than zero. */
+function fixedCode(reviewedSha) {
+	return {
+		state: "fixed",
+		reviewedSha,
+		latestSha: null,
+		comparison: null,
+		newCommits: null,
+		changedFiles: null,
+		rewritten: false,
+		reason: null
 	};
 }
 /**
@@ -5139,6 +5360,7 @@ async function checkFreshness(workspace) {
 * a whole `FreshnessReport` around a single run would imply it had its own answer to both.
 */
 async function checkCodeFreshness(workspace, reviewedSha) {
+	if (isCommitReview(workspace.changeSet)) return fixedCode(reviewedSha);
 	return codeFreshness(workspace, reviewedSha, await readHead(workspace.repoPath), await latest(workspace));
 }
 /**
@@ -9283,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.
@@ -9605,6 +10050,7 @@ async function reanalyseReview(workspaceId, agentId, onStarted, requestedModel)
 			target,
 			env: agent.captureEnv(),
 			purpose: "review",
+			reanalysis: true,
 			...model ? { requestedModel: model } : {}
 		});
 		saveJob(job);
@@ -9748,6 +10194,7 @@ async function drive(jobId, workspaceId, runners, driver, signal) {
 					repoPath: job.target.originRepoPath,
 					headRef: job.target.branch,
 					...job.target.ref ? { headResolvedRef: job.target.ref } : {},
+					...commitIdentity(job.target, stored.changeSet),
 					checkoutName,
 					isLinkedWorktree,
 					data: {
@@ -9819,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) {
@@ -9832,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;
 	}
 }
@@ -9916,7 +10365,7 @@ function pendingChangeSet(target) {
 		data: {
 			pullRequest: {
 				number: target.pullRequest?.number ?? 0,
-				title: target.branch,
+				title: target.commit?.subject || target.branch,
 				body: null,
 				base: {
 					ref: target.base ?? "",
@@ -9935,6 +10384,7 @@ function pendingChangeSet(target) {
 		repoPath: target.originRepoPath,
 		headRef: target.branch,
 		...target.ref ? { headResolvedRef: target.ref } : {},
+		...commitIdentity(target, void 0),
 		baseRef: target.base ?? "",
 		mergeBase: "",
 		includesUncommitted: false,
@@ -9943,6 +10393,27 @@ function pendingChangeSet(target) {
 	};
 }
 /**
+* What makes a stored change set a commit review, carried from wherever it is known.
+*
+* Two sources, because a target is rebuilt from a stored review in three places (`reanalyseReview`,
+* `pinned_checkout.ts`, `kiss_run.ts`) and none of them has the `NamedCommit` the original command
+* resolved. They do not need it: the stored record already says what it is, and that answer is the
+* one to keep. A fresh target wins when there is one, since it is where the answer was decided.
+*/
+function commitIdentity(target, stored) {
+	if (target.commit) return {
+		targetType: "commit",
+		parentSha: target.commit.parentSha,
+		parentCount: target.commit.parentCount
+	};
+	if (stored?.targetType === "commit") return {
+		targetType: "commit",
+		parentSha: stored.parentSha ?? null,
+		...stored.parentCount !== void 0 ? { parentCount: stored.parentCount } : {}
+	};
+	return {};
+}
+/**
 * Rebuild the prompt a phase needs, from what the job and the workspace already hold.
 *
 * Not cached in memory: the daemon can restart between `context` finishing and `analysing`
@@ -10965,6 +11436,8 @@ function explainUpdateFailure(error, env, requestedModel) {
 var RefreshUnavailableError = class extends Error {};
 /** A fetch reaches the network, so it gets a ceiling. Nothing else here can hang. */
 var FETCH_TIMEOUT_MS = 6e4;
+/** Said wherever an update is asked of a commit review. One sentence, so both surfaces agree. */
+var COMMIT_REVIEW_CANNOT_UPDATE = "This review is of one commit, and a commit cannot move, so there is nothing to bring it up to date with. To analyse the same commit again, reanalyse it instead.";
 /**
 * Computes and mutates the workspace in memory; does not persist.
 *
@@ -10973,6 +11446,7 @@ var FETCH_TIMEOUT_MS = 6e4;
 */
 async function updateReview(workspace, runners = {}) {
 	const reviewedSha = workspace.session.metadata?.commitSha || null;
+	if (workspace.changeSet.targetType === "commit") return refuse(reviewedSha, false, COMMIT_REVIEW_CANNOT_UPDATE);
 	const held = await claimCheckoutJob(workspace, reviewedSha ?? "", {
 		purpose: "update",
 		...workspace.prContext ? { conversation: {
@@ -10985,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();
@@ -11578,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, checkFreshness 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 };