diffing 0.10.1 → 0.10.2

package/dist/{server-CRk40DPV.mjs → server-D-gJ7owz.mjs}

@@ -2,8 +2,9 @@ import { C as isSafePath, S as revertHunk, _ as getUntrackedFilePathsAsync, a as
 import { a as searchContent, c as trackSelection, i as searchAll, n as saveSettings, o as searchFiles, r as getSearchStatus, s as searchSymbols, t as loadSettings } from "./settings-BVnzGFL7.mjs";
 import { t as formatComments } from "./comment-format-B5AcGcR-.mjs";
 import { n as formatPlanReview, r as sectionTitleForLine, t as extractPlanLines } from "./plan-format-BQyx--mp.mjs";
-import { C as resolvedFromSession, E as updatePrReviewComment, T as submitReview, a as detectCwdRepo, i as deletePrReviewComment, l as fetchExistingCommentsViaGh, t as buildPrSession, u as fetchExistingReviewsViaGh, w as setPrReviewThreadResolved, x as refreshPrSession, y as parsePrRef } from "./github-C27GDU9I.mjs";
+import { D as updatePrReviewComment, E as submitReview, S as refreshPrSession, T as setPrReviewThreadResolved, a as detectCwdRepo, b as parsePrRef, f as fetchPrFileContentViaGh, i as deletePrReviewComment, l as fetchExistingCommentsViaGh, t as buildPrSession, u as fetchExistingReviewsViaGh, w as resolvedFromSession } from "./github-CzxbZnhh.mjs";
 import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { dirname, extname, join, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, watch } from "node:fs";
@@ -250,10 +251,10 @@ Subcommands:
   progress --message … Live agent progress toast
   url                  Print the active review base URL
   plan <submit|await|list|show|versions|reply|resolve>
-  gh <status|pr-fetch|pr-list-comments|pr-review>
+  gh <status|overview|threads|reviews|pr-fetch|pr-list-comments|pr-review>
   mcp [--repo PATH]    Stdio MCP server for agents
   inspect <summary|files|hunks|slice|search>
-                       Bounded reads from a running TUI session
+                       Bounded reads from a running web, TUI, or PR session
   doctor               Environment self-check
   completion <bash|zsh|fish>
   update               Check for a newer npm release
@@ -1977,6 +1978,744 @@ var FilePrSessionStore = class {
 	}
 };
 //#endregion
