prreviewbuddy 0.29.1 → 0.31.0

package/CHANGELOG.md

@@ -1,5 +1,59 @@
 # Changelog
 
+## 0.31.0
+
+**Review a single commit.** `prreviewbuddy review --commit <commit>` reviews the change one commit
+made, compared against the commit before it. Name the commit however git lets you: a sha, `HEAD~2`
+or a tag. A merge commit is compared against its first parent, and the review says so; the very
+first commit in a repository is compared against nothing, so every file in it is new.
+
+A commit never changes, so its review does not go out of date. The review page says "Freshness:
+Fixed" instead of offering to update it, and `--update` is refused with a pointer to `--reanalyse`,
+which analyses the same commit again and keeps the earlier analysis beside the new one. If the commit
+later disappears from your repository, after a force-push for example, the review still opens in
+full and says the commit is gone. `--commit` cannot be combined with `--base`, because the commit
+before it is the base; to compare a branch against a base of your choosing, use `--branch` with
+`--base` as before.
+
+Reviews of the same commit share one card on the reviews list, named `commit` and its short sha, and
+searching the list for the sha finds it. A review of a commit and a review of the branch that
+contains it stay separate.
+
+**A detached checkout points at `--commit HEAD`.** Running `prreviewbuddy review` on a detached HEAD
+is still refused, because there is no branch to file the review under, and the message now offers
+`prreviewbuddy review --commit HEAD` to review the commit you are on.
+
+**A calmer Files tab.** Each file's issue and question counts are now small icons with a number, in
+a column of their own on the right, instead of labels that squeezed long filenames onto several
+lines. The label naming a second theme that also mentions a file is gone: the file is already listed
+under its own theme, and its counts still include every finding. Added, modified, removed and renamed
+files now each have their own colour, and the labels are all one width so the paths line up.
+
+**The review header stays on one line.** On a narrow window the branch, commit and controls at the
+top of a review no longer wrap onto a second line.
+
+## 0.30.0
+
+**Usage telemetry is now on by default.** Non-identifying usage telemetry is now enabled by default
+on installations that have not previously made a choice. Existing opt-outs remain respected: if you
+answered no when PR Review Buddy asked, nothing is sent, and nothing about your machine changes.
+The first-run question is gone, replaced by a one-time notice in the terminal that says what is
+sent and how to stop it. That notice is shown only to installations the new default actually
+changes, so a machine that already answered sees nothing.
+
+Nothing new is collected. The same two events carry the same eight fields they did before: review
+start and finish, a random installation ID, the version, the platform, the agent, whether the
+analysis succeeded and how long it took. Never your code, diffs, file paths, repository names,
+prompts or review content. Rows are still deleted after 90 days.
+
+`prreviewbuddy config set telemetry-upload off` turns it off, as does the Privacy section of the
+workspace Settings page, and `PRB_TELEMETRY=off` still stops the local log as well. The reasoning
+for the change, and what it replaced, is written out at https://prreviewbuddy.com/privacy.
+
+**Copy says "non-identifying" rather than "anonymous".** The events carry a random installation ID
+that persists, and a stable identifier makes data pseudonymous however little else is attached to
+it. The word changed; what is sent did not.
+
 ## 0.29.1
 
 **Icons in the review sidebar.** Every item in a review's sidebar now has an icon: Review, KISS,

package/README.md

@@ -44,10 +44,11 @@ an assistant that has read the diff. The job is durable, so closing the terminal
 Your code goes to the coding agent you chose, exactly as it would if you had run that agent
 yourself. It does not pass through us, and no server of ours is in the path of a review.
 
