@diffohq/diffo 0.17.2 → 0.18.0

package/dist/cli.mjs

@@ -124,6 +124,59 @@ function detectHarness() {
 	}
 }
 //#endregion
+//#region src/shared/anchors.ts
+function findHunk$1(files, id) {
+	for (const file of files) {
+		const hunk = file.hunks.find((h) => h.id === id);
+		if (hunk) return hunk;
+	}
+}
+/** Index of the line numbered `line` on `side`, or -1: a deleted line is not
+* on the new side, an added one not on the old. */
+function indexOfSideLine(lines, side, line) {
+	return lines.findIndex((l) => side === "old" ? l.kind !== "add" && l.oldNo === line : l.kind !== "del" && l.newNo === line);
+}
+/**
+* The same hunk, numbered as another diff numbers it. A hunk id is
+* content-addressed — the path and the changed lines, not where they sit — so
+* the hunk a commit introduced and the one the full diff still shows are one
+* id with two sets of line numbers whenever a later commit grew the file
+* above it. A thread anchored in one numbering is renamed into the other by
+* position in the hunk: line k of the hunk here is line k of the hunk there.
+*
+* Unchanged when either diff lacks the hunk, or when the two copies differ in
+* shape (a context line more or less): then the numbers cannot be trusted and
+* the anchor is left as it was, for placement to re-home by line as usual.
+*/
+function translateHunkAnchor(anchor, from, to) {
+	const src = findHunk$1(from, anchor.hunkId);
+	const dst = findHunk$1(to, anchor.hunkId);
+	if (!src || !dst || src === dst) return anchor;
+	if (src.lines.length !== dst.lines.length) return anchor;
+	if (src.lines.some((l, i) => l.kind !== dst.lines[i].kind)) return anchor;
+	const rename = (n) => {
+		const i = indexOfSideLine(src.lines, anchor.side, n);
+		if (i === -1) return null;
+		const l = dst.lines[i];
+		return anchor.side === "old" ? l.oldNo : l.newNo;
+	};
+	const line = rename(anchor.line);
+	if (line === null) return anchor;
+	if (anchor.endLine === void 0) return line === anchor.line ? anchor : {
+		...anchor,
+		line
+	};
+	const endLine = rename(anchor.endLine);
+	return endLine === null ? {
+		...anchor,
+		line
+	} : {
+		...anchor,
+		line,
+		endLine
+	};
+}
+//#endregion
 //#region src/shared/review.ts
 const THREAD_INTENTS = ["fix", "question"];
 /** A review comment on GitHub tops out at 65 536 characters; a suggestion that
@@ -260,11 +313,7 @@ function describeAnchor(anchor) {
 /** A comment can anchor to a long range; the frozen text keeps its head. */
 const ANCHORED_TEXT_CAP = 10;
 function findHunk(changeset, hunkId) {
-	for (const file of changeset.files) {
-		const hunk = file.hunks.find((h) => h.id === hunkId);
-		if (hunk) return hunk;
-	}
-	return null;
+	return findHunk$1(changeset.files, hunkId) ?? null;
 }
 /**
 * Freeze what a new thread anchors to: the whole hunk as a diff snapshot, plus
@@ -1377,74 +1426,6 @@ function parseLayersInput(raw) {
 		items
 	};
 }
-//#endregion
-//#region src/cliArgs.ts
-const HELP_TEXT = `diffo: review a changeset the way you'd read a book
-
-Usage: diffo [options]          open (or resume) the review for this repo
-       diffo <target> [options] review against a branch, or review a pull request
-       diffo <command> [...]    manage the server, or talk to the review
-       diffo help [command]     show help for a command
-
-The target:
-  <branch>           everything since forking from that branch (same as --base)
-  <PR URL>           a GitHub pull request (also owner/repo#N, #N, or N)
-                     (the short forms resolve against this repo's origin)
-
-For the reviewer:
-  pr <target>        Review a pull request (the same as \`diffo <target>\`,
-                     and the explicit answer for a pull request of your own;
-                     help pr explains the flow)
-  status             Show this repo's review server, if one is running
-                     (--json for a machine-readable answer)
-  stop               Stop this repo's review server
-  clean              Remove the worktrees diffo made for pull requests whose
-                     review is over (--force takes dirty ones, and ones a
-                     running server still serves; --all takes every one)
-  setup              Register diffo with the coding agents on this machine
-                     (Claude Code, Cursor, VS Code, Copilot, and the shared
-                     ~/.agents skills dir read by Codex, Gemini, Amp, Goose, …)
-  telemetry          Show whether anonymous usage data is on, or turn it
-                     off / on (telemetry off · telemetry on)
-
-For the agent (the AI that wrote the change):
-  poll               Wait for the reviewer's feedback (blocking long-poll;
-                     prints one JSON payload; safe to re-run any time)
-                     (--title "<what the change is>" on the first poll names
-                     the reviewer's browser tab)
-  reply <threadId>   Post a reply to a review thread
-                     (--message "<text>", or pipe the text on stdin)
-  comment [<file>]   Start a comment thread as the agent: on a line (--line),
-                     a file, or (with no file) the whole changeset; the
-                     reviewer replies to take it up, or resolves it
-  layers             Outline the changeset as steps to read in order
-                     (--suggest ["why"] flags it at open; --json '<Layer[]>'
-                     or --stdin posts the list, replacing the last one)
-  end                Detach from the review politely
-  help agent         The agent's whole protocol on one page
-  help guide         The guide comment — the map of the change — with an example
-
-Options (for opening the review):
-  --base <branch>    Review everything since forking from <branch>
-                     (default: working tree vs HEAD)
-  -p, --port <port>  Port to serve on (default: the port this repo last used,
-                     else the first free one)
-  --no-open          Don't open the browser automatically
-  --foreground       Run the server in this terminal instead of leaving a
-                     background one behind (Ctrl-C stops it)
-  -v, --version      Show version
-  -h, --help         Show this help
-
-Examples:
-  diffo                        open the review for this repo in the browser
-  diffo main                   review everything since forking from main
-  diffo https://github.com/o/r/pull/482
-                               review pull request #482 with your agent as copilot
-  diffo status                 is a server running here, and where?
-  diffo reply t-3 -m "fixed"   answer a review thread (agent side)
-
-Feedback lives in the review, not in any process: diffo, poll, status, stop,
-and setup are all safe to re-run after an interruption.`;
 const VERB_HELP = {
 	agent: `diffo help agent: the agent's whole protocol on one page
 
@@ -1796,7 +1777,7 @@ Example:
   diffo telemetry off`
 };
 function helpFor(topic) {
-	return topic && VERB_HELP[topic] || HELP_TEXT;
+	return topic && VERB_HELP[topic] || "diffo: review a changeset the way you'd read a book\n\nUsage: diffo [options]          open (or resume) the review for this repo\n       diffo <target> [options] review against a branch, or review a pull request\n       diffo <command> [...]    manage the server, or talk to the review\n       diffo help [command]     show help for a command\n\nThe target:\n  <branch>           everything since forking from that branch (same as --base)\n  <PR URL>           a GitHub pull request (also owner/repo#N, #N, or N)\n                     (the short forms resolve against this repo's origin)\n\nFor the reviewer:\n  pr <target>        Review a pull request (the same as `diffo <target>`,\n                     and the explicit answer for a pull request of your own;\n                     help pr explains the flow)\n  status             Show this repo's review server, if one is running\n                     (--json for a machine-readable answer)\n  stop               Stop this repo's review server\n  clean              Remove the worktrees diffo made for pull requests whose\n                     review is over (--force takes dirty ones, and ones a\n                     running server still serves; --all takes every one)\n  setup              Register diffo with the coding agents on this machine\n                     (Claude Code, Cursor, VS Code, Copilot, and the shared\n                     ~/.agents skills dir read by Codex, Gemini, Amp, Goose, …)\n  telemetry          Show whether anonymous usage data is on, or turn it\n                     off / on (telemetry off · telemetry on)\n\nFor the agent (the AI that wrote the change):\n  poll               Wait for the reviewer's feedback (blocking long-poll;\n                     prints one JSON payload; safe to re-run any time)\n                     (--title \"<what the change is>\" on the first poll names\n                     the reviewer's browser tab)\n  reply <threadId>   Post a reply to a review thread\n                     (--message \"<text>\", or pipe the text on stdin)\n  comment [<file>]   Start a comment thread as the agent: on a line (--line),\n                     a file, or (with no file) the whole changeset; the\n                     reviewer replies to take it up, or resolves it\n  layers             Outline the changeset as steps to read in order\n                     (--suggest [\"why\"] flags it at open; --json '<Layer[]>'\n                     or --stdin posts the list, replacing the last one)\n  end                Detach from the review politely\n  help agent         The agent's whole protocol on one page\n  help guide         The guide comment — the map of the change — with an example\n\nOptions (for opening the review):\n  --base <branch>    Review everything since forking from <branch>\n                     (default: working tree vs HEAD)\n  -p, --port <port>  Port to serve on (default: the port this repo last used,\n                     else the first free one)\n  --no-open          Don't open the browser automatically\n  --foreground       Run the server in this terminal instead of leaving a\n                     background one behind (Ctrl-C stops it)\n  -v, --version      Show version\n  -h, --help         Show this help\n\nExamples:\n  diffo                        open the review for this repo in the browser\n  diffo main                   review everything since forking from main\n  diffo https://github.com/o/r/pull/482\n                               review pull request #482 with your agent as copilot\n  diffo status                 is a server running here, and where?\n  diffo reply t-3 -m \"fixed\"   answer a review thread (agent side)\n\nFeedback lives in the review, not in any process: diffo, poll, status, stop,\nand setup are all safe to re-run after an interruption.";
 }
 const VERBS = /* @__PURE__ */ new Set([
 	"poll",
@@ -3390,6 +3371,86 @@ async function getFullDiffAsync(root, spec) {
 	const [raw, untracked] = await Promise.all([getRawDiffAsync(root, spec), getUntrackedDiffAsync(root)]);
 	return [raw, untracked].filter(Boolean).join("\n");
 }
+const COMMIT_FIELDS = [
+	"%H",
+	"%h",
+	"%an",
+	"%aI",
+	"%s",
+	"%b"
+].join("%x1f");
+/** `3 files changed, 10 insertions(+), 2 deletions(-)` — any part may be absent. */
+function parseShortstat(line) {
+	const n = (re) => Number.parseInt(re.exec(line)?.[1] ?? "0", 10);
+	return {
+		files: n(/(\d+) files? changed/),
+		additions: n(/(\d+) insertions?\(\+\)/),
+		deletions: n(/(\d+) deletions?\(-\)/)
+	};
+}
+/**
+* The commits a branch review spans, oldest first. A working-tree review has
+* none: its changeset is not made of commits. Merges are skipped — what they
+* bring in is the base branch, which this review is not about.
+*/
+async function branchStart(root, base) {
+	try {
+		return (await gitAsync(root, [
+			"merge-base",
+			base,
+			"HEAD"
+		])).trim();
+	} catch {
+		throw new MissingBaseError(base);
+	}
+}
+/** Just the shas of `listCommitsAsync`, in the same order: a `rev-list`, no
+* per-commit stats, so a route that only needs to know whether a sha is in the
+* changeset does not pay for diffing every commit. */
+async function listCommitShasAsync(root, spec) {
+	if (spec.kind !== "branch") return [];
+	return (await gitAsync(root, [
+		"rev-list",
+		"--reverse",
+		"--no-merges",
+		`${await branchStart(root, spec.base)}..HEAD`
+	])).split("\n").filter((sha) => sha !== "");
+}
+async function listCommitsAsync(root, spec) {
+	if (spec.kind !== "branch") return [];
+	const mergeBase = await branchStart(root, spec.base);
+	return (await gitAsync(root, [
+		"log",
+		"--reverse",
+		"--no-merges",
+		"--no-color",
+		`--format=%x1e${COMMIT_FIELDS}%x1f`,
+		"--shortstat",
+		`${mergeBase}..HEAD`
+	])).split("").filter((chunk) => chunk.trim() !== "").map((chunk) => {
+		const [sha = "", short = "", author = "", at = "", subject = "", body = "", stat = ""] = chunk.split("");
+		return {
+			sha,
+			short,
+			author,
+			at,
+			subject,
+			body: body.trim(),
+			stats: parseShortstat(stat)
+		};
+	});
+}
+/** One commit's own patch, against its first parent — or against nothing, for
+* a root commit, which `git show` handles where `sha^` would not resolve. */
+async function getCommitDiffAsync(root, sha) {
+	return gitAsync(root, [
+		"show",
+		"--format=",
+		"--patch",
+		...DIFF_FLAGS,
+		sha
+	]);
+}
 function isSafeRepoPath(root, relPath) {
 	return resolve(root, relPath).startsWith(resolve(root) + sep);
 }
@@ -3980,86 +4041,396 @@ const VERSION = (() => {
 	return "0.0.0";
 })();
 //#endregion
-//#region src/server/delivery.ts
-const STALL_AFTER_MS = 3e5;
-const REPLY_GRACE_MS = 9e4;
-/** A re-poll within this window of a delivery reads as "hasn't started yet". */
-const BATCH_SETTLE_MS = 2e3;
-/** Signal 0 probes existence without touching the process; EPERM still proves it exists. */
-function pidAlive(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (err) {
-		return err.code === "EPERM";
-	}
+//#region src/shared/types.ts
+/** The working-tree edits a branch review also carries, listed after the
+* commits as one more step to read. Not a sha, so it can never collide with one. */
+const UNCOMMITTED = "uncommitted";
+//#endregion
+//#region src/server/parse.ts
+const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".bmp",
+	".svg",
+	".ico",
+	".avif"
+]);
+function isImagePath(path) {
+	const dot = path.lastIndexOf(".");
+	return dot !== -1 && IMAGE_EXTENSIONS.has(path.slice(dot).toLowerCase());
 }
-var DeliveryQueue = class DeliveryQueue {
-	stallAfterMs;
-	replyGraceMs;
-	liveness;
-	batchSettleMs;
-	buckets = /* @__PURE__ */ new Map();
-	scope = "";
-	waiter = null;
-	awaitingReply = false;
-	/** Thread id -> epoch ms it was delivered. */
-	deliveredAt = /* @__PURE__ */ new Map();
-	listeners = /* @__PURE__ */ new Set();
-	stalled = false;
-	stallTimer = null;
-	betweenPolls = false;
-	/** Why the agent is parked between polls: a reply just landed, its poll
-	* ended on its own and the re-poll is expected, or it opened the review and
-	* is still orienting itself before its first poll. */
-	parked = "replied";
-	graceTimer = null;
-	lastDetach = null;
-	since = Date.now();
-	lastDetail = {
-		state: "waiting",
-		reason: "no-agent"
+/** Content-addressed hunk identity: the hash covers the file path and the changed
+* lines only — not line numbers, not context. Editing the hunk itself mints a new
+* id; the occurrence index separates identical hunks within one file. */
+function hunkId(path, lines, occurrence) {
+	const changed = lines.filter((l) => l.kind !== "context").map((l) => `${l.kind === "add" ? "+" : "-"}${l.text}`).join("\n");
+	return createHash("sha256").update(`${path}\0${changed}\0${occurrence}`).digest("hex").slice(0, 16);
+}
+function parseSectionMeta(section) {
+	return {
+		renamedFrom: section.match(/^rename from (.+)$/m)?.[1] ?? null,
+		renamedTo: section.match(/^rename to (.+)$/m)?.[1] ?? null,
+		binary: /^Binary files .* differ$/m.test(section) || /^GIT binary patch$/m.test(section),
+		symlink: /^(?:new file|deleted file|new|old) mode 120000$/m.test(section) || /^index [0-9a-f.]+ 120000$/m.test(section)
 	};
-	owner = null;
-	/** The session pid that last received the full reply protocol. Later
-	* deliveries to the same session carry the compact form — the full text is
-	* the loop's largest recurring token cost. A takeover (new pid) or an
-	* anonymous session (null pid) always gets the full form again. */
-	protocolPid = null;
-	batch = null;
-	batchWatch = null;
-	waiterWatch = null;
-	batchListeners = /* @__PURE__ */ new Set();
-	constructor(stallAfterMs = STALL_AFTER_MS, replyGraceMs = REPLY_GRACE_MS, liveness = {}, batchSettleMs = BATCH_SETTLE_MS) {
-		this.stallAfterMs = stallAfterMs;
-		this.replyGraceMs = replyGraceMs;
-		this.liveness = liveness;
-		this.batchSettleMs = batchSettleMs;
+}
+function splitSections(patch) {
+	if (!patch.trim()) return [];
+	const sections = [];
+	const lines = patch.split("\n");
+	let current = null;
+	for (const line of lines) if (line.startsWith("diff --git ")) {
+		if (current) sections.push(current.join("\n"));
+		current = [line];
+	} else if (current) current.push(line);
+	if (current) sections.push(current.join("\n"));
+	return sections;
+}
+/**
+* `@@ -oldStart,oldCount +newStart,newCount @@ scope`. Both counts are optional in
+* the format and mean 1 when absent (`@@ -1 +1 @@`). The trailing scope is git's own
+* guess at what you are inside.
+*/
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
+/**
+* Read one hunk body, starting at the line after its header. The declared counts
+* are authoritative: consume exactly that many old and new lines and stop, rather
+* than reading up to the next `@@` — git's own rule, and what keeps the blank line
+* every patch ends with out of the last hunk.
+*/
+function parseHunkBody(lines, start, oldStart, newStart, oldCount, newCount) {
+	const out = [];
+	let oldNo = oldStart;
+	let newNo = newStart;
+	let remainingOld = oldCount;
+	let remainingNew = newCount;
+	let i = start;
+	while (remainingOld > 0 || remainingNew > 0) {
+		const line = lines[i];
+		if (line === void 0) break;
+		if (line.startsWith("@@") || line.startsWith("diff --git ")) break;
+		i++;
+		if (line.startsWith("\\")) continue;
+		if (line.startsWith("+")) {
+			out.push({
+				kind: "add",
+				oldNo: null,
+				newNo: newNo++,
+				text: line.slice(1)
+			});
+			remainingNew--;
+		} else if (line.startsWith("-")) {
+			out.push({
+				kind: "del",
+				oldNo: oldNo++,
+				newNo: null,
+				text: line.slice(1)
+			});
+			remainingOld--;
+		} else {
+			out.push({
+				kind: "context",
+				oldNo: oldNo++,
+				newNo: newNo++,
+				text: line.slice(1)
+			});
+			remainingOld--;
+			remainingNew--;
+		}
 	}
-	onBatchClosed(listener) {
-		this.batchListeners.add(listener);
-		return () => this.batchListeners.delete(listener);
+	return {
+		lines: out,
+		next: i
+	};
+}
+function parseHunks(lines) {
+	const hunks = [];
+	let i = 0;
+	while (i < lines.length) {
+		const header = lines[i]?.match(HUNK_HEADER);
+		if (!header) {
+			i++;
+			continue;
+		}
+		const oldStart = Number(header[1]);
+		const newStart = Number(header[3]);
+		const body = parseHunkBody(lines, i + 1, oldStart, newStart, header[2] === void 0 ? 1 : Number(header[2]), header[4] === void 0 ? 1 : Number(header[4]));
+		const context = (header[5] ?? "").trim();
+		hunks.push({
+			oldStart,
+			newStart,
+			context: context === "" ? null : context,
+			lines: body.lines
+		});
+		i = body.next;
 	}
-	closeBatch(reason) {
-		const batch = this.batch;
-		if (!batch) return;
-		const closed = {
-			threadIds: batch.threadIds,
-			unanswered: [...this.deliveredAt.keys()],
-			deliveredAt: batch.deliveredAt,
-			closedAt: Date.now(),
-			reason
-		};
-		this.batch = null;
-		this.deliveredAt.clear();
-		this.awaitingReply = false;
-		this.stalled = false;
-		this.clearStall();
-		this.clearBatchWatch();
-		for (const listener of this.batchListeners) listener(closed);
+	return hunks;
+}
+/**
+* `--- a/x` / `+++ b/x`, read only from the part of the section before the first
+* `@@`. That bound is load-bearing: inside a hunk body an added line starting with
+* `++` is spelled `+++ …`, so scanning the whole section would read file content as
+* a path header.
+*/
+function parseSectionPaths(section, lines) {
+	let from = null;
+	let to = null;
+	for (const line of lines) {
+		if (line.startsWith("@@")) break;
+		if (from === null && line.startsWith("--- ")) from = diffPath(line.slice(4));
+		else if (to === null && line.startsWith("+++ ")) to = diffPath(line.slice(4));
 	}
-	armBatchWatch() {
-		this.clearBatchWatch();
+	return {
+		from,
+		to,
+		isNew: from === "/dev/null" || /^new file mode /m.test(section),
+		isDeleted: to === "/dev/null" || /^deleted file mode /m.test(section)
+	};
+}
+function diffPath(raw) {
+	const path = raw.split("	", 1)[0] ?? raw;
+	return path === "/dev/null" ? path : stripAB(path);
+}
+function parsePatch(patch) {
+	const files = [];
+	for (const section of splitSections(patch)) {
+		const sectionLines = section.split("\n");
+		const meta = parseSectionMeta(section);
+		const paths = parseSectionPaths(section, sectionLines);
+		let path;
+		let oldPath = null;
+		let status;
+		if (meta.renamedTo) {
+			path = meta.renamedTo;
+			oldPath = meta.renamedFrom;
+			status = "renamed";
+		} else if (paths.isNew) {
+			path = paths.to ?? headerPath(section);
+			status = "added";
+		} else if (paths.isDeleted) {
+			path = paths.from ?? headerPath(section);
+			status = "deleted";
+		} else if (paths.to !== null && paths.to !== "/dev/null") {
+			path = paths.to;
+			status = "modified";
+		} else {
+			path = headerPath(section);
+			status = "modified";
+		}
+		const kind = meta.symlink ? "symlink" : meta.binary ? isImagePath(path) ? "image" : "binary" : isImagePath(path) ? "image" : "text";
+		const seen = /* @__PURE__ */ new Map();
+		const hunks = meta.binary ? [] : parseHunks(sectionLines).map((hunk) => {
+			const lines = hunk.lines;
+			const contentKey = lines.filter((l) => l.kind !== "context").map((l) => `${l.kind}:${l.text}`).join("\n");
+			const occurrence = seen.get(contentKey) ?? 0;
+			seen.set(contentKey, occurrence + 1);
+			return {
+				id: hunkId(path, lines, occurrence),
+				path,
+				oldStart: hunk.oldStart,
+				newStart: hunk.newStart,
+				lines,
+				...hunk.context === null ? {} : { context: hunk.context }
+			};
+		});
+		files.push({
+			path,
+			oldPath,
+			status,
+			kind,
+			staged: false,
+			hunks
+		});
+	}
+	return files;
+}
+function stripAB(p) {
+	return p.startsWith("b/") || p.startsWith("a/") ? p.slice(2) : p;
+}
+function headerPath(section) {
+	const header = section.split("\n", 1)[0] ?? "";
+	return header.match(/^diff --git a\/(.*) b\/(.*)$/)?.[2] ?? header.replace(/^diff --git /, "");
+}
+//#endregion
+//#region src/server/commits.ts
+function stats$2(files) {
+	let additions = 0;
+	let deletions = 0;
+	for (const file of files) for (const hunk of file.hunks) for (const line of hunk.lines) if (line.kind === "add") additions++;
+	else if (line.kind === "del") deletions++;
+	return {
+		files: files.length,
+		additions,
+		deletions
+	};
+}
+/** A commit's diff has no working-tree file to size a trailing gap from, so
+* `newLineCount` stays unknown and that gap is simply not offered. The other
+* gaps read the file at `rev`, the commit's own version. */
+const commitFiles = (raw, rev) => parsePatch(raw).map((file) => ({
+	...file,
+	staged: false,
+	newLineCount: null,
+	...rev ? { rev } : {}
+}));
+/**
+* The tab fetches every commit's diff at once, and each is a git process: a
+* few at a time keeps a long branch from spawning one per commit in a burst.
+*/
+const GIT_SLOTS = 4;
+let gitBusy = 0;
+const gitWaiting = [];
+async function withGitSlot(work) {
+	if (gitBusy >= GIT_SLOTS) await new Promise((resolve) => gitWaiting.push(resolve));
+	gitBusy++;
+	try {
+		return await work();
+	} finally {
+		gitBusy--;
+		gitWaiting.shift()?.();
+	}
+}
+/** Whether `sha` is a full sha of one of the changeset's commits: the cheap
+* listing answers, so a reviewer-typed ref never reaches git as one. */
+async function isListedCommit(root, spec, sha) {
+	if (!/^[0-9a-f]{40}$/.test(sha)) return false;
+	return withGitSlot(async () => (await listCommitShasAsync(root, spec)).includes(sha));
+}
+const uncommittedFiles = async (root) => commitFiles(await getFullDiffAsync(root, { kind: "working-tree" }));
+/**
+* The changeset's commits, oldest first. A branch review's diff runs from the
+* merge-base to the *working tree*, so edits not yet committed are part of what
+* is under review: they follow the commits as one more entry, when there are any.
+*/
+async function listCommits(root, spec) {
+	const raw = await listCommitsAsync(root, spec);
+	if (raw.length === 0) return { commits: [] };
+	const commits = raw.map((c) => ({
+		sha: c.sha,
+		short: c.short,
+		subject: c.subject,
+		body: c.body,
+		author: c.author,
+		at: c.at,
+		stats: c.stats
+	}));
+	const pending = await uncommittedFiles(root);
+	if (pending.length > 0) commits.push({
+		sha: UNCOMMITTED,
+		short: "",
+		subject: "Uncommitted changes",
+		body: "",
+		author: null,
+		at: null,
+		stats: stats$2(pending)
+	});
+	return { commits };
+}
+/**
+* One listed commit's own diff. The sha must be one `listCommits` returns: the
+* route never hands git a ref the reviewer typed, only a full sha it already
+* listed — checked against the cheap sha listing, not the one that diffs every
+* commit for its stats. Null when it is not in the changeset.
+*/
+async function getCommitChangeset(root, spec, sha) {
+	if (sha === "uncommitted") {
+		if (spec.kind !== "branch") return null;
+		return {
+			sha,
+			files: await uncommittedFiles(root)
+		};
+	}
+	if (!await isListedCommit(root, spec, sha)) return null;
+	const raw = await withGitSlot(() => getCommitDiffAsync(root, sha));
+	return {
+		sha,
+		files: commitFiles(raw, sha)
+	};
+}
+//#endregion
+//#region src/server/delivery.ts
+const STALL_AFTER_MS = 3e5;
+const REPLY_GRACE_MS = 9e4;
+/** A re-poll within this window of a delivery reads as "hasn't started yet". */
+const BATCH_SETTLE_MS = 2e3;
+/** Signal 0 probes existence without touching the process; EPERM still proves it exists. */
+function pidAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return err.code === "EPERM";
+	}
+}
+var DeliveryQueue = class DeliveryQueue {
+	stallAfterMs;
+	replyGraceMs;
+	liveness;
+	batchSettleMs;
+	buckets = /* @__PURE__ */ new Map();
+	scope = "";
+	waiter = null;
+	awaitingReply = false;
+	/** Thread id -> epoch ms it was delivered. */
+	deliveredAt = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	stalled = false;
+	stallTimer = null;
+	betweenPolls = false;
+	/** Why the agent is parked between polls: a reply just landed, its poll
+	* ended on its own and the re-poll is expected, or it opened the review and
+	* is still orienting itself before its first poll. */
+	parked = "replied";
+	graceTimer = null;
+	lastDetach = null;
+	since = Date.now();
+	lastDetail = {
+		state: "waiting",
+		reason: "no-agent"
+	};
+	owner = null;
+	/** The session pid that last received the full reply protocol. Later
+	* deliveries to the same session carry the compact form — the full text is
+	* the loop's largest recurring token cost. A takeover (new pid) or an
+	* anonymous session (null pid) always gets the full form again. */
+	protocolPid = null;
+	batch = null;
+	batchWatch = null;
+	waiterWatch = null;
+	batchListeners = /* @__PURE__ */ new Set();
+	constructor(stallAfterMs = STALL_AFTER_MS, replyGraceMs = REPLY_GRACE_MS, liveness = {}, batchSettleMs = BATCH_SETTLE_MS) {
+		this.stallAfterMs = stallAfterMs;
+		this.replyGraceMs = replyGraceMs;
+		this.liveness = liveness;
+		this.batchSettleMs = batchSettleMs;
+	}
+	onBatchClosed(listener) {
+		this.batchListeners.add(listener);
+		return () => this.batchListeners.delete(listener);
+	}
+	closeBatch(reason) {
+		const batch = this.batch;
+		if (!batch) return;
+		const closed = {
+			threadIds: batch.threadIds,
+			unanswered: [...this.deliveredAt.keys()],
+			deliveredAt: batch.deliveredAt,
+			closedAt: Date.now(),
+			reason
+		};
+		this.batch = null;
+		this.deliveredAt.clear();
+		this.awaitingReply = false;
+		this.stalled = false;
+		this.clearStall();
+		this.clearBatchWatch();
+		for (const listener of this.batchListeners) listener(closed);
+	}
+	armBatchWatch() {
+		this.clearBatchWatch();
 		const isAlive = this.liveness.isAlive ?? pidAlive;
 		const timer = setInterval(() => {
 			if (!this.batch) return this.clearBatchWatch();
@@ -4822,6 +5193,14 @@ function githubPosition(anchor, body, files) {
 		downgraded: false
 	};
 	const file = files.find((f) => f.path === anchor.path);
+	if (anchor.commit !== void 0 && !file?.hunks.some((h) => h.id === anchor.hunkId)) return {
+		draft: {
+			path: anchor.path,
+			body,
+			subjectType: "FILE"
+		},
+		downgraded: true
+	};
 	const has = (n) => file?.hunks.some((h) => h.lines.some((l) => anchor.side === "old" ? l.kind !== "add" && l.oldNo === n : l.kind !== "del" && l.newNo === n)) ?? false;
 	const end = anchor.endLine ?? anchor.line;
 	if (!has(end) || !has(anchor.line)) return {
@@ -6253,13 +6632,15 @@ function parseAnchor(value) {
 		if (anchor.side !== "old" && anchor.side !== "new") return null;
 		if (typeof anchor.line !== "number") return null;
 		const endLine = typeof anchor.endLine === "number" && Number.isInteger(anchor.endLine) && anchor.endLine > anchor.line ? anchor.endLine : void 0;
+		const commit = typeof anchor.commit === "string" && /^[0-9a-f]{40}$/.test(anchor.commit) ? anchor.commit : void 0;
 		return {
 			kind: "hunk",
 			hunkId: anchor.hunkId,
 			path: anchor.path,
 			side: anchor.side,
 			line: anchor.line,
-			...endLine !== void 0 ? { endLine } : {}
+			...endLine !== void 0 ? { endLine } : {},
+			...commit !== void 0 ? { commit } : {}
 		};
 	}
 	if (anchor.kind === "file") return typeof anchor.path === "string" ? {
@@ -6460,215 +6841,6 @@ function normalizePr(value) {
 	};
 }
 //#endregion
-//#region src/server/parse.ts
-const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
-	".png",
-	".jpg",
-	".jpeg",
-	".gif",
-	".webp",
-	".bmp",
-	".svg",
-	".ico",
-	".avif"
-]);
-function isImagePath(path) {
-	const dot = path.lastIndexOf(".");
-	return dot !== -1 && IMAGE_EXTENSIONS.has(path.slice(dot).toLowerCase());
-}
-/** Content-addressed hunk identity: the hash covers the file path and the changed
-* lines only — not line numbers, not context. Editing the hunk itself mints a new
-* id; the occurrence index separates identical hunks within one file. */
-function hunkId(path, lines, occurrence) {
-	const changed = lines.filter((l) => l.kind !== "context").map((l) => `${l.kind === "add" ? "+" : "-"}${l.text}`).join("\n");
-	return createHash("sha256").update(`${path}\0${changed}\0${occurrence}`).digest("hex").slice(0, 16);
-}
-function parseSectionMeta(section) {
-	return {
-		renamedFrom: section.match(/^rename from (.+)$/m)?.[1] ?? null,
-		renamedTo: section.match(/^rename to (.+)$/m)?.[1] ?? null,
-		binary: /^Binary files .* differ$/m.test(section) || /^GIT binary patch$/m.test(section),
-		symlink: /^(?:new file|deleted file|new|old) mode 120000$/m.test(section) || /^index [0-9a-f.]+ 120000$/m.test(section)
-	};
-}
-function splitSections(patch) {
-	if (!patch.trim()) return [];
-	const sections = [];
-	const lines = patch.split("\n");
-	let current = null;
-	for (const line of lines) if (line.startsWith("diff --git ")) {
-		if (current) sections.push(current.join("\n"));
-		current = [line];
-	} else if (current) current.push(line);
-	if (current) sections.push(current.join("\n"));
-	return sections;
-}
-/**
-* `@@ -oldStart,oldCount +newStart,newCount @@ scope`. Both counts are optional in
-* the format and mean 1 when absent (`@@ -1 +1 @@`). The trailing scope is git's own
-* guess at what you are inside.
-*/
-const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
-/**
-* Read one hunk body, starting at the line after its header. The declared counts
-* are authoritative: consume exactly that many old and new lines and stop, rather
-* than reading up to the next `@@` — git's own rule, and what keeps the blank line
-* every patch ends with out of the last hunk.
-*/
-function parseHunkBody(lines, start, oldStart, newStart, oldCount, newCount) {
-	const out = [];
-	let oldNo = oldStart;
-	let newNo = newStart;
-	let remainingOld = oldCount;
-	let remainingNew = newCount;
-	let i = start;
-	while (remainingOld > 0 || remainingNew > 0) {
-		const line = lines[i];
-		if (line === void 0) break;
-		if (line.startsWith("@@") || line.startsWith("diff --git ")) break;
-		i++;
-		if (line.startsWith("\\")) continue;
-		if (line.startsWith("+")) {
-			out.push({
-				kind: "add",
-				oldNo: null,
-				newNo: newNo++,
-				text: line.slice(1)
-			});
-			remainingNew--;
-		} else if (line.startsWith("-")) {
-			out.push({
-				kind: "del",
-				oldNo: oldNo++,
-				newNo: null,
-				text: line.slice(1)
-			});
-			remainingOld--;
-		} else {
-			out.push({
-				kind: "context",
-				oldNo: oldNo++,
-				newNo: newNo++,
-				text: line.slice(1)
-			});
-			remainingOld--;
-			remainingNew--;
-		}
-	}
-	return {
-		lines: out,
-		next: i
-	};
-}
-function parseHunks(lines) {
-	const hunks = [];
-	let i = 0;
-	while (i < lines.length) {
-		const header = lines[i]?.match(HUNK_HEADER);
-		if (!header) {
-			i++;
-			continue;
-		}
-		const oldStart = Number(header[1]);
-		const newStart = Number(header[3]);
-		const body = parseHunkBody(lines, i + 1, oldStart, newStart, header[2] === void 0 ? 1 : Number(header[2]), header[4] === void 0 ? 1 : Number(header[4]));
-		const context = (header[5] ?? "").trim();
-		hunks.push({
-			oldStart,
-			newStart,
-			context: context === "" ? null : context,
-			lines: body.lines
-		});
-		i = body.next;
-	}
-	return hunks;
-}
-/**
-* `--- a/x` / `+++ b/x`, read only from the part of the section before the first
-* `@@`. That bound is load-bearing: inside a hunk body an added line starting with
-* `++` is spelled `+++ …`, so scanning the whole section would read file content as
-* a path header.
-*/
-function parseSectionPaths(section, lines) {
-	let from = null;
-	let to = null;
-	for (const line of lines) {
-		if (line.startsWith("@@")) break;
-		if (from === null && line.startsWith("--- ")) from = diffPath(line.slice(4));
-		else if (to === null && line.startsWith("+++ ")) to = diffPath(line.slice(4));
-	}
-	return {
-		from,
-		to,
-		isNew: from === "/dev/null" || /^new file mode /m.test(section),
-		isDeleted: to === "/dev/null" || /^deleted file mode /m.test(section)
-	};
-}
-function diffPath(raw) {
-	const path = raw.split("	", 1)[0] ?? raw;
-	return path === "/dev/null" ? path : stripAB(path);
-}
-function parsePatch(patch) {
-	const files = [];
-	for (const section of splitSections(patch)) {
-		const sectionLines = section.split("\n");
-		const meta = parseSectionMeta(section);
-		const paths = parseSectionPaths(section, sectionLines);
-		let path;
-		let oldPath = null;
-		let status;
-		if (meta.renamedTo) {
-			path = meta.renamedTo;
-			oldPath = meta.renamedFrom;
-			status = "renamed";
-		} else if (paths.isNew) {
-			path = paths.to ?? headerPath(section);
-			status = "added";
-		} else if (paths.isDeleted) {
-			path = paths.from ?? headerPath(section);
-			status = "deleted";
-		} else if (paths.to !== null && paths.to !== "/dev/null") {
-			path = paths.to;
-			status = "modified";
-		} else {
-			path = headerPath(section);
-			status = "modified";
-		}
-		const kind = meta.symlink ? "symlink" : meta.binary ? isImagePath(path) ? "image" : "binary" : isImagePath(path) ? "image" : "text";
-		const seen = /* @__PURE__ */ new Map();
-		const hunks = meta.binary ? [] : parseHunks(sectionLines).map((hunk) => {
-			const lines = hunk.lines;
-			const contentKey = lines.filter((l) => l.kind !== "context").map((l) => `${l.kind}:${l.text}`).join("\n");
-			const occurrence = seen.get(contentKey) ?? 0;
-			seen.set(contentKey, occurrence + 1);
-			return {
-				id: hunkId(path, lines, occurrence),
-				path,
-				oldStart: hunk.oldStart,
-				newStart: hunk.newStart,
-				lines,
-				...hunk.context === null ? {} : { context: hunk.context }
-			};
-		});
-		files.push({
-			path,
-			oldPath,
-			status,
-			kind,
-			staged: false,
-			hunks
-		});
-	}
-	return files;
-}
-function stripAB(p) {
-	return p.startsWith("b/") || p.startsWith("a/") ? p.slice(2) : p;
-}
-function headerPath(section) {
-	const header = section.split("\n", 1)[0] ?? "";
-	return header.match(/^diff --git a\/(.*) b\/(.*)$/)?.[2] ?? header.replace(/^diff --git /, "");
-}
-//#endregion
 //#region src/server/changeset.ts
 function stats$1(files) {
 	let additions = 0;
@@ -7379,8 +7551,17 @@ function createApp(ctx, store, review, queue) {
 				edited: message.prComment.text.trim() !== text
 			};
 		}
-		const capture = store ? captureAnchor(store.get(), anchor, review.get().layers) : null;
-		const created = review.createThread(anchor, text, capture, intent, "reviewer", {
+		const commitFiles = store && anchor.kind === "hunk" && typeof body?.commit === "string" ? (await getCommitChangeset(ctx.root, ctx.spec, body.commit).catch(() => null))?.files ?? null : null;
+		const placed = commitFiles && anchor.kind === "hunk" ? findHunk$1(store.get().files, anchor.hunkId) ? translateHunkAnchor(anchor, commitFiles, store.get().files) : {
+			...anchor,
+			commit: body.commit
+		} : anchor;
+		let capture = store ? captureAnchor(store.get(), placed, review.get().layers) : null;
+		if (store && !capture && commitFiles) capture = captureAnchor({
+			...store.get(),
+			files: commitFiles
+		}, anchor);
+		const created = review.createThread(placed, text, capture, intent, "reviewer", {
 			...audience ? { audience } : {},
 			...parentId ? { parentId } : {},
 			...origin ? { origin } : {}
@@ -7893,13 +8074,35 @@ function createApp(ctx, store, review, queue) {
 			throw err;
 		}
 	});
-	app.get("/api/file", (c) => {
+	app.get("/api/commits", async (c) => {
+		try {
+			return c.json(await listCommits(ctx.root, ctx.spec));
+		} catch (err) {
+			if (err instanceof MissingBaseError) return c.json({ error: err.message }, 400);
+			throw err;
+		}
+	});
+	app.get("/api/commits/:sha", async (c) => {
+		try {
+			const commit = await getCommitChangeset(ctx.root, ctx.spec, c.req.param("sha"));
+			return commit ? c.json(commit) : c.json({ error: "no such commit in this changeset" }, 404);
+		} catch (err) {
+			if (err instanceof MissingBaseError) return c.json({ error: err.message }, 400);
+			throw err;
+		}
+	});
+	app.get("/api/file", async (c) => {
 		const path = c.req.query("path");
 		const side = c.req.query("side");
+		const rev = c.req.query("rev");
 		if (!path || side !== "base" && side !== "head") return c.json({ error: "need ?path= and ?side=base|head" }, 400);
 		let bytes;
 		try {
-			bytes = side === "head" ? getHeadFileBytes(ctx.root, path) : getBaseFileBytes(ctx.root, resolveBaseRef(ctx.root, ctx.spec), path);
+			if (rev !== void 0) {
+				if (side !== "head") return c.json({ error: "?rev= reads the head side only" }, 400);
+				if (!await isListedCommit(ctx.root, ctx.spec, rev)) return c.json({ error: "no such commit in this changeset" }, 404);
+				bytes = getBaseFileBytes(ctx.root, rev, path);
+			} else bytes = side === "head" ? getHeadFileBytes(ctx.root, path) : getBaseFileBytes(ctx.root, resolveBaseRef(ctx.root, ctx.spec), path);
 		} catch (err) {
 			if (err instanceof MissingBaseError) return c.json({ error: err.message }, 400);
 			throw err;