+//#region src/lib/agent-diff-index.ts
+/**
+* In-process unified-diff index for token-efficient agent inspection.
+*
+* Mirrors the TUI Agent API response shapes (`/api/diff/summary|files|hunks|slice|search`)
+* so web and gh-pr sessions can share the same inspect CLI / MCP tools without
+* embedding the Rust sparse spool. Suitable for patches already held in memory
+* (PR sessions, web `git diff` results).
+*/
+const MAX_PAGE_LINES = 1e3;
+const DEFAULT_SLICE_LINES = 120;
+const DEFAULT_MAX_BYTES = 256 * 1024;
+const MAX_BODY_BYTES = 4 * 1024 * 1024;
+let nextGeneration = 1;
+function createEmptyIndex(generation = nextGeneration++) {
+	return {
+		generation,
+		complete: true,
+		files: [],
+		totalRows: 0,
+		totalHunks: 0,
+		additions: 0,
+		deletions: 0,
+		patchBytes: 0
+	};
+}
+/**
+* Parse a unified multi-file patch into an agent-facing index.
+* Generation is assigned automatically unless provided (for cache control).
+*/
+function buildAgentDiffIndex(patch, generation = nextGeneration++) {
+	const patchBytes = Buffer.byteLength(patch, "utf8");
+	if (!patch.trim()) return {
+		...createEmptyIndex(generation),
+		patchBytes
+	};
+	const lines = patch.split(/\r?\n/);
+	const files = [];
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		const gitHeader = parseGitFileHeader(line);
+		if (!gitHeader) {
+			i++;
+			continue;
+		}
+		const [oldPathRaw, newPathRaw] = gitHeader;
+		let oldPath = oldPathRaw === "/dev/null" ? null : oldPathRaw;
+		let newPath = newPathRaw === "/dev/null" ? null : newPathRaw;
+		let isBinary = false;
+		let kind = "modified";
+		i++;
+		while (i < lines.length) {
+			const h = lines[i];
+			if (h.startsWith("diff --git ")) break;
+			if (h.startsWith("@@ ")) break;
+			if (h.startsWith("Binary files ") || h.startsWith("GIT binary patch")) isBinary = true;
+			if (h.startsWith("new file mode")) kind = "added";
+			else if (h.startsWith("deleted file mode")) kind = "deleted";
+			else if (h.startsWith("rename from ")) {
+				kind = "renamed";
+				oldPath = decodeGitPath(h.slice(12));
+			} else if (h.startsWith("rename to ")) {
+				kind = "renamed";
+				newPath = decodeGitPath(h.slice(10));
+			} else if (h.startsWith("--- ")) {
+				const p = decodeGitPath(h.slice(4));
+				oldPath = p === "/dev/null" ? null : stripSidePrefix(p, "a/");
+			} else if (h.startsWith("+++ ")) {
+				const p = decodeGitPath(h.slice(4));
+				newPath = p === "/dev/null" ? null : stripSidePrefix(p, "b/");
+			}
+			i++;
+		}
+		if (isBinary) kind = "binary";
+		else if (!oldPath && newPath) kind = "added";
+		else if (oldPath && !newPath) kind = "deleted";
+		const displayPath = newPath ?? oldPath ?? "";
+		const rows = [];
+		const hunks = [];
+		let additions = 0;
+		let deletions = 0;
+		const fileIndex = files.length;
+		rows.push({
+			type: "fileHeader",
+			fileIndex,
+			path: displayPath,
+			kind,
+			binary: isBinary
+		});
+		if (!isBinary) while (i < lines.length) {
+			const h = lines[i];
+			if (h.startsWith("diff --git ")) break;
+			const hunkMatch = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/.exec(h);
+			if (!hunkMatch) {
+				i++;
+				continue;
+			}
+			const oldStart = Number(hunkMatch[1]);
+			const oldLines = hunkMatch[2] != null ? Number(hunkMatch[2]) : 1;
+			const newStart = Number(hunkMatch[3]);
+			const newLines = hunkMatch[4] != null ? Number(hunkMatch[4]) : 1;
+			const heading = (hunkMatch[5] ?? "").replace(/^\s/, "");
+			const hunkIndex = hunks.length;
+			const rowStart = rows.length;
+			rows.push({
+				type: "hunkHeader",
+				hunkIndex,
+				oldStart,
+				oldLines,
+				newStart,
+				newLines,
+				heading
+			});
+			i++;
+			let oldLineno = oldStart;
+			let newLineno = newStart;
+			let bodyCount = 0;
+			while (i < lines.length) {
+				const body = lines[i];
+				if (body.startsWith("diff --git ") || body.startsWith("@@ ")) break;
+				if (body.startsWith("\")) {
+					rows.push({
+						type: "noNewline",
+						hunkIndex
+					});
+					bodyCount++;
+					i++;
+					continue;
+				}
+				if (body === "" && i === lines.length - 1) {
+					i++;
+					break;
+				}
+				const prefix = body[0];
+				if (prefix === "+") {
+					rows.push({
+						type: "line",
+						hunkIndex,
+						kind: "add",
+						oldLineno: null,
+						newLineno,
+						content: body.slice(1)
+					});
+					newLineno++;
+					additions++;
+					bodyCount++;
+					i++;
+					continue;
+				}
+				if (prefix === "-") {
+					rows.push({
+						type: "line",
+						hunkIndex,
+						kind: "del",
+						oldLineno,
+						newLineno: null,
+						content: body.slice(1)
+					});
+					oldLineno++;
+					deletions++;
+					bodyCount++;
+					i++;
+					continue;
+				}
+				if (prefix === " " || body === "") {
+					const content = prefix === " " ? body.slice(1) : body;
+					rows.push({
+						type: "line",
+						hunkIndex,
+						kind: "context",
+						oldLineno,
+						newLineno,
+						content
+					});
+					oldLineno++;
+					newLineno++;
+					bodyCount++;
+					i++;
+					continue;
+				}
+				break;
+			}
+			hunks.push({
+				oldStart,
+				oldLines,
+				newStart,
+				newLines,
+				heading,
+				rowStart,
+				lineCount: bodyCount
+			});
+		}
+		else while (i < lines.length && !lines[i].startsWith("diff --git ")) i++;
+		files.push({
+			oldPath,
+			newPath,
+			kind,
+			isBinary,
+			hunks,
+			rowCount: rows.length,
+			additions,
+			deletions,
+			rows
+		});
+	}
+	let totalRows = 0;
+	let totalHunks = 0;
+	let totalAdd = 0;
+	let totalDel = 0;
+	for (const f of files) {
+		totalRows += f.rowCount;
+		totalHunks += f.hunks.length;
+		totalAdd += f.additions;
+		totalDel += f.deletions;
+	}
+	return {
+		generation,
+		complete: true,
+		files,
+		totalRows,
+		totalHunks,
+		additions: totalAdd,
+		deletions: totalDel,
+		patchBytes
+	};
+}
+function indexSummary(index) {
+	const changes = {};
+	for (const file of index.files) changes[file.kind] = (changes[file.kind] ?? 0) + 1;
+	return {
+		generation: index.generation,
+		complete: index.complete,
+		files: index.files.length,
+		hunks: index.totalHunks,
+		rows: index.totalRows,
+		additions: index.additions,
+		deletions: index.deletions,
+		patchBytes: index.patchBytes,
+		changes,
+		next: [
+			"diff_files",
+			"diff_search",
+			"diff_slice"
+		]
+	};
+}
+function indexFiles(index, cursor = 0, limit = 100) {
+	const safeLimit = clamp(limit, 1, MAX_PAGE_LINES);
+	const start = Math.max(0, cursor);
+	const end = Math.min(index.files.length, start + safeLimit);
+	const files = index.files.slice(start, end).map((file, offset) => ({
+		index: start + offset,
+		path: file.newPath ?? file.oldPath ?? "",
+		oldPath: file.oldPath,
+		newPath: file.newPath,
+		kind: file.kind,
+		binary: file.isBinary,
+		hunks: file.hunks.length,
+		rows: file.rowCount,
+		additions: file.additions,
+		deletions: file.deletions
+	}));
+	return {
+		generation: index.generation,
+		returned: files.length,
+		total: index.files.length,
+		nextCursor: end < index.files.length ? end : null,
+		files
+	};
+}
+function indexHunks(index, fileIndex, cursor = 0, limit = 100, generation) {
+	if (generation !== void 0 && generation !== index.generation) return {
+		error: `stale generation ${generation}; current generation is ${index.generation}`,
+		status: 409
+	};
+	const file = index.files[fileIndex];
+	if (!file) return {
+		error: "file index not found",
+		status: 404
+	};
+	const safeLimit = clamp(limit, 1, MAX_PAGE_LINES);
+	const start = Math.min(Math.max(0, cursor), file.hunks.length);
+	const end = Math.min(file.hunks.length, start + safeLimit);
+	return {
+		generation: index.generation,
+		file: fileIndex,
+		path: file.newPath ?? file.oldPath ?? "",
+		returned: end - start,
+		total: file.hunks.length,
+		nextCursor: end < file.hunks.length ? end : null,
+		hunks: file.hunks.slice(start, end)
+	};
+}
+function indexSlice(index, fileIndex, startRow = 0, maxLines = DEFAULT_SLICE_LINES, maxBytes = DEFAULT_MAX_BYTES, generation) {
+	if (generation !== void 0 && generation !== index.generation) return {
+		error: `stale generation ${generation}; current generation is ${index.generation}`,
+		status: 409
+	};
+	const file = index.files[fileIndex];
+	if (!file) return {
+		generation: index.generation,
+		fileIndex,
+		startRow,
+		nextRow: null,
+		totalRows: 0,
+		truncated: false,
+		estimatedBytes: 0,
+		rows: []
+	};
+	const lineBudget = clamp(maxLines, 1, MAX_PAGE_LINES);
+	const byteBudget = clamp(maxBytes, 1, MAX_BODY_BYTES);
+	const start = Math.min(Math.max(0, startRow), file.rowCount);
+	const rows = [];
+	let estimatedBytes = 0;
+	let truncated = false;
+	let cursor = start;
+	while (cursor < file.rowCount && rows.length < lineBudget) {
+		const row = file.rows[cursor];
+		const cost = viewRowCost(row);
+		if (estimatedBytes + cost > byteBudget && rows.length > 0) {
+			truncated = true;
+			break;
+		}
+		rows.push(row);
+		estimatedBytes += cost;
+		cursor++;
+	}
+	if (cursor < file.rowCount && rows.length >= lineBudget) truncated = true;
+	return {
+		generation: index.generation,
+		fileIndex,
+		startRow: start,
+		nextRow: cursor < file.rowCount ? cursor : null,
+		totalRows: file.rowCount,
+		truncated,
+		estimatedBytes,
+		rows
+	};
+}
+function indexSearch(index, query, fileStart = 0, rowStart = 0, limit = 100, maxBytes = DEFAULT_MAX_BYTES, generation) {
+	if (generation !== void 0 && generation !== index.generation) return {
+		error: `stale generation ${generation}; current generation is ${index.generation}`,
+		status: 409
+	};
+	const q = query.toLowerCase();
+	if (!q) return {
+		generation: index.generation,
+		hits: [],
+		nextFile: null,
+		nextRow: null,
+		truncated: false,
+		estimatedBytes: 0
+	};
+	const hitLimit = clamp(limit, 1, MAX_PAGE_LINES);
+	const byteBudget = clamp(maxBytes, 1, MAX_BODY_BYTES);
+	const hits = [];
+	let estimatedBytes = 0;
+	let truncated = false;
+	let nextFile = null;
+	let nextRow = null;
+	outer: for (let fi = Math.max(0, fileStart); fi < index.files.length; fi++) {
+		const file = index.files[fi];
+		const path = file.newPath ?? file.oldPath ?? "";
+		const pathMatch = path.toLowerCase().includes(q);
+		const rowBegin = fi === fileStart ? Math.max(0, rowStart) : 0;
+		for (let ri = rowBegin; ri < file.rows.length; ri++) {
+			const row = file.rows[ri];
+			let preview = "";
+			let oldLineno = null;
+			let newLineno = null;
+			let matched = false;
+			if (row.type === "fileHeader") {
+				if (pathMatch && ri === 0) {
+					preview = path;
+					matched = true;
+				}
+			} else if (row.type === "hunkHeader") {
+				const text = `@@ -${row.oldStart},${row.oldLines} +${row.newStart},${row.newLines} @@ ${row.heading}`;
+				if (text.toLowerCase().includes(q)) {
+					preview = text;
+					matched = true;
+				}
+			} else if (row.type === "line") {
+				if (row.content.toLowerCase().includes(q)) {
+					preview = row.content;
+					oldLineno = row.oldLineno;
+					newLineno = row.newLineno;
+					matched = true;
+				}
+			}
+			if (!matched) continue;
+			const cost = preview.length + path.length + 32;
+			if (estimatedBytes + cost > byteBudget && hits.length > 0) {
+				truncated = true;
+				nextFile = fi;
+				nextRow = ri;
+				break outer;
+			}
+			hits.push({
+				fileIndex: fi,
+				path,
+				row: ri,
+				oldLineno,
+				newLineno,
+				preview: preview.slice(0, 400)
+			});
+			estimatedBytes += cost;
+			if (hits.length >= hitLimit) {
+				const nr = ri + 1;
+				if (nr < file.rows.length) {
+					nextFile = fi;
+					nextRow = nr;
+				} else if (fi + 1 < index.files.length) {
+					nextFile = fi + 1;
+					nextRow = 0;
+				}
+				truncated = nextFile != null;
+				break outer;
+			}
+		}
+	}
+	return {
+		generation: index.generation,
+		hits,
+		nextFile,
+		nextRow,
+		truncated,
+		estimatedBytes
+	};
+}
+function viewRowCost(row) {
+	switch (row.type) {
+		case "fileHeader": return row.path.length + 32;
+		case "hunkHeader": return row.heading.length + 48;
+		case "line": return row.content.length + 16;
+		case "noNewline": return 24;
+	}
+}
+function clamp(n, min, max) {
+	if (!Number.isFinite(n)) return min;
+	return Math.min(max, Math.max(min, Math.trunc(n)));
+}
+/** Parse Git's file header, including core.quotePath-style C-quoted paths. */
+function parseGitFileHeader(line) {
+	if (!line.startsWith("diff --git ")) return null;
+	const rest = line.slice(11);
+	if (rest.startsWith("\"")) {
+		const first = consumeGitToken(rest, 0);
+		if (!first) return null;
+		let cursor = first.next;
+		while (cursor < rest.length && /\s/.test(rest[cursor])) cursor++;
+		const second = consumeGitToken(rest, cursor);
+		if (!second) return null;
+		return [stripSidePrefix(decodeGitPath(first.token), "a/"), stripSidePrefix(decodeGitPath(second.token), "b/")];
+	}
+	const separator = rest.lastIndexOf(" b/");
+	if (separator < 0) return null;
+	return [stripSidePrefix(rest.slice(0, separator), "a/"), stripSidePrefix(rest.slice(separator + 1), "b/")];
+}
+function consumeGitToken(input, start) {
+	if (input[start] !== "\"") {
+		const end = input.indexOf(" ", start);
+		return {
+			token: input.slice(start, end < 0 ? input.length : end),
+			next: end < 0 ? input.length : end
+		};
+	}
+	let escaped = false;
+	for (let i = start + 1; i < input.length; i++) {
+		const char = input[i];
+		if (!escaped && char === "\"") return {
+			token: input.slice(start, i + 1),
+			next: i + 1
+		};
+		if (!escaped && char === "\\") escaped = true;
+		else escaped = false;
+	}
+	return null;
+}
+function stripSidePrefix(path, prefix) {
+	return path.startsWith(prefix) ? path.slice(prefix.length) : path;
+}
+/** Decode the byte escapes emitted by Git for quoted pathnames. */
+function decodeGitPath(raw) {
+	const input = raw.trim();
+	if (!(input.startsWith("\"") && input.endsWith("\""))) return input;
+	const bytes = [];
+	const pushText = (value) => bytes.push(...Buffer.from(value, "utf8"));
+	for (let i = 1; i < input.length - 1; i++) {
+		if (input[i] !== "\\") {
+			const codePoint = input.codePointAt(i);
+			pushText(String.fromCodePoint(codePoint));
+			if (codePoint > 65535) i++;
+			continue;
+		}
+		const escaped = input[++i];
+		if (escaped == null) break;
+		const simple = {
+			a: 7,
+			b: 8,
+			t: 9,
+			n: 10,
+			v: 11,
+			f: 12,
+			r: 13,
+			"\"": 34,
+			"\\": 92
+		};
+		if (escaped in simple) {
+			bytes.push(simple[escaped]);
+			continue;
+		}
+		if (/[0-7]/.test(escaped)) {
+			let octal = escaped;
+			while (octal.length < 3 && i + 1 < input.length - 1 && /[0-7]/.test(input[i + 1])) octal += input[++i];
+			bytes.push(Number.parseInt(octal, 8));
+			continue;
+		}
+		pushText(escaped);
+	}
+	return Buffer.from(bytes).toString("utf8");
+}
+/** Cache helper: rebuild only when patch fingerprint changes. */
+var AgentDiffIndexCache = class {
+	index = null;
+	fingerprint = null;
+	getOrBuild(patch) {
+		const fp = createHash("sha256").update(patch).digest("base64url");
+		if (this.index && this.fingerprint === fp) return this.index;
+		this.index = buildAgentDiffIndex(patch);
+		this.fingerprint = fp;
+		return this.index;
+	}
+	clear() {
+		this.index = null;
+		this.fingerprint = null;
+	}
+};
+//#endregion
+//#region src/lib/pr-agent-format.ts
+function buildPrOverviewPayload(session) {
+	const threads = session.existingComments ?? [];
+	const reviews = session.existingReviews ?? [];
+	const drafts = session.comments ?? [];
+	let unresolved = 0;
+	let resolved = 0;
+	let outdated = 0;
+	for (const t of threads) {
+		if (t.isOutdated) outdated++;
+		if (t.isResolved) resolved++;
+		else unresolved++;
+	}
+	return {
+		prMode: true,
+		ref: session.ref,
+		owner: session.owner,
+		repo: session.repo,
+		pullNumber: session.pullNumber,
+		title: session.title,
+		url: session.url,
+		author: session.author,
+		baseSha: session.baseSha,
+		headSha: session.headSha,
+		additions: session.additions,
+		deletions: session.deletions,
+		changedFiles: session.changedFiles,
+		host: session.host,
+		counts: {
+			publishedThreads: threads.length,
+			unresolvedThreads: unresolved,
+			resolvedThreads: resolved,
+			outdatedThreads: outdated,
+			reviews: reviews.length,
+			localDrafts: drafts.length,
+			openDrafts: drafts.filter((d) => d.status === "open").length
+		},
+		submittedAt: session.submittedAt ?? null,
+		submittedReviewId: session.submittedReviewId ?? null,
+		submittedReviewUrl: session.submittedReviewUrl ?? null,
+		authSource: session.authSource,
+		patchBytes: Buffer.byteLength(session.diff ?? "", "utf8")
+	};
+}
+function truncateBody(body, maxChars, fullBody) {
+	if (fullBody || maxChars == null) return {
+		text: body,
+		truncated: false
+	};
+	const limit = Math.max(0, maxChars);
+	if (body.length <= limit) return {
+		text: body,
+		truncated: false
+	};
+	return {
+		text: body.slice(0, limit) + "…",
+		truncated: true
+	};
+}
+function paginatePrThreads(session, opts = {}) {
+	const cursor = Math.max(0, opts.cursor ?? 0);
+	const limit = Math.min(200, Math.max(1, opts.limit ?? 50));
+	const bodyMax = Math.min(5e4, Math.max(0, opts.bodyMaxChars ?? 500));
+	const pathFilter = opts.path?.toLowerCase();
+	const authorFilter = opts.author?.toLowerCase();
+	let filtered = session.existingComments ?? [];
+	if (opts.unresolvedOnly) filtered = filtered.filter((t) => !t.isResolved);
+	if (pathFilter) filtered = filtered.filter((t) => (t.path ?? "").toLowerCase().includes(pathFilter));
+	if (authorFilter) filtered = filtered.filter((t) => (t.author?.login ?? "").toLowerCase() === authorFilter);
+	const total = filtered.length;
+	const slice = filtered.slice(cursor, cursor + limit);
+	const threads = slice.map((t) => {
+		const root = truncateBody(t.body ?? "", bodyMax, opts.fullBody);
+		const replies = (t.replies ?? []).map((r) => {
+			const rb = truncateBody(r.body ?? "", bodyMax, opts.fullBody);
+			return {
+				id: r.id,
+				author: r.author?.login ?? null,
+				body: rb.text,
+				bodyTruncated: rb.truncated,
+				createdAt: r.createdAt
+			};
+		});
+		return {
+			id: t.id,
+			threadId: t.threadId,
+			path: t.path,
+			line: t.line,
+			startLine: t.startLine,
+			side: t.side,
+			startSide: t.startSide,
+			author: t.author?.login ?? null,
+			resolved: Boolean(t.isResolved),
+			outdated: Boolean(t.isOutdated),
+			state: t.state,
+			createdAt: t.createdAt,
+			updatedAt: t.updatedAt,
+			body: root.text,
+			bodyTruncated: root.truncated,
+			replyCount: replies.length,
+			replies
+		};
+	});
+	const end = cursor + slice.length;
+	return {
+		returned: threads.length,
+		total,
+		nextCursor: end < total ? end : null,
+		threads
+	};
+}
+function paginatePrReviews(session, opts = {}) {
+	const cursor = Math.max(0, opts.cursor ?? 0);
+	const limit = Math.min(100, Math.max(1, opts.limit ?? 50));
+	const bodyMax = Math.min(5e4, Math.max(0, opts.bodyMaxChars ?? 500));
+	let reviews = session.existingReviews ?? [];
+	if (opts.state) {
+		const s = opts.state.toUpperCase();
+		reviews = reviews.filter((r) => r.state === s);
+	}
+	const total = reviews.length;
+	const slice = reviews.slice(cursor, cursor + limit);
+	const mapped = slice.map((r) => {
+		const b = truncateBody(r.body ?? "", bodyMax, opts.fullBody);
+		return {
+			id: r.id,
+			author: r.author?.login ?? null,
+			state: r.state,
+			submittedAt: r.submittedAt,
+			htmlUrl: r.htmlUrl,
+			commitId: r.commitId,
+			body: b.text,
+			bodyTruncated: b.truncated
+		};
+	});
+	const end = cursor + slice.length;
+	return {
+		returned: mapped.length,
+		total,
+		nextCursor: end < total ? end : null,
+		reviews: mapped
+	};
+}
+function escapeAttr(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function cdata(value) {
+	return value.replace(/]]>/g, "]]]]><![CDATA[>");
+}
+/**
+* Compact agent XML for published GitHub review threads (+ optional reviews).
+*/
+function formatPrReviewThreads(session, threads, reviews, page) {
+	const prLabel = `${session.owner}/${session.repo}#${session.pullNumber}`;
+	const lines = [];
+	const pageAttrs = page ? ` returned="${page.returned}" total="${page.total}"${page.nextCursor == null ? "" : ` nextCursor="${page.nextCursor}"`}` : "";
+	lines.push(`<pr-review-threads pr="${escapeAttr(prLabel)}" headSha="${escapeAttr(session.headSha)}" url="${escapeAttr(session.url)}"${pageAttrs}>`);
+	lines.push("  <instructions>");
+	lines.push("    Published GitHub review threads for this pull request (not local drafts).");
+	lines.push("    Prefer addressing feedback via a local checkout + plan/implement cycle unless the user authorized live GitHub replies.");
+	lines.push("    Only treat unresolved threads as actionable. resolved=\"true\" threads are historical.");
+	lines.push("  </instructions>");
+	for (const t of threads) {
+		const lineAttr = t.startLine != null && t.line != null && t.startLine !== t.line ? ` line="${t.startLine}-${t.line}"` : t.line != null ? ` line="${t.line}"` : "";
+		const sideAttr = t.side ? ` side="${t.side}"` : "";
+		const pathAttr = t.path ? ` path="${escapeAttr(t.path)}"` : "";
+		const authorAttr = t.author ? ` author="${escapeAttr(t.author)}"` : "";
+		const threadIdAttr = t.threadId ? ` threadId="${escapeAttr(t.threadId)}"` : "";
+		const stateAttr = t.state ? ` state="${t.state}"` : "";
+		lines.push(`  <thread id="${t.id}"${threadIdAttr}${pathAttr}${sideAttr}${lineAttr}${stateAttr} resolved="${t.resolved}" outdated="${t.outdated}" replyCount="${t.replyCount}"${authorAttr}>`);
+		lines.push(`    <body${t.bodyTruncated ? " truncated=\"true\"" : ""}><![CDATA[${cdata(t.body)}]]></body>`);
+		if (t.replies.length > 0) {
+			lines.push("    <replies>");
+			for (const r of t.replies) {
+				const ra = r.author ? ` author="${escapeAttr(r.author)}"` : "";
+				lines.push(`      <reply id="${r.id}"${ra}${r.bodyTruncated ? " truncated=\"true\"" : ""}><![CDATA[${cdata(r.body)}]]></reply>`);
+			}
+			lines.push("    </replies>");
+		}
+		lines.push("  </thread>");
+	}
+	if (reviews && reviews.length > 0) {
+		lines.push("  <reviews>");
+		for (const r of reviews) {
+			const ra = r.author ? ` author="${escapeAttr(r.author)}"` : "";
+			lines.push(`    <review id="${r.id}" state="${r.state}"${ra}${r.submittedAt ? ` submittedAt="${escapeAttr(r.submittedAt)}"` : ""}>`);
+			if (r.body) lines.push(`      <body${r.bodyTruncated ? " truncated=\"true\"" : ""}><![CDATA[${cdata(r.body)}]]></body>`);
+			lines.push("    </review>");
+		}
+		lines.push("  </reviews>");
+	}
+	lines.push("</pr-review-threads>");
+	return lines.join("\n");
+}
+function formatPrReviews(session, reviews, page) {
+	return formatPrReviewThreads(session, [], reviews, page);
+}
+//#endregion
 //#region src/server.ts
 const MIME_TYPES = {
 	".html": "text/html",
@@ -1993,6 +2732,20 @@ const MIME_TYPES = {
 	".bmp": "image/bmp",
 	".avif": "image/avif"
 };
+const MAX_AVATAR_BYTES = 5 * 1024 * 1024;
+function collectPrAvatarUrls(session) {
+	const urls = /* @__PURE__ */ new Set();
+	const add = (avatarUrl) => {
+		if (avatarUrl) urls.add(avatarUrl);
+	};
+	add(session.author?.avatarUrl);
+	for (const review of session.existingReviews ?? []) add(review.author?.avatarUrl);
+	for (const comment of session.existingComments) {
+		add(comment.author?.avatarUrl);
+		for (const reply of comment.replies) add(reply.author?.avatarUrl);
+	}
+	return urls;
+}
 function isCustomMode(opts) {
 	return opts.revisions.length > 0 || opts.pathspecs.length > 0 || opts.showMode;
 }
@@ -2003,6 +2756,7 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 	const store = commentStore ?? new FileCommentStore();
 	const plans = planStore ?? new FilePlanStore();
 	const prStore = prSessionStore ?? new FilePrSessionStore();
+	const agentDiffCache = new AgentDiffIndexCache();
 	const uiStateStore = new FileUiStateStore();
 	const viewedFiles = /* @__PURE__ */ new Set();
 	/** Agent-reported progress events for the human UI (SSE `agent-progress`). */
@@ -2167,20 +2921,105 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 			overview: result.overview
 		});
 	});