-PR Review Buddy asks once, on first run, whether it may send anonymous usage counts: two event
-names, a random ID generated on your machine, the version, the platform, the agent and a duration.
-Never your code, diffs, file paths, repository names, prompts or review content, and never anything
-at all unless you said yes. [The full field table is published](https://prreviewbuddy.com/privacy).
+PR Review Buddy sends non-identifying usage telemetry, on by default and off with one command: two
+event names, a random ID generated on your machine, the version, the platform, the agent and a
+duration. Never your code, diffs, file paths, repository names, prompts or review content.
+`prreviewbuddy config set telemetry-upload off` stops it.
+[The full field table is published](https://prreviewbuddy.com/privacy).
 
 More at [prreviewbuddy.com](https://prreviewbuddy.com).
 
@@ -80,7 +81,7 @@ prreviewbuddy open <review>             open one review
 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 anonymous usage counts, or stop
+                                        send usage telemetry, or stop. On by default
 
 prreviewbuddy uninstall                 remove everything this put on your machine
 ```
@@ -167,10 +168,10 @@ ID** and **Delete review**, and the menu on a card deletes every review of that
 </details>
 
 <details>
-<summary><b>Anonymous usage counts</b> — what is sent, and how to stop it</summary>
+<summary><b>Usage telemetry</b> — what is sent, and how to stop it</summary>
 
-Two events reach a server we run, and only if you answered yes when asked on first run:
-`review_started` and `review_finished`. Between them they carry a random UUID generated on your
+Two events reach a server we run, on by default since 0.30.0: `review_started` and
+`review_finished`. Between them they carry a random UUID generated on your
 machine, the CLI version, the platform, which agent ran the analysis, a timestamp, whether it
 succeeded and how long it took. That is the whole list, and the server refuses any field that is
 not on it rather than accepting the request and dropping what it does not recognise.

package/dist/{delete_review-DUCSC5Bc.js → delete_review-C2wax0ED.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 } : {};
@@ -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
@@ -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 {
@@ -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
 	};
@@ -5110,18 +5290,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 +5348,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));
 }
 /**
@@ -9298,26 +9508,32 @@ async function withUsageRecorded(workspaceId, kind, env, body, runId, requestedM
 */
 var UPLOAD_KEY = "telemetryUpload";
 /**
-* The answer to the first-run question, or `null` if it has not been asked yet.
+* What this machine was told to do about transmission, or `null` if nobody ever said.
 *
-* Three states rather than two, and the third is load-bearing: an install that has never been
-* asked must be asked, and must not be treated as having declined. Collapsing `null` to `false`
-* here would make the question unaskable the moment anything read the setting.
+* Three states rather than two, and the third is load-bearing in both directions: it is what lets
+* `upload.ts` apply a default without overwriting anybody's answer, and what lets the CLI disclose
+* the default to the machines it actually applies to and nobody else.
 */
 function telemetryUploadConsent() {
 	return loadConfig().telemetryUpload;
 }
-/** Whether a subset may go over the wire. Yes only if somebody said yes. */
+/**
+* Whether a subset may go over the wire. Yes unless somebody said no.
+*
+* `!== false` rather than `=== true`, and that is the whole of the 0.30.0 change in one operator.
+* Opt in measured who answers questions rather than who uses this: one or two installations
+* reporting against hundreds of weekly downloads. What is sent did not widen by a field.
+*/
 function telemetryUploadEnabled() {
 	const config = loadConfig();
-	return config.telemetry && config.telemetryUpload === true;
+	return config.telemetry && config.telemetryUpload !== false;
 }
 /**
-* Remember the answer, so the question is asked once on a machine and never again.
+* Remember a decision somebody made, so it outlives any change to the default.
 *
 * Read-modify-write through `config_file.ts`, and refuses outright while `PRB_TELEMETRY=off` is
-* set: the kill switch means nothing is asked, so there is no answer to store, and writing one
-* would record a decision nobody made.
+* set: the kill switch means nothing is being sent and nobody is being asked anything, so there is
+* no answer to store, and writing one would record a decision nobody made.
 */
 function recordTelemetryUploadConsent(answer) {
 	if (process.env.PRB_TELEMETRY === "off") return;
@@ -9366,7 +9582,7 @@ function loadConfig() {
 	} catch {}
 	return config;
 }
-/** Anything that is not exactly `true` or `false` is nobody having answered. */
+/** Anything that is not exactly `true` or `false` is nobody having chosen. */
 function consentOf(value) {
 	return typeof value === "boolean" ? value : null;
 }
@@ -9415,7 +9631,7 @@ function project(record) {
 	} : base;
 }
 /**
-* Send one event, if there is one to send and somebody said it could be.
+* Send one event, if there is one to send and nobody has said not to.
 *
 * Returns nothing and awaits nothing. A failed send is a lost data point, which is a cost we
 * accept; a thrown error here would be a review that did not happen, which is not. The same
@@ -9742,6 +9958,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: {
@@ -9910,7 +10127,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 ?? "",
@@ -9929,6 +10146,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,
@@ -9937,6 +10155,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`
@@ -10959,6 +11198,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.
 *
@@ -10967,6 +11208,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: {
@@ -11572,4 +11814,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 { 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 };