-	app.get("/api/file-content", (c) => {
+	async function resolveAgentPatch() {
+		if (prMode) return (await prStore.get())?.diff ?? "";
+		const stagedQuery = void 0;
+		const untrackedQuery = void 0;
+		const staged = stagedQuery === void 0 ? diffOpts.staged : false;
+		const untracked = untrackedQuery === void 0 ? diffOpts.includeUntracked : false;
+		return (await executeDiffWithMeta(customMode ? diffOpts : {
+			...diffOpts,
+			staged,
+			includeUntracked: untracked
+		})).patch ?? "";
+	}
+	function parseUInt(value, fallback) {
+		if (value == null || value === "") return fallback;
+		const n = Number(value);
+		return Number.isFinite(n) && n >= 0 ? Math.trunc(n) : fallback;
+	}
+	app.get("/api/diff/summary", async (c) => {
+		const patch = await resolveAgentPatch();
+		const summary = indexSummary(agentDiffCache.getOrBuild(patch));
+		if (!prMode) return c.json(summary);
+		const session = await prStore.get();
+		if (!session) return c.json(summary);
+		return c.json({
+			...summary,
+			prMode: true,
+			owner: session.owner,
+			repo: session.repo,
+			pullNumber: session.pullNumber,
+			title: session.title,
+			url: session.url,
+			baseSha: session.baseSha,
+			headSha: session.headSha
+		});
+	});
+	app.get("/api/diff/files", async (c) => {
+		const patch = await resolveAgentPatch();
+		const index = agentDiffCache.getOrBuild(patch);
+		const cursor = parseUInt(c.req.query("cursor"), 0);
+		const limit = parseUInt(c.req.query("limit"), 100);
+		return c.json(indexFiles(index, cursor, limit));
+	});
+	app.get("/api/diff/hunks", async (c) => {
+		const patch = await resolveAgentPatch();
+		const index = agentDiffCache.getOrBuild(patch);
+		const file = parseUInt(c.req.query("file"), 0);
+		const cursor = parseUInt(c.req.query("cursor"), 0);
+		const limit = parseUInt(c.req.query("limit"), 100);
+		const generationRaw = c.req.query("generation");
+		const result = indexHunks(index, file, cursor, limit, generationRaw != null && generationRaw !== "" ? parseUInt(generationRaw, 0) : void 0);
+		if ("status" in result) return c.json({ error: result.error }, result.status);
+		return c.json(result);
+	});
+	app.get("/api/diff/slice", async (c) => {
+		const patch = await resolveAgentPatch();
+		const index = agentDiffCache.getOrBuild(patch);
+		const file = parseUInt(c.req.query("file"), 0);
+		const start = parseUInt(c.req.query("start"), 0);
+		const maxLines = parseUInt(c.req.query("maxLines"), 120);
+		const maxBytes = parseUInt(c.req.query("maxBytes"), 256 * 1024);
+		const generationRaw = c.req.query("generation");
+		const result = indexSlice(index, file, start, maxLines, maxBytes, generationRaw != null && generationRaw !== "" ? parseUInt(generationRaw, 0) : void 0);
+		if ("status" in result) return c.json({ error: result.error }, result.status);
+		return c.json(result);
+	});
+	app.get("/api/diff/search", async (c) => {
+		const patch = await resolveAgentPatch();
+		const index = agentDiffCache.getOrBuild(patch);
+		const q = c.req.query("q") ?? "";
+		const file = parseUInt(c.req.query("file"), 0);
+		const row = parseUInt(c.req.query("row"), 0);
+		const limit = parseUInt(c.req.query("limit"), 100);
+		const maxBytes = parseUInt(c.req.query("maxBytes"), 256 * 1024);
+		const generationRaw = c.req.query("generation");
+		const result = indexSearch(index, q, file, row, limit, maxBytes, generationRaw != null && generationRaw !== "" ? parseUInt(generationRaw, 0) : void 0);
+		if ("status" in result) return c.json({ error: result.error }, result.status);
+		return c.json(result);
+	});
+	const resolveFileVersion = async (path, version) => {
+		if (!prMode) return getFileContent(path, version);
+		const session = await prStore.get();
+		if (!session) return null;
+		const sha = version === "old" ? session.baseSha : session.headSha;
+		return fetchPrFileContentViaGh(resolvedFromSession(session), path, sha);
+	};
+	app.get("/api/file-content", async (c) => {
 		const path = c.req.query("path");
 		const version = c.req.query("version");
 		if (!path || !version) return c.json({ error: "Missing path or version" }, 400);
-		const content = getFileContent(path, version);
+		const content = await resolveFileVersion(path, version);
 		if (!content) return c.json({ error: "File not found" }, 404);
 		const contentType = MIME_TYPES[extname(path)] || "application/octet-stream";
 		return new Response(new Uint8Array(content), { headers: { "Content-Type": contentType } });
 	});
-	app.get("/api/file-text", (c) => {
+	app.get("/api/file-text", async (c) => {
 		const path = c.req.query("path");
 		const version = c.req.query("version");
 		if (!path || !version) return c.json({ error: "Missing path or version" }, 400);
-		const buffer = getFileContent(path, version);
+		const buffer = await resolveFileVersion(path, version);
 		if (!buffer) return c.json({
 			content: "",
 			missing: true
@@ -2615,6 +3454,91 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 			authSource: session.authSource
 		});
 	});
+	/**
+	* Serve GitHub avatars from this origin. Privacy extensions commonly block
+	* embedded githubusercontent.com requests even though the same URL works as
+	* a top-level navigation. Only URLs already supplied by the active GitHub
+	* session are accepted, which keeps this endpoint from becoming an SSRF
+	* proxy.
+	*/
+	app.get("/api/gh/avatar", async (c) => {
+		if (!prMode) return notInPrMode(c);
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const url = c.req.query("url");
+		if (!url || !collectPrAvatarUrls(session).has(url)) return c.json({ error: "Avatar URL is not part of this PR session" }, 403);
+		let parsed;
+		try {
+			parsed = new URL(url);
+		} catch {
+			return c.json({ error: "Invalid avatar URL" }, 400);
+		}
+		if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return c.json({ error: "Invalid avatar URL protocol" }, 400);
+		try {
+			const response = await fetch(parsed, { redirect: "error" });
+			if (!response.ok) return c.json({ error: `Avatar request failed with HTTP ${response.status}` }, 502);
+			const contentType = response.headers.get("content-type")?.split(";")[0]?.trim() ?? "";
+			if (!contentType.startsWith("image/")) return c.json({ error: "Avatar response was not an image" }, 502);
+			if (Number(response.headers.get("content-length") ?? "0") > MAX_AVATAR_BYTES) return c.json({ error: "Avatar is too large" }, 413);
+			const bytes = new Uint8Array(await response.arrayBuffer());
+			if (bytes.byteLength > MAX_AVATAR_BYTES) return c.json({ error: "Avatar is too large" }, 413);
+			return new Response(bytes, { headers: {
+				"Content-Type": contentType,
+				"Cache-Control": "private, max-age=3600",
+				"X-Content-Type-Options": "nosniff"
+			} });
+		} catch (error) {
+			return c.json({ error: error?.message ?? "Failed to load avatar" }, 502);
+		}
+	});
+	/** Slim PR metadata for agents — no threads, reviews, or patch. */
+	app.get("/api/gh/overview", async (c) => {
+		if (!prMode) return notInPrMode(c);
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		return c.json(buildPrOverviewPayload(session));
+	});
+	/**
+	* Paged published review threads. Prefer this over /api/gh/session for agents.
+	* Query: unresolvedOnly, path, author, cursor, limit, bodyMaxChars, fullBody, format=xml|json
+	*/
+	app.get("/api/gh/threads", async (c) => {
+		if (!prMode) return notInPrMode(c);
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const page = paginatePrThreads(session, {
+			unresolvedOnly: c.req.query("unresolvedOnly") === "true" || c.req.query("unresolved") === "1",
+			path: c.req.query("path") ?? void 0,
+			author: c.req.query("author") ?? void 0,
+			cursor: parseUInt(c.req.query("cursor"), 0),
+			limit: parseUInt(c.req.query("limit"), 50),
+			bodyMaxChars: parseUInt(c.req.query("bodyMaxChars"), 500),
+			fullBody: c.req.query("fullBody") === "true" || c.req.query("fullBody") === "1"
+		});
+		if ((c.req.query("format") ?? "json").toLowerCase() === "xml") {
+			c.header("Content-Type", "application/xml; charset=utf-8");
+			return c.body(formatPrReviewThreads(session, page.threads, void 0, page));
+		}
+		return c.json(page);
+	});
+	/** Paged submitted review verdicts / overall comments. */
+	app.get("/api/gh/reviews", async (c) => {
+		if (!prMode) return notInPrMode(c);
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const page = paginatePrReviews(session, {
+			cursor: parseUInt(c.req.query("cursor"), 0),
+			limit: parseUInt(c.req.query("limit"), 50),
+			bodyMaxChars: parseUInt(c.req.query("bodyMaxChars"), 500),
+			fullBody: c.req.query("fullBody") === "true" || c.req.query("fullBody") === "1",
+			state: c.req.query("state") ?? void 0
+		});
+		if ((c.req.query("format") ?? "json").toLowerCase() === "xml") {
+			c.header("Content-Type", "application/xml; charset=utf-8");
+			return c.body(formatPrReviews(session, page.reviews, page));
+		}
+		return c.json(page);
+	});
 	const syncExistingPrReviewData = async (session) => {
 		const resolved = resolvedFromSession(session);
 		let existingReviews = await fetchExistingReviewsViaGh(resolved);
@@ -2672,7 +3596,7 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 		const session = await prStore.get();
 		if (!session) return notInPrMode(c);
 		try {
-			const { fetchPrChecks } = await import("./github-8THGZ7Nu.mjs");
+			const { fetchPrChecks } = await import("./github-DL7-BqhD.mjs");
 			const checks = await fetchPrChecks(resolvedFromSession(session), session.headSha);
 			const summary = {
 				total: checks.length,
@@ -2704,7 +3628,7 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 		const text = typeof body.body === "string" ? body.body.trim() : "";
 		if (!text) return c.json({ error: "body is required" }, 400);
 		try {
-			const { replyToPrComment } = await import("./github-8THGZ7Nu.mjs");
+			const { replyToPrComment } = await import("./github-DL7-BqhD.mjs");
 			const result = await replyToPrComment({
 				resolved: resolvedFromSession(session),
 				inReplyTo: id,
@@ -2824,6 +3748,8 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 		const body = await c.req.json();
 		const session = await prStore.get();
 		if (!session) return notInPrMode(c);
+		const severityRaw = body.severity;
+		const severity = severityRaw === "blocking" || severityRaw === "nit" || severityRaw === "question" || severityRaw === "praise" || severityRaw === "none" ? severityRaw === "none" ? void 0 : severityRaw : void 0;
 		const comment = {
 			id: crypto.randomUUID(),
 			filePath: body.filePath,
@@ -2834,7 +3760,8 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 			body: body.body,
 			status: "open",
 			createdAt: Date.now(),
-			replies: []
+			replies: [],
+			...severity ? { severity } : {}
 		};
 		const next = {
 			...session,
@@ -2913,7 +3840,7 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 		if (decision !== "approve" && decision !== "comment" && decision !== "request-changes" && decision !== "draft") return c.json({ error: "decision must be one of: approve, comment, request-changes, draft" }, 400);
 		const generalBody = typeof body.body === "string" ? body.body : "";
 		if (body.dryRun === true) {
-			const { buildReviewPayload } = await import("./github-8THGZ7Nu.mjs");
+			const { buildReviewPayload } = await import("./github-DL7-BqhD.mjs");
 			const payload = buildReviewPayload({
 				decision,
 				body: generalBody,