@dev.fast/whiteboard 0.0.0-stage → 0.2.0

package/dist/local-data-CxLk75rx.js

@@ -0,0 +1,4491 @@
+import { _ as readFileAtCommit, b as resolveRevision, c as diffTrees, f as gitCommonDir, g as parseGitRemote, h as listTrackedFilesAtCommit, i as diff, l as diffWorkingTree, m as listCommitRange, n as createBlobBatchReader, o as diffFileSummariesTrees, p as jjRevisionIsConflicted, r as detectLocalVcs, s as diffFileSummariesWorkingTree, t as LocalVcsToolsMissingError, u as git, v as resolveRepoContext, y as resolveRepoContextSync } from "./src-CmdiBL20.js";
+import { c as jsonString, o as jsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
+import { _ as SCRATCHPAD_REVIEW_ID, b as structuralChangeCounts, g as ReviewSelectedDiffSchema, m as ReviewApiSelectionSourceSchema, y as decodeStructuralDiffEvent } from "./src-DnwdaQ2r.js";
+import { $ as unionIntervals, A as applyLensEdit, C as resourceReferences, D as summarizeEdit, E as sourceReferences, F as checkSourcePath, I as fileLineRangeSchema, K as sourceAnchors, L as requireVisibleSource, N as lensSelections, O as checkReferences, P as SourceRangeError, Q as subtractIntervals, R as sliceSourceRange, S as resourceReference, X as intersectIntervals, Y as emptyCoverage, a as defineSoftwareMap, b as pinsSchema, c as traceSchema, d as applyEdit, et as updateCoverage, f as assignFreshIds, g as explicitPins, h as elements, i as SoftwareModelValidationError, j as lensEditSchema, l as textIncludesQuote, m as editSchema, n as migrateStoredDocument, p as documentSchema, q as coverageSchema, r as migrateStoredLenses, t as liftFileLenses, u as anchorPins, v as isUnit, w as reviewTargetSchema } from "./stored-document-migration-DHeMpLMb.js";
+import { t as ReviewInputError } from "./input-error-OLgB_h31.js";
+import { D as processIsAlive, O as withFileLock, P as writePrivateJsonAtomic } from "./s3-config-CAxhO9u_.js";
+import { t as errorMessage } from "./error-message-OtiDonty.js";
+import { s as safeStorageSegment } from "./review-home-paths-6zZH-1c9.js";
+import { t as findReviewPackageRoot } from "./package-paths-B6-zxvIO.js";
+import { r as isMissingFileError } from "./fs-utils-BMPLt0cr.js";
+import { createRequire } from "node:module";
+import crypto, { createHash, randomUUID } from "node:crypto";
+import { z } from "zod";
+import { existsSync, lstatSync, readFileSync, realpathSync, rmSync, watch } from "node:fs";
+import * as fs$1 from "node:fs/promises";
+import { lstat, mkdir, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
+import path, { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import os from "node:os";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { DatabaseSync } from "node:sqlite";
+import { createInterface } from "node:readline";
+//#region ../review-protocol/src/source-alignment.ts
+/** The 0-based, half-open line span a region touches. An end at column 0 does not touch its end line. */
+function alignmentRegionLines(region) {
+	return {
+		start: region.start.line,
+		end: region.end.column === 0 ? region.end.line : region.end.line + 1
+	};
+}
+function alignmentLeaves(regions) {
+	const leaves = [];
+	const walk = (region) => {
+		if (region.kind === "leaf") leaves.push(region);
+		else for (const child of region.children) walk(child);
+	};
+	for (const region of regions ?? []) walk(region);
+	return leaves;
+}
+/** Monaco keeps a final empty line after a newline; the wire need not mention it. */
+function monacoLineCount(source) {
+	return source ? source.text.split("\n").length : 0;
+}
+/**
+* Zips the two sides' leaves by `alignment_id` into the full row table. Paired leaves
+* yield rows line for line, in the same order on both sides; an unpaired leaf
+* yields one-sided rows. Rows past the last leaf pair the trailing empty
+* lines Monaco keeps.
+*/
+function structuralRows(diff) {
+	const lhsLeaves = alignmentLeaves(diff.lhs?.regions);
+	const rhsLeaves = alignmentLeaves(diff.rhs?.regions);
+	const leftCount = monacoLineCount(diff.lhs);
+	const rightCount = monacoLineCount(diff.rhs);
+	const rows = [];
+	let left = 0, right = 0;
+	const push = (l, r) => {
+		rows.push([l, r]);
+		if (l !== null) left = l + 1;
+		if (r !== null) right = r + 1;
+	};
+	const oneSided = (leaf, side) => {
+		const lines = alignmentRegionLines(leaf);
+		for (let line = lines.start; line < lines.end; line++) push(side === 0 ? line : null, side === 1 ? line : null);
+	};
+	const rhsIndex = new Map(rhsLeaves.map((leaf, index) => [leaf.alignment_id, index]));
+	let cursor = 0;
+	for (const leaf of lhsLeaves) {
+		const partner = rhsIndex.get(leaf.alignment_id);
+		if (partner === void 0) {
+			oneSided(leaf, 0);
+			continue;
+		}
+		while (cursor < partner) oneSided(rhsLeaves[cursor++], 1);
+		const a = alignmentRegionLines(leaf);
+		const b = alignmentRegionLines(rhsLeaves[partner]);
+		for (let offset = 0; offset < a.end - a.start; offset++) push(a.start + offset, b.start + offset);
+		cursor = partner + 1;
+	}
+	while (cursor < rhsLeaves.length) oneSided(rhsLeaves[cursor++], 1);
+	while (left < leftCount || right < rightCount) rows.push([left < leftCount ? left++ : null, right < rightCount ? right++ : null]);
+	return rows;
+}
+//#endregion
+//#region src/review-checkout-paths.ts
+/**
+* Root for Review-owned checkouts. A Review UUID identifies one subtree.
+*/
+function reviewManagedCheckoutsDir(gitCommonDir) {
+	return path.join(gitCommonDir, "dev-fast", "reviews");
+}
+/** Return the checkout subtree owned by one Review UUID. */
+function reviewManagedCheckoutRoot(gitCommonDir, reviewUuid) {
+	return path.join(reviewManagedCheckoutsDir(gitCommonDir), safeStorageSegment(reviewUuid));
+}
+/** A detached checkout owned by one Review revision and source role. */
+function reviewManagedCheckoutDir(gitCommonDir, reviewUuid, role, commit) {
+	return path.join(reviewManagedCheckoutRoot(gitCommonDir, reviewUuid), role, safeStorageSegment(commit));
+}
+//#endregion
+//#region src/review-prepare.ts
+const PREPARE_LOCK_RETRY_MS = 250;
+const PREPARE_LOCK_STALE_MS = 18e5;
+const PREPARE_LOCK_TIMEOUT_MS = 1e3;
+const PREPARE_LOCK_UNOWNED_GRACE_MS = 1e3;
+const PREPARE_OUTPUT_TAIL_LINES = 20;
+/** The marker file that records a completed prepare, beside the worktree. */
+function reviewPrepareMarkerPath(checkoutPath) {
+	return `${checkoutPath}.prepared`;
+}
+/** The failure log written beside the worktree when a prepare command fails. */
+function reviewPrepareLogPath(checkoutPath) {
+	return `${checkoutPath}.prepare-log`;
+}
+function reviewPrepareCommandsHash(commands) {
+	return crypto.createHash("sha256").update(JSON.stringify(commands)).digest("hex").slice(0, 16);
+}
+async function removeReviewPrepareArtifacts(checkoutPath) {
+	await rm(reviewPrepareMarkerPath(checkoutPath), { force: true });
+	await rm(reviewPrepareLogPath(checkoutPath), { force: true });
+}
+async function prepareReviewPinnedCheckout(input) {
+	if (input.commands.length === 0) return { prepared: false };
+	const markerPath = reviewPrepareMarkerPath(input.checkoutPath);
+	const expectedHash = reviewPrepareCommandsHash(input.commands);
+	if (await markerMatches(markerPath, expectedHash)) return { prepared: true };
+	const outcome = await withFileLock(`${input.checkoutPath}.prepare-lock`, {
+		retryMs: PREPARE_LOCK_RETRY_MS,
+		staleMs: PREPARE_LOCK_STALE_MS,
+		heartbeatMs: 5e3,
+		timeoutMs: PREPARE_LOCK_TIMEOUT_MS,
+		unownedGraceMs: PREPARE_LOCK_UNOWNED_GRACE_MS
+	}, async () => {
+		if (await markerMatches(markerPath, expectedHash)) return { prepared: true };
+		await rm(markerPath, { force: true });
+		const runCommand = input.runCommand ?? (async (command, cwd) => {
+			return {
+				exitCode: 0,
+				output: await runPrepareCommand(command, cwd, input.progress ?? (() => {}), input.signal ?? new AbortController().signal, input.timeoutMs)
+			};
+		});
+		for (const command of input.commands) {
+			const result = await runCommand(command, input.checkoutPath).catch((cause) => ({
+				exitCode: null,
+				output: cause instanceof Error ? cause.message : String(cause)
+			}));
+			if (result.exitCode !== 0) {
+				const exit = result.exitCode === null ? "no exit code" : `exit ${result.exitCode}`;
+				const logNote = await writePrepareFailureLog(input.checkoutPath, result.output);
+				input.warning?.(formatPrepareFailure({
+					commit: input.commit,
+					command,
+					exit,
+					output: result.output,
+					logNote
+				}));
+				return { prepared: false };
+			}
+		}
+		await rm(reviewPrepareLogPath(input.checkoutPath), { force: true });
+		await writeFile(markerPath, JSON.stringify({
+			commandsHash: expectedHash,
+			preparedAt: Date.now()
+		}), "utf8");
+		return { prepared: true };
+	});
+	if (!outcome.acquired) {
+		input.warning?.(`devfast.prepare skipped for commit ${input.commit.slice(0, 12)}: another process holds the prepare lock. Language features use the unprepared pinned checkout.`);
+		return { prepared: false };
+	}
+	return outcome.result;
+}
+async function writePrepareFailureLog(checkoutPath, output) {
+	const trimmed = output?.trimEnd();
+	if (!trimmed) return "";
+	const logPath = reviewPrepareLogPath(checkoutPath);
+	return writeFile(logPath, `${trimmed}\n`, "utf8").then(() => ` Full output: ${logPath}.`).catch(() => "");
+}
+function formatPrepareFailure(input) {
+	const base = `devfast.prepare failed for commit ${input.commit.slice(0, 12)} (${input.exit}): ${input.command}. Language features use the unprepared pinned checkout.`;
+	const output = input.output?.trimEnd();
+	if (!output) return base;
+	const lines = output.split("\n");
+	const tail = lines.slice(-20).join("\n");
+	return `${base} Last output:\n${lines.length > PREPARE_OUTPUT_TAIL_LINES ? "…\n" : ""}${tail}${input.logNote}`;
+}
+async function markerMatches(markerPath, expectedHash) {
+	return readFile(markerPath, "utf8").then((contents) => jsonObject(parseJsonText(contents))?.commandsHash === expectedHash).catch(() => false);
+}
+function runPrepareCommand(command, cwd, progress, signal, timeoutMs = 9e5) {
+	return new Promise((resolve, reject) => {
+		signal.throwIfAborted();
+		let output = "";
+		const child = spawn(command, {
+			cwd,
+			shell: true,
+			detached: process.platform !== "win32",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let interrupted;
+		let force;
+		const kill = (signal) => {
+			try {
+				if (process.platform !== "win32" && child.pid) process.kill(-child.pid, signal);
+				else child.kill(signal);
+			} catch {}
+		};
+		const stop = (reason) => {
+			interrupted = reason;
+			kill("SIGTERM");
+			force ??= setTimeout(() => kill("SIGKILL"), 2e3);
+			force.unref();
+		};
+		const abort = () => stop(/* @__PURE__ */ new Error("Project command interrupted by shutdown."));
+		signal.addEventListener("abort", abort, { once: true });
+		const timeout = setTimeout(() => stop(/* @__PURE__ */ new Error("Project preparation timed out.")), timeoutMs);
+		timeout.unref();
+		const append = (chunk) => {
+			output = (output + chunk.toString()).slice(-64e3);
+			progress(output);
+		};
+		child.stdout.on("data", append);
+		child.stderr.on("data", append);
+		child.on("error", reject);
+		child.on("close", (code) => {
+			clearTimeout(timeout);
+			clearTimeout(force);
+			signal.removeEventListener("abort", abort);
+			if (interrupted) reject(/* @__PURE__ */ new Error(`${interrupted.message}\n${output}`));
+			else if (code === 0) resolve(output);
+			else reject(/* @__PURE__ */ new Error(`Command exited with ${code}.\n${output}`));
+		});
+	});
+}
+//#endregion
+//#region src/review-head-checkout.ts
+async function ensureReviewPinnedCheckout(input) {
+	const target = await resolveReviewPinnedCheckout({
+		...input,
+		role: input.role ?? "head"
+	});
+	if (!target) return null;
+	if (!(await withFileLock(`${target.checkoutPath}.prepare-lock`, {
+		retryMs: 20,
+		timeoutMs: 3e4,
+		staleMs: 12e4,
+		heartbeatMs: 5e3,
+		unownedGraceMs: 1e3
+	}, () => materializeReviewPinnedCheckout({
+		rootPath: input.rootPath,
+		...target
+	}))).acquired) throw new Error(`Pinned checkout ${target.commit} is busy; retry the operation.`);
+	return target.checkoutPath;
+}
+async function resolveReviewPinnedCheckout(input) {
+	const commit = await resolveReviewPinnedCommit(input.rootPath, input.ref);
+	if (!commit) return null;
+	const commonDir = await gitCommonDir(input.rootPath);
+	if (!commonDir) return null;
+	return {
+		checkoutPath: reviewManagedCheckoutDir(commonDir, input.reviewUuid, input.role ?? "head", commit),
+		commit
+	};
+}
+async function materializeReviewPinnedCheckout(input) {
+	const { checkoutPath } = input;
+	if (await isWorktreeAt(input.rootPath, checkoutPath, input.commit)) return;
+	if (await jjRevisionIsConflicted(input.rootPath, input.commit)) throw new Error(`Whiteboard cannot pin conflicted revision ${input.commit.slice(0, 12)}: the jj change has unresolved conflicts. Resolve them (jj resolve), then re-pin the review.`);
+	await git(input.rootPath, [
+		"worktree",
+		"remove",
+		"--force",
+		checkoutPath
+	], { allowFailure: true });
+	await git(input.rootPath, ["worktree", "prune"], { allowFailure: true });
+	rmSync(checkoutPath, {
+		recursive: true,
+		force: true
+	});
+	await removeReviewPrepareArtifacts(checkoutPath);
+	await mkdir(path.dirname(checkoutPath), { recursive: true });
+	await git(input.rootPath, [
+		"worktree",
+		"add",
+		"--detach",
+		checkoutPath,
+		input.commit
+	]);
+}
+/**
+* Remove every checkout one Review owns in a repository. Registrations go
+* first, so an interrupted removal cannot leave a gutted tree that git still
+* lists and a later ensure would reuse; an unregistered leftover is replaced
+* by the next ensure. Each checkout is removed on its own, so one that cannot
+* be deleted leaves the others removed; the error names every failure.
+*/
+async function removeReviewManagedCheckouts(commonDir, reviewUuid) {
+	const root = reviewManagedCheckoutRoot(commonDir, reviewUuid);
+	if (!isInsideDirectory(root, reviewManagedCheckoutsDir(commonDir))) throw new Error(`Refusing to remove non-managed checkouts at ${root}.`);
+	const roots = [root, path.join(realPath(path.dirname(root)), path.basename(root))];
+	const errors = [];
+	const kept = /* @__PURE__ */ new Set();
+	const attempt = (work) => work.then(() => true, (error) => {
+		errors.push(errorMessage(error));
+		return false;
+	});
+	for (const worktree of await listRegisteredWorktrees(commonDir)) if (roots.some((dir) => isInsideDirectory(worktree.worktreePath, dir)) && !await attempt(git(commonDir, [
+		"worktree",
+		"remove",
+		"--force",
+		worktree.worktreePath
+	]))) kept.add(realPath(worktree.worktreePath));
+	const entries = async (dir) => (await lstat(dir).catch(() => null))?.isDirectory() ? await readdir(dir, { withFileTypes: true }) : [];
+	for (const entry of await entries(root)) {
+		const dir = path.join(root, entry.name);
+		const checkouts = entry.isDirectory() && (entry.name === "base" || entry.name === "head") ? (await entries(dir)).map((child) => path.join(dir, child.name)) : [dir];
+		for (const checkout of checkouts) if (!kept.has(path.join(realPath(path.dirname(checkout)), path.basename(checkout)))) await attempt(rm(checkout, {
+			recursive: true,
+			force: true
+		}));
+	}
+	if (!errors.length) await rm(root, {
+		recursive: true,
+		force: true
+	});
+	await git(commonDir, ["worktree", "prune"], { allowFailure: true });
+	if (errors.length) throw new Error(errors.join("\n"));
+}
+async function resolveReviewPinnedCommit(rootPath, ref) {
+	const resolved = await resolveRevision(rootPath, ref).catch(() => null);
+	if (resolved) return resolved.commit;
+	const fromGitDir = await git(rootPath, [
+		"rev-parse",
+		"--verify",
+		`${ref}^{commit}`
+	], { allowFailure: true }).catch(() => null);
+	if (!fromGitDir?.ok) return null;
+	return fromGitDir.stdout.trim() || null;
+}
+async function isWorktreeAt(rootPath, checkoutPath, commit) {
+	if (!existsSync(path.join(checkoutPath, ".git"))) return false;
+	const list = await git(rootPath, [
+		"worktree",
+		"list",
+		"--porcelain"
+	], { allowFailure: true }).catch(() => null);
+	if (!list?.ok) return false;
+	return parseWorktreeList(list.stdout).some((entry) => path.resolve(entry.worktreePath) === path.resolve(checkoutPath) && entry.headCommit === commit);
+}
+function parseWorktreeList(output) {
+	const entries = [];
+	for (const block of output.split(/\n\n+/)) {
+		let worktreePath = null;
+		let headCommit = null;
+		for (const line of block.split("\n")) if (line.startsWith("worktree ")) worktreePath = line.slice(9);
+		else if (line.startsWith("HEAD ")) headCommit = line.slice(5);
+		if (worktreePath) entries.push({
+			worktreePath,
+			headCommit
+		});
+	}
+	return entries;
+}
+async function listRegisteredWorktrees(rootPath) {
+	const listed = await git(rootPath, [
+		"worktree",
+		"list",
+		"--porcelain"
+	], { allowFailure: true }).catch(() => null);
+	return listed?.ok ? parseWorktreeList(listed.stdout) : [];
+}
+function realPath(filePath) {
+	return existsSync(filePath) ? realpathSync(filePath) : path.resolve(filePath);
+}
+function isInsideDirectory(filePath, directory) {
+	const relative = path.relative(directory, filePath);
+	return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+//#endregion
+//#region src/server/diffr-languages.ts
+const exec$1 = promisify(execFile);
+const versionSchema = z.object({ version: z.string() });
+const stampSchema = z.object({
+	version: z.string(),
+	full: z.boolean()
+});
+const pending = /* @__PURE__ */ new Map();
+function configuration(root) {
+	const installer = path.join(root, "bin/diffr-package/bin/fetch.mjs");
+	const { version } = versionSchema.parse(JSON.parse(readFileSync(path.join(root, "bin/diffr-package/package.json"), "utf8")));
+	const directory = path.join(process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache"), "diffr", version, `${process.platform}-${process.arch}`, "full");
+	return {
+		installer,
+		version,
+		directory,
+		binary: path.join(directory, process.platform === "win32" ? "diffr.exe" : "diffr")
+	};
+}
+function installedFullDiffr(root) {
+	try {
+		const { binary, directory, version } = configuration(root);
+		const stat = lstatSync(binary);
+		const stamp = stampSchema.parse(JSON.parse(readFileSync(path.join(directory, "diffr.stamp.json"), "utf8")));
+		if (stat.isFile() && (process.platform === "win32" || stat.mode & 73) && stamp.full && stamp.version === version) return binary;
+	} catch {}
+}
+function installFullDiffr(root = findReviewPackageRoot(import.meta.url)) {
+	if (process.env.REVIEW_DIFFR_BINARY) return Promise.reject(/* @__PURE__ */ new Error("An explicitly selected diffr executable is in use. Install its full edition separately."));
+	const { installer, directory } = configuration(root);
+	const current = pending.get(directory);
+	if (current) return current;
+	const task = exec$1(process.execPath, [
+		installer,
+		"--full",
+		"--required",
+		"--into",
+		directory
+	], {
+		env: {
+			...process.env,
+			ELECTRON_RUN_AS_NODE: "1"
+		},
+		timeout: 18e4
+	}).then(() => {}).finally(() => pending.delete(directory));
+	pending.set(directory, task);
+	return task;
+}
+//#endregion
+//#region src/server/structural-diff.ts
+function diffrExecutable(packageRoot = findReviewPackageRoot(import.meta.url)) {
+	if (process.env.REVIEW_DIFFR_BINARY) return process.env.REVIEW_DIFFR_BINARY;
+	const full = installedFullDiffr(packageRoot);
+	if (full) return full;
+	const bundled = path.join(packageRoot, "bin", process.platform === "win32" ? "diffr.exe" : "diffr");
+	return existsSync(bundled) ? bundled : "diffr";
+}
+function diffrMissingError() {
+	return /* @__PURE__ */ new Error(`Cannot find diffr at ${diffrExecutable()}. Whiteboard Desktop bundles it at bin/diffr under its runtime; in a checkout, run \`pnpm --filter @dev.fast/whiteboard ensure:diffr\` or install diffr on PATH, or set REVIEW_DIFFR_BINARY to its executable.`);
+}
+/**
+* Stream validated diffr records. File errors and aborted completion are data;
+* launch failures, malformed/truncated streams and unexpected exits throw.
+* Closing the iterator (including a consumer's break) terminates the child.
+*/
+async function* structuralDiff(input) {
+	input.signal.throwIfAborted();
+	const comparison = input.comparison;
+	const args = [
+		"--repo",
+		input.repositoryPath,
+		"--format",
+		"ndjson",
+		"--stream-annotations"
+	];
+	switch (comparison.kind) {
+		case "worktree":
+			args.push(comparison.base);
+			break;
+		case "trees":
+			args.push(comparison.base, comparison.head);
+			break;
+		case "merge-base": args.push(`${comparison.base}...${comparison.head}`);
+	}
+	args.push("--", ...input.paths ?? []);
+	const idleAbort = new AbortController();
+	const idle = setTimeout(() => idleAbort.abort(), 12e4);
+	const signal = AbortSignal.any([idleAbort.signal, input.signal]);
+	console.info(`[Review] structural diff: ${diffrExecutable()} ${args.join(" ")}`);
+	const child = spawn(diffrExecutable(), args, {
+		cwd: input.repositoryPath,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		signal
+	});
+	let stderr = "";
+	child.stderr.setEncoding("utf8");
+	child.stderr.on("data", (chunk) => {
+		stderr = (stderr + chunk).slice(-16384);
+	});
+	const exited = new Promise((resolve, reject) => {
+		child.once("error", (error) => {
+			reject(error.code === "ENOENT" ? diffrMissingError() : error);
+		});
+		child.once("close", (code) => resolve(code));
+	});
+	const exitError = (code) => /* @__PURE__ */ new Error(`diffr exited with ${code}: ${stderr}`);
+	exited.catch(() => {});
+	let started = false;
+	let completed = false;
+	let aborted;
+	let failed = 0;
+	let annotationFailed = false;
+	const lines = createInterface({
+		input: child.stdout,
+		crlfDelay: Infinity
+	});
+	try {
+		for await (const line of lines) {
+			idle.refresh();
+			if (Buffer.byteLength(line) > 67108864) throw new Error("Structural diff record exceeded 64 MiB.");
+			if (!line.trim()) continue;
+			const event = decodeStructuralDiffEvent(line);
+			if (completed) throw new Error("diffr emitted data after completion.");
+			if (!started) {
+				if (event.type !== "start" || event.version !== 4) throw new Error("Unsupported diffr stream protocol.");
+				started = true;
+			} else if (event.type === "complete") {
+				completed = true;
+				failed = event.failed;
+				aborted = event.aborted;
+			} else if (event.type === "annotations") annotationFailed ||= event.error !== void 0;
+			else if (event.type !== "file") throw new Error(`Unexpected diffr event: ${event.type}`);
+			yield event;
+		}
+		if (!completed) {
+			const code = await exited;
+			if (code !== 0) throw exitError(code);
+			throw new Error("diffr stream ended before completion.");
+		}
+		const code = await exited;
+		if (code !== 0 && !(code === 2 && (failed > 0 || annotationFailed || aborted !== void 0))) throw exitError(code);
+	} finally {
+		clearTimeout(idle);
+		lines.close();
+		if (child.exitCode === null) child.kill();
+		await exited.catch(() => {});
+	}
+}
+//#endregion
+//#region src/server/structural-comparisons.ts
+/** Replays a pinned comparison to concurrent rendering and coverage consumers. */
+var StructuralComparisons = class {
+	entries = /* @__PURE__ */ new Map();
+	async *stream(input) {
+		input.signal.throwIfAborted();
+		const key = JSON.stringify([
+			configGeneration,
+			input.repositoryPath,
+			input.comparison,
+			input.paths
+		]);
+		let entry = this.entries.get(key);
+		if (entry) this.entries.delete(key);
+		else entry = new Comparison(input);
+		this.entries.set(key, entry);
+		entry.readers++;
+		try {
+			yield* entry.read(input.signal);
+		} finally {
+			entry.readers--;
+			if (!entry.done && !entry.initialReady && !entry.readers || entry.error || entry.failed) {
+				entry.abort.abort();
+				this.entries.delete(key);
+			}
+			const idle = [...this.entries].filter(([, value]) => (value.done || value.initialReady) && !value.readers);
+			for (const [oldKey, old] of idle.slice(0, -10)) {
+				old.abort.abort();
+				this.entries.delete(oldKey);
+			}
+		}
+	}
+	close() {
+		for (const entry of this.entries.values()) entry.abort.abort();
+		this.entries.clear();
+	}
+};
+let configGeneration = 0;
+function invalidateStructuralComparisons() {
+	configGeneration++;
+}
+var Comparison = class {
+	abort = new AbortController();
+	events = [];
+	readers = 0;
+	done = false;
+	error;
+	failed = false;
+	initialReady = false;
+	remaining;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(input) {
+		this.run(input);
+	}
+	async run(input) {
+		try {
+			for await (const event of structuralDiff({
+				...input,
+				signal: this.abort.signal
+			})) {
+				if (event.type === "start") {
+					this.remaining = new Set(event.files.map((entry) => (entry.file.rhs ?? entry.file.lhs).path));
+					this.initialReady = this.remaining.size === 0;
+				} else if (event.type === "file") {
+					const path = (event.file.rhs ?? event.file.lhs).path;
+					if (!this.remaining?.delete(path)) throw new Error(`Unexpected structural result: ${path}`);
+					this.initialReady = this.remaining.size === 0;
+				}
+				if (event.type === "complete") this.failed = event.failed > 0 || !!event.aborted;
+				this.events.push(event);
+				for (const wake of this.listeners) wake();
+			}
+		} catch (error) {
+			this.error = error;
+		} finally {
+			this.done = true;
+			for (const wake of this.listeners) wake();
+		}
+	}
+	async *read(signal) {
+		let index = 0;
+		while (true) {
+			signal.throwIfAborted();
+			if (index < this.events.length) {
+				yield this.events[index++];
+				continue;
+			}
+			if (this.done) {
+				if (this.error) throw this.error;
+				return;
+			}
+			await new Promise((resolve) => {
+				const wake = () => {
+					this.listeners.delete(wake);
+					signal.removeEventListener("abort", wake);
+					resolve();
+				};
+				this.listeners.add(wake);
+				signal.addEventListener("abort", wake, { once: true });
+			});
+		}
+	}
+};
+//#endregion
+//#region src/unified-diff.ts
+const HUNK_HEADER = /^@@ -(?<oldStart>\d+)(?:,(?<oldLines>\d+))? \+(?<newStart>\d+)(?:,(?<newLines>\d+))? @@/;
+function parseUnifiedPatch(file, patch) {
+	if (!patch) return [];
+	const hunks = [];
+	let current = null;
+	let oldLine = 0;
+	let newLine = 0;
+	for (const row of patch.split(/\r?\n/)) {
+		const header = HUNK_HEADER.exec(row);
+		if (header?.groups) {
+			current = {
+				file,
+				oldStart: Number(header.groups.oldStart),
+				oldLines: Number(header.groups.oldLines ?? "1"),
+				newStart: Number(header.groups.newStart),
+				newLines: Number(header.groups.newLines ?? "1"),
+				lines: []
+			};
+			oldLine = current.oldStart;
+			newLine = current.newStart;
+			hunks.push(current);
+			continue;
+		}
+		if (!current || row.startsWith("\")) continue;
+		const marker = row[0];
+		const text = row.slice(1);
+		let line = null;
+		if (marker === " ") {
+			line = {
+				kind: "context",
+				oldLine,
+				newLine,
+				text
+			};
+			oldLine += 1;
+			newLine += 1;
+		} else if (marker === "+") {
+			line = {
+				kind: "add",
+				oldLine: null,
+				newLine,
+				text
+			};
+			newLine += 1;
+		} else if (marker === "-") {
+			line = {
+				kind: "remove",
+				oldLine,
+				newLine: null,
+				text
+			};
+			oldLine += 1;
+		}
+		if (line) current.lines.push(line);
+	}
+	return hunks;
+}
+//#endregion
+//#region src/software-map-diff-counts.ts
+async function resolveSoftwareMapDiffCounts(input) {
+	const baseRef = input.baseRef?.trim();
+	if (!baseRef) return {
+		countsByElementPath: {},
+		unmappedByElementPath: {}
+	};
+	const headRef = input.headRef?.trim() || void 0;
+	const sourceRootPath = input.sourceRootPath;
+	const diff$1 = input.patch ?? await diff({
+		rootPath: sourceRootPath,
+		kind: input.sourceVcsKind,
+		baseRef,
+		headRef,
+		contextLines: 0
+	}).catch(() => "");
+	if (!diff$1.trim()) return {
+		baseRef,
+		headRef,
+		countsByElementPath: {},
+		unmappedByElementPath: {}
+	};
+	const countsByFile = parseGitUnifiedDiffLineCounts(diff$1, input.side);
+	if (countsByFile.size === 0) return {
+		baseRef,
+		headRef,
+		countsByElementPath: {},
+		unmappedByElementPath: {}
+	};
+	const mapped = await mapDiffLineCountsToSoftwareMapElements({
+		codeElements: input.codeElements,
+		countsByFile
+	});
+	const unmappedByElementPath = mapDiffLineCountsToCoverageClaims({
+		coverageClaims: input.coverageClaims ?? [],
+		countsByFile
+	});
+	return {
+		baseRef,
+		headRef,
+		countsByElementPath: mapped.countsByElementPath,
+		unmappedByElementPath
+	};
+}
+function parseGitUnifiedDiffLineCounts(diff, side = "head") {
+	const countsByFile = /* @__PURE__ */ new Map();
+	for (const fileDiff of splitGitDiff(diff)) {
+		const file = side === "base" ? fileDiff.oldFile ?? fileDiff.newFile : fileDiff.newFile ?? fileDiff.oldFile;
+		if (!file) continue;
+		for (const hunk of parseUnifiedPatch(file, fileDiff.patch)) {
+			let currentNewLine = Math.max(1, hunk.newStart);
+			let currentOldLine = Math.max(1, hunk.oldStart);
+			let replacedOldLine = null;
+			for (const line of hunk.lines) {
+				if (line.kind === "add" && line.newLine !== null) {
+					addLineCount(countsByFile, file, side === "base" ? replacedOldLine ?? currentOldLine : line.newLine, "additions", line);
+					currentNewLine = line.newLine + 1;
+					continue;
+				}
+				if (line.kind === "remove") {
+					const oldLine = line.oldLine ?? currentOldLine;
+					addLineCount(countsByFile, file, side === "base" ? oldLine : currentNewLine, "deletions", line);
+					replacedOldLine ??= oldLine;
+					currentOldLine = oldLine + 1;
+					continue;
+				}
+				replacedOldLine = null;
+				if (line.newLine !== null) currentNewLine = line.newLine + 1;
+				if (line.oldLine !== null) currentOldLine = line.oldLine + 1;
+			}
+		}
+	}
+	return countsByFile;
+}
+function mapDiffLineCountsToSoftwareMapElements(input) {
+	const countsByElementPath = {};
+	for (const element of input.codeElements) {
+		const total = {
+			additions: 0,
+			deletions: 0
+		};
+		const countedLines = /* @__PURE__ */ new Set();
+		for (const range of element.sourceRanges ?? []) {
+			const fileCounts = input.countsByFile.get(range.file);
+			if (!fileCounts) continue;
+			for (const [line, counts] of fileCounts) {
+				if (line < range.fromLine || line > range.toLine) continue;
+				const lineKey = `${range.file}:${line}`;
+				if (countedLines.has(lineKey)) continue;
+				countedLines.add(lineKey);
+				total.additions += element.changeStatus === "removed" ? 0 : counts.additions;
+				total.deletions += element.changeStatus === "added" ? 0 : counts.deletions;
+			}
+		}
+		if (total.additions > 0 || total.deletions > 0) countsByElementPath[element.path] = total;
+	}
+	return { countsByElementPath };
+}
+function mapDiffLineCountsToCoverageClaims(input) {
+	const result = {};
+	const claims = input.coverageClaims.filter((claim) => (claim.files?.length ?? 0) > 0 || (claim.globs?.length ?? 0) > 0).sort(compareCoverageClaims);
+	for (const [file, fileCounts] of input.countsByFile) for (const [line, counts] of fileCounts) for (const claim of claims) {
+		if (!softwareMapCoverageClaimMatchesLine(claim, file, line)) continue;
+		const summary = result[claim.path] ??= {
+			additions: 0,
+			deletions: 0,
+			files: []
+		};
+		summary.additions += counts.additions;
+		summary.deletions += counts.deletions;
+		addUnmappedFileLine(summary, file, line, counts.rows);
+	}
+	return result;
+}
+function addLineCount(countsByFile, file, line, kind, diffLine) {
+	const fileCounts = countsByFile.get(file) ?? /* @__PURE__ */ new Map();
+	const current = fileCounts.get(line) ?? {
+		additions: 0,
+		deletions: 0,
+		rows: []
+	};
+	current[kind] += 1;
+	current.rows.push(toUnmappedDiffLine(diffLine));
+	fileCounts.set(line, current);
+	countsByFile.set(file, fileCounts);
+}
+function addUnmappedFileLine(summary, file, line, rows) {
+	let fileSummary = summary.files.find((candidate) => candidate.file === file);
+	if (!fileSummary) {
+		fileSummary = {
+			file,
+			additions: 0,
+			deletions: 0,
+			hunks: []
+		};
+		summary.files.push(fileSummary);
+	}
+	for (const row of rows) {
+		if (row.kind === "add") fileSummary.additions += 1;
+		if (row.kind === "remove") fileSummary.deletions += 1;
+	}
+	const lastHunk = fileSummary.hunks.at(-1);
+	if (lastHunk && line <= lastHunk.startLine + lastHunk.lines.length + 1) lastHunk.lines.push(...rows);
+	else fileSummary.hunks.push({
+		startLine: line,
+		lines: [...rows]
+	});
+}
+function toUnmappedDiffLine(line) {
+	return {
+		kind: line.kind === "add" ? "add" : "remove",
+		oldLine: line.oldLine,
+		newLine: line.newLine,
+		text: line.text
+	};
+}
+function compareCoverageClaims(left, right) {
+	return coverageSpecificity(right) - coverageSpecificity(left);
+}
+function coverageSpecificity(claim) {
+	const pathDepth = claim.path.split(".").length * 1e3;
+	const exactFiles = (claim.files?.length ?? 0) * 20;
+	const globs = claim.globs?.reduce((total, glob) => total + glob.length, 0) ?? 0;
+	return pathDepth + exactFiles + globs;
+}
+function softwareMapCoverageClaimMatchesLine(claim, file, line) {
+	for (const claimedFile of claim.files ?? []) {
+		if (claimedFile.path !== file) continue;
+		if (softwareMapLineInRanges(line, claimedFile.ranges)) return true;
+	}
+	return (claim.globs ?? []).some((glob) => softwareMapGlobMatches(glob, file));
+}
+function softwareMapLineInRanges(line, ranges = []) {
+	if (ranges.length === 0) return true;
+	return ranges.some((range) => line >= range.fromLine && line <= range.toLine);
+}
+const softwareMapGlobRegexes = /* @__PURE__ */ new Map();
+function softwareMapGlobMatches(pattern, value) {
+	let regex = softwareMapGlobRegexes.get(pattern);
+	if (!regex) {
+		regex = new RegExp(`^${globToRegex(pattern)}$`);
+		softwareMapGlobRegexes.set(pattern, regex);
+	}
+	return regex.test(value);
+}
+function globToRegex(pattern) {
+	let result = "";
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index];
+		const next = pattern[index + 1];
+		if (char === "*" && next === "*") {
+			result += ".*";
+			index += 1;
+			continue;
+		}
+		if (char === "*") {
+			result += "[^/]*";
+			continue;
+		}
+		if (char === "?") {
+			result += "[^/]";
+			continue;
+		}
+		result += escapeRegex(char);
+	}
+	return result;
+}
+function escapeRegex(char) {
+	return /[\\^$.*+?()[\]{}|]/.test(char) ? `\\${char}` : char;
+}
+function splitGitDiff(diff) {
+	const result = [];
+	let current = null;
+	for (const line of diff.split(/\r?\n/)) {
+		if (line.startsWith("diff --git ")) {
+			if (current) result.push({
+				oldFile: current.oldFile,
+				newFile: current.newFile,
+				patch: current.lines.join("\n")
+			});
+			current = {
+				oldFile: null,
+				newFile: null,
+				lines: []
+			};
+			continue;
+		}
+		if (!current) continue;
+		const oldFile = parseGitFileLine(line, "--- ");
+		const newFile = parseGitFileLine(line, "+++ ");
+		if (oldFile !== void 0) {
+			current.oldFile = oldFile;
+			continue;
+		}
+		if (newFile !== void 0) {
+			current.newFile = newFile;
+			continue;
+		}
+		current.lines.push(line);
+	}
+	if (current) result.push({
+		oldFile: current.oldFile,
+		newFile: current.newFile,
+		patch: current.lines.join("\n")
+	});
+	return result;
+}
+function parseGitFileLine(line, prefix) {
+	if (!line.startsWith(prefix)) return void 0;
+	const raw = unquoteGitPath(line.slice(prefix.length).trim());
+	if (raw === "/dev/null") return null;
+	if (raw.startsWith("a/") || raw.startsWith("b/")) return raw.slice(2);
+	return raw;
+}
+function unquoteGitPath(value) {
+	if (!value.startsWith(`"`)) return value;
+	const unquoted = value.slice(1, value.endsWith(`"`) ? -1 : void 0);
+	try {
+		return jsonString(parseJsonText(value)) ?? unquoted;
+	} catch {
+		return unquoted;
+	}
+}
+//#endregion
+//#region src/review-api/checkout-fs.ts
+/**
+* File system calls for paths inside a user's checkout. Electron's `fs`
+* treats every `*.asar` path as an archive, so a checkout that merely
+* contains one fails with "Invalid package" or shows it as a directory.
+* Electron's unpatched `original-fs` reads it as the plain file it is.
+*/
+const checkoutFs = process.versions.electron ? createRequire(import.meta.url)("original-fs").promises : fs$1;
+//#endregion
+//#region src/review-api/lens-alignment.ts
+/** Project the already-computed patch's runs, including unchanged gaps. */
+function textualRows(path, patch, baseCount, headCount) {
+	const rows = [];
+	let base = 0, head = 0;
+	const append = (baseEnd, headEnd) => {
+		while (base < baseEnd || head < headEnd) rows.push([base < baseEnd ? base++ : null, head < headEnd ? head++ : null]);
+	};
+	for (const hunk of parseUnifiedPatch(path, patch)) {
+		append(hunk.oldLines ? hunk.oldStart - 1 : hunk.oldStart, hunk.newLines ? hunk.newStart - 1 : hunk.newStart);
+		let removed = 0, added = 0;
+		const flush = () => {
+			append(base + removed, head + added);
+			removed = added = 0;
+		};
+		for (const line of hunk.lines) if (line.kind === "context") {
+			flush();
+			append(base + 1, head + 1);
+		} else if (line.kind === "add") added++;
+		else removed++;
+		flush();
+	}
+	append(baseCount, headCount);
+	return rows;
+}
+//#endregion
+//#region src/review-api/comparison-coverage.ts
+const hash = (parts) => createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+/** Immutable comparison facts shared by catalog totals and review progress. */
+async function comparisonCoverage(data, reviewId, pins, mode, signal, publish) {
+	const fileSources = /* @__PURE__ */ new Map();
+	const alignments = /* @__PURE__ */ new Map();
+	const files = [];
+	if (mode === "textual") for (const file of await data.changes(pins)) {
+		signal.throwIfAborted();
+		const patch = await data.changes(pins, file.path);
+		const changed = emptyCoverage();
+		for (const hunk of parseUnifiedPatch(file.path, patch)) for (const line of hunk.lines) {
+			if (line.kind === "add") changed.head.push([line.newLine - 1, line.newLine]);
+			if (line.kind === "remove") changed.base.push([line.oldLine - 1, line.oldLine]);
+		}
+		changed.base = unionIntervals(changed.base);
+		changed.head = unionIntervals(changed.head);
+		const [base, head] = await Promise.all([file.status === "added" ? null : data.file(pins, "base", file.previousPath ?? file.path).then((value) => value.text).catch(() => null), file.status === "deleted" ? null : data.file(pins, "head", file.path).then((value) => value.text).catch(() => null)]);
+		alignments.set(file.path, textualRows(file.path, patch, base === null ? 0 : base.split("\n").length, head === null ? 0 : head.split("\n").length));
+		const readable = (file.status === "added" || base !== null) && (file.status === "deleted" || head !== null);
+		const fingerprint = hash([
+			pins.repositoryId,
+			base,
+			head,
+			...readable ? [] : [
+				pins.base,
+				pins.head,
+				patch
+			]
+		]);
+		fileSources.set(file.path, [...base !== null ? [{
+			side: "base",
+			file: file.previousPath ?? file.path,
+			fromLine: 1,
+			toLine: base.split("\n").length
+		}] : [], ...head !== null ? [{
+			side: "head",
+			file: file.path,
+			fromLine: 1,
+			toLine: head.split("\n").length
+		}] : []]);
+		files.push({
+			path: file.path,
+			previousPath: file.previousPath,
+			fingerprint,
+			changed,
+			viewed: emptyCoverage()
+		});
+		publish?.({
+			files: [...files],
+			fileSources: new Map(fileSources),
+			alignments: new Map(alignments)
+		});
+	}
+	else {
+		const remaining = /* @__PURE__ */ new Set();
+		for await (const event of data.structuralChanges({
+			reviewId,
+			pins,
+			signal
+		})) {
+			if (event.type === "start") {
+				for (const entry of event.files) remaining.add((entry.file.rhs ?? entry.file.lhs).path);
+				if (!remaining.size) break;
+				continue;
+			}
+			if (event.type === "complete" && (event.failed || event.aborted)) throw new Error(event.aborted?.message ?? "Structural coverage is incomplete.");
+			if (event.type !== "file") continue;
+			const path = (event.file.rhs ?? event.file.lhs).path;
+			if (!remaining.delete(path)) throw new Error(`Unexpected structural result: ${path}`);
+			if (event.error) {
+				if (event.error.code !== "unsupported_file_type") throw new Error(`Cannot count ${path}: ${event.error.message}`);
+				if (!remaining.size) break;
+				continue;
+			}
+			const diff = event.diff;
+			const previousPath = event.file.lhs?.path !== path ? event.file.lhs?.path : void 0;
+			const base = diff.type === "text" ? diff.lhs?.text ?? null : null;
+			const head = diff.type === "text" ? diff.rhs?.text ?? null : null;
+			const fingerprint = hash([
+				pins.repositoryId,
+				base,
+				head,
+				...diff.type === "binary" ? [event.file.lhs?.oid ?? null, event.file.rhs?.oid ?? null] : []
+			]);
+			const sources = [];
+			if (base !== null) sources.push({
+				side: "base",
+				file: event.file.lhs.path,
+				fromLine: 1,
+				toLine: base.split("\n").length
+			});
+			if (head !== null) sources.push({
+				side: "head",
+				file: path,
+				fromLine: 1,
+				toLine: head.split("\n").length
+			});
+			fileSources.set(path, sources);
+			if (diff.type === "text") alignments.set(path, structuralRows(diff));
+			files.push({
+				path,
+				previousPath,
+				fingerprint,
+				changed: diff.type === "text" ? diff.structural_changes : emptyCoverage(),
+				folded: foldedChanges(event.visibility, diff),
+				viewed: emptyCoverage()
+			});
+			publish?.({
+				files: [...files],
+				fileSources: new Map(fileSources),
+				alignments: new Map(alignments)
+			});
+			if (!remaining.size) break;
+		}
+		if (remaining.size) throw new Error("Structural coverage is incomplete.");
+	}
+	return {
+		files,
+		fileSources,
+		alignments
+	};
+}
+/**
+* The changed lines diffr folds by default. A file it hides (lockfiles,
+* generated, vendored and test files, per its plugins) folds all of them.
+* Otherwise they are the changed lines under regions that start collapsed
+* and in no visible leaf: `structural_changes` less what diffr counts in
+* `stats.visible`, recomputed the way diffr's `change_coverage` does so that
+* the lines, not just the counts, are known. A paired leaf contributes its
+* changed spans' lines; an unpaired leaf, all of its lines.
+*/
+function foldedChanges(visibility, diff) {
+	if (diff.type !== "text") return emptyCoverage();
+	const all = diff.structural_changes;
+	if (visibility?.collapsed) return {
+		base: unionIntervals(all.base),
+		head: unionIntervals(all.head)
+	};
+	const side = (changed, source, other) => {
+		const paired = /* @__PURE__ */ new Set();
+		const pair = (region) => {
+			if (region.kind === "leaf") paired.add(region.alignment_id);
+			else region.children.forEach(pair);
+		};
+		other?.regions?.forEach(pair);
+		const hidden = [], visible = [];
+		const collect = (region, folded) => {
+			folded ||= region.visibility?.collapsed === true;
+			if (region.kind === "fold") {
+				for (const child of region.children) collect(child, folded);
+				return;
+			}
+			const lines = folded ? hidden : visible;
+			if (paired.has(region.alignment_id)) for (const span of region.changed ?? []) lines.push([span.line, span.line + 1]);
+			else lines.push([region.start.line, region.end.column === 0 ? region.end.line : region.end.line + 1]);
+		};
+		for (const region of source?.regions ?? []) collect(region, false);
+		return subtractIntervals(intersectIntervals(changed, hidden), visible);
+	};
+	return {
+		base: side(all.base, diff.lhs, diff.rhs),
+		head: side(all.head, diff.rhs, diff.lhs)
+	};
+}
+//#endregion
+//#region src/review-api/image-decode.ts
+/** The one decoder for images entering the store, whether uploaded by a client
+* or read from a legacy review: bounded, single frame, re-encoded as PNG. */
+async function decodeImage(bytes) {
+	const { default: sharp } = await import("sharp");
+	try {
+		const decoder = sharp(Buffer.from(bytes), {
+			limitInputPixels: 2e7,
+			failOn: "warning"
+		});
+		const metadata = await decoder.metadata();
+		if (![
+			"png",
+			"jpeg",
+			"webp"
+		].includes(metadata.format ?? "") || (metadata.pages ?? 1) !== 1) throw new Error("Unsupported image");
+		return await decoder.png().toBuffer();
+	} catch {
+		throw new ReviewInputError("Provide a valid single PNG, JPEG, or WebP image (at most 20 megapixels).");
+	}
+}
+//#endregion
+//#region src/review-api/map-input.ts
+const label = z.string().trim().min(1);
+const nonEmptyStringSchema = z.string().refine((value) => value.trim().length > 0, "Must not be empty");
+const optionalNonEmptyStringSchema = nonEmptyStringSchema.optional();
+const softwareDataStoreForeignKeyRefSchema = z.union([nonEmptyStringSchema, z.strictObject({
+	store: optionalNonEmptyStringSchema,
+	table: nonEmptyStringSchema,
+	field: nonEmptyStringSchema,
+	label: optionalNonEmptyStringSchema,
+	cardinality: z.enum(["one-to-one", "many-to-one"]).optional(),
+	onDelete: optionalNonEmptyStringSchema,
+	onUpdate: optionalNonEmptyStringSchema
+})]);
+const softwareDataStoreFieldSchema = z.lazy(() => z.record(nonEmptyStringSchema, z.union([z.strictObject({
+	type: nonEmptyStringSchema,
+	example: z.unknown().optional(),
+	pk: z.boolean().optional(),
+	fk: softwareDataStoreForeignKeyRefSchema.optional(),
+	schema: softwareDataStoreFieldSchema.optional()
+}), softwareDataStoreFieldSchema])));
+const softwareDataStoreCollectionInputSchema = z.strictObject({
+	label: optionalNonEmptyStringSchema,
+	key: optionalNonEmptyStringSchema,
+	schema: softwareDataStoreFieldSchema
+});
+const endpoint = label.describe("Existing element or data-store schema path. Resolution order: relative to the containing element, relative to its parent, then full path. \".\" means the containing element. At model root use full paths. Cross-level endpoints are allowed.");
+const range = z.strictObject({
+	fromLine: z.number().int().positive(),
+	toLine: z.number().int().positive()
+});
+const relationship = z.union([z.strictObject({
+	kind: z.literal("call"),
+	from: endpoint,
+	to: endpoint,
+	label: z.string().optional(),
+	description: z.string().optional(),
+	nthCallSite: z.number().int().nonnegative().optional()
+}), z.strictObject({
+	kind: z.literal("semantic"),
+	from: endpoint,
+	to: endpoint,
+	label: z.string().optional(),
+	description: z.string().optional(),
+	semanticKind: z.string().optional(),
+	sourceRanges: z.array(range).optional()
+})]);
+const base = z.strictObject({
+	id: label.optional().describe("Local ID, unique among siblings; defaults to the object key (or array index). Give array entries explicit IDs for stable paths. Nesting builds the full path: api under app becomes app.api. Do not repeat the parent path in the ID."),
+	label: label.optional(),
+	description: z.string().optional(),
+	changeStatus: z.enum([
+		"added",
+		"removed",
+		"modified",
+		"unchanged"
+	]).optional(),
+	relationships: z.array(relationship).optional().describe("Relationships scoped to this element. Endpoints may use relative names or full paths; they need not be direct children.")
+});
+const coverage = z.strictObject({
+	files: z.array(z.union([label, z.strictObject({
+		path: label,
+		ranges: z.array(range).optional()
+	})])).optional(),
+	globs: z.array(label).optional()
+});
+const collection = (schema) => z.union([z.record(label, schema), z.array(schema)]);
+const code = base.extend({ sourceRanges: z.array(range.extend({ file: label })).optional() });
+const component = base.extend({
+	coverage: coverage.optional(),
+	codeElements: collection(code).optional()
+});
+const container = base.extend({
+	coverage: coverage.optional(),
+	components: collection(component).optional()
+});
+const store = container.extend({
+	kind: z.enum([
+		"database",
+		"objectStore",
+		"bucket",
+		"artifactStore",
+		"fileStore"
+	]).optional(),
+	tables: z.record(label, softwareDataStoreCollectionInputSchema).optional(),
+	documents: z.record(label, softwareDataStoreCollectionInputSchema).optional()
+});
+const system = base.extend({
+	coverage: coverage.optional(),
+	external: z.boolean().optional(),
+	containers: collection(container).optional(),
+	dataStores: collection(store).optional()
+});
+const mapInputSchema = z.strictObject({
+	people: collection(base).optional(),
+	systems: collection(system).optional(),
+	relationships: z.array(relationship).optional().describe("Model-level relationships, including people and systems. Use full endpoint paths; external systems are systems with external: true.")
+});
+//#endregion
+//#region src/review-api/pull-request.ts
+const GH_TIMEOUT_MS = 2e4;
+const API_TIMEOUT_MS = 15e3;
+const FETCH_TIMEOUT_MS = 12e4;
+const LOCAL_TIMEOUT_MS = 3e4;
+const defaultPullRequestDeps = {
+	run: (file, args, options) => new Promise((resolve, reject) => {
+		execFile(file, args, {
+			cwd: options.cwd,
+			timeout: options.timeoutMs,
+			maxBuffer: 16777216,
+			env: {
+				...process.env,
+				GIT_TERMINAL_PROMPT: "0",
+				GH_PROMPT_DISABLED: "1",
+				GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND ?? "ssh -o BatchMode=yes"
+			}
+		}, (error, stdout, stderr) => {
+			if (!error) return resolve(stdout);
+			const reason = error.killed ? `timed out after ${options.timeoutMs / 1e3}s` : String(stderr).trim() || error.message;
+			reject(/* @__PURE__ */ new Error(`${file} ${args[0]}: ${reason}`));
+		});
+	}),
+	fetch: (input, init) => fetch(input, init)
+};
+/** Host, owner/repo and number from a canonical PR URL (validated by the command schema). */
+function pullRequestAddress(url) {
+	const { hostname, pathname } = new URL(url);
+	const [, owner, repo, , number] = pathname.split("/");
+	return {
+		host: hostname,
+		slug: `${owner}/${repo}`,
+		number: Number(number)
+	};
+}
+const metadataSchema = z.object({
+	number: z.number().int().positive(),
+	title: z.string(),
+	baseRefName: z.string().min(1),
+	baseRefOid: z.string().optional()
+});
+/** gh first (it carries the user's auth), then, for github.com only, GitHub's
+* public REST API: Enterprise hosts require gh. */
+async function readPullRequest(url, deps) {
+	const { host, slug, number } = pullRequestAddress(url);
+	let ghFailure;
+	try {
+		const stdout = await deps.run("gh", [
+			"pr",
+			"view",
+			String(number),
+			"--repo",
+			`${host}/${slug}`,
+			"--json",
+			"number,title,baseRefName,baseRefOid"
+		], { timeoutMs: GH_TIMEOUT_MS });
+		return {
+			host,
+			slug,
+			...metadataSchema.parse(JSON.parse(stdout))
+		};
+	} catch (error) {
+		ghFailure = firstLine(errorMessage(error));
+	}
+	if (host !== "github.com") throw new ReviewInputError(`Could not read ${url}: gh failed (${ghFailure}). Run \`gh auth login --hostname ${host}\` with an account that can read the repository, then retry.`, 409);
+	let response;
+	try {
+		response = await deps.fetch(`https://api.github.com/repos/${slug}/pulls/${number}`, {
+			headers: {
+				Accept: "application/vnd.github+json",
+				"X-GitHub-Api-Version": "2022-11-28"
+			},
+			signal: AbortSignal.timeout(API_TIMEOUT_MS)
+		});
+	} catch (error) {
+		throw unreadable(url, ghFailure, `the GitHub API is unreachable (${firstLine(errorMessage(error))})`);
+	}
+	if (response.status === 404) throw new ReviewInputError(`${url} was not found: it does not exist, or it is private and gh is not signed in to an account that can read it (run \`gh auth status\`). gh said: ${ghFailure}`, 404);
+	if (response.status === 403 || response.status === 429) throw unreadable(url, ghFailure, response.headers.get("x-ratelimit-remaining") === "0" || response.status === 429 ? "the unauthenticated GitHub API rate limit is exhausted" : "the GitHub API refused the request");
+	if (!response.ok) throw unreadable(url, ghFailure, `the GitHub API returned HTTP ${response.status}`);
+	const parsed = z.object({
+		number: z.number(),
+		title: z.string(),
+		base: z.object({
+			ref: z.string().min(1),
+			sha: z.string()
+		})
+	}).safeParse(await response.json().catch(() => void 0));
+	if (!parsed.success) throw unreadable(url, ghFailure, "the GitHub API response was malformed");
+	return {
+		host,
+		slug,
+		number: parsed.data.number,
+		title: parsed.data.title,
+		baseRefName: parsed.data.base.ref,
+		baseRefOid: parsed.data.base.sha
+	};
+}
+/** Remotes by the host and owner/repo their configured URL names. The
+* configured URL, not the insteadOf rewrite: a mirror still names its repo. */
+async function githubRemotes(gitDir, deps) {
+	return (await deps.run("git", [
+		"--git-dir",
+		gitDir,
+		"config",
+		"--get-regexp",
+		String.raw`^remote\..*\.url$`
+	], { timeoutMs: LOCAL_TIMEOUT_MS }).catch(() => "")).split("\n").flatMap((line) => {
+		const match = /^remote\.(.+)\.url\s+(\S+)/.exec(line.trim());
+		const remote = match && parseGitRemote(match[2]);
+		return match && remote ? [{
+			name: match[1],
+			host: remote.host,
+			slug: remote.slug
+		}] : [];
+	});
+}
+/** Refs Review owns for one PR; the user's branches and bookmarks never move. */
+function pullRequestRefs(pr) {
+	const prefix = `refs/review/github/${`${pr.host === "github.com" ? "" : `${pr.host}/`}${pr.slug}`.toLowerCase()}/pull/${pr.number}`;
+	return {
+		head: `${prefix}/head`,
+		base: `${prefix}/base`,
+		frozenBase: `${prefix}/frozen-base`
+	};
+}
+/**
+* Fetch the PR head (refs/pull/N/head, so fork PRs work) and its base branch
+* into Review's own namespace, and return the comparison GitHub shows: the
+* head, and the merge base of the head with the base branch.
+*
+* A PR merged with a merge commit is absorbed: merge-base(base branch, head)
+* is the head itself and the diff is empty. GitHub freezes the base commit
+* (baseRefOid) at the PR's last update, so its merge base with the head is
+* the fork point GitHub diffs against, and it survives base branches that are
+* force-rebuilt or deleted.
+*/
+async function fetchPullRequest(input, deps) {
+	const { pullRequest: pr } = input;
+	const refs = pullRequestRefs(pr);
+	const git = (args, timeoutMs = LOCAL_TIMEOUT_MS) => deps.run("git", [
+		"--git-dir",
+		input.gitDir,
+		...args
+	], { timeoutMs }).then((stdout) => stdout.trim());
+	const fetchRefs = (...refspecs) => git([
+		"fetch",
+		"--no-tags",
+		"--no-write-fetch-head",
+		"--quiet",
+		input.remote,
+		...refspecs
+	], FETCH_TIMEOUT_MS);
+	const commit = (ref) => git([
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		`${ref}^{commit}`
+	]).catch(() => void 0);
+	const mergeBase = (left, right) => git([
+		"merge-base",
+		left,
+		right
+	]).catch(() => void 0);
+	const frozenBase = async () => {
+		if (!pr.baseRefOid) return void 0;
+		if (!await commit(pr.baseRefOid)) await fetchRefs(`+${pr.baseRefOid}:${refs.frozenBase}`).catch(() => void 0);
+		return commit(pr.baseRefOid);
+	};
+	let baseTip;
+	try {
+		await fetchRefs(`+refs/pull/${pr.number}/head:${refs.head}`, `+refs/heads/${pr.baseRefName}:${refs.base}`);
+		baseTip = await commit(refs.base);
+	} catch (error) {
+		try {
+			await fetchRefs(`+refs/pull/${pr.number}/head:${refs.head}`);
+		} catch {
+			throw new ReviewInputError(`Could not fetch PR #${pr.number} from remote "${input.remote}" (${pr.slug}). Check \`git fetch ${input.remote}\` works with your Git credentials, then retry. Git said: ${firstLine(errorMessage(error))}`, 409);
+		}
+	}
+	const head = await commit(refs.head);
+	baseTip ??= await frozenBase();
+	if (!head || !baseTip) throw new ReviewInputError(`Fetched PR #${pr.number} but could not resolve its ${head ? `base branch ${pr.baseRefName}` : "head"}.`, 409);
+	let base = await mergeBase(baseTip, head);
+	if (!base || base === head) {
+		const frozen = await frozenBase();
+		if (frozen && frozen !== baseTip) base = await mergeBase(frozen, head) ?? base;
+	}
+	if (!base) throw new ReviewInputError(`PR #${pr.number}'s head shares no history with ${pr.baseRefName}.`, 409);
+	if (input.kind === "jj") await indexForJj(input.rootPath, [base, head], git, deps);
+	return {
+		head,
+		base
+	};
+}
+/**
+* jj resolves only commits in its index, and `jj git import` indexes only
+* branches, remote branches and tags. Import the commits through a
+* transient tag, then drop it: the commits stay indexed (hidden, resolvable
+* by commit id) and no bookmark or tag remains.
+*/
+async function indexForJj(rootPath, commits, git, deps) {
+	const tags = commits.map(() => `refs/tags/review-index-${randomUUID()}`);
+	const jjImport = () => deps.run("jj", [
+		"-R",
+		rootPath,
+		"git",
+		"import",
+		"--ignore-working-copy",
+		"--quiet"
+	], {
+		cwd: rootPath,
+		timeoutMs: LOCAL_TIMEOUT_MS
+	});
+	try {
+		for (const [index, tag] of tags.entries()) await git([
+			"update-ref",
+			tag,
+			commits[index]
+		]);
+		await jjImport();
+	} finally {
+		for (const tag of tags) await git([
+			"update-ref",
+			"-d",
+			tag
+		]).catch(() => void 0);
+		await jjImport().catch(() => void 0);
+	}
+}
+function unreadable(url, ghFailure, fallback) {
+	return new ReviewInputError(`Could not read ${url}: gh failed (${ghFailure}) and ${fallback}. Run \`gh auth status\` and sign in with an account that can read the repository, then retry.`, 409);
+}
+function firstLine(text) {
+	return text.split("\n")[0].slice(0, 300);
+}
+//#endregion
+//#region src/review-api/activity.ts
+const focusSchema = z.strictObject({
+	description: z.string().trim().min(1).max(160),
+	targetId: z.string().min(1).optional()
+});
+const activityBeginSchema = z.strictObject({ focus: focusSchema.nullable().optional() });
+const activityUpdateSchema = z.strictObject({
+	activityId: z.string().min(1),
+	focus: focusSchema.nullable().optional()
+});
+const activityEndSchema = z.strictObject({ activityId: z.string().min(1) });
+const activitySchema = z.discriminatedUnion("action", [
+	activityBeginSchema.extend({ action: z.literal("begin") }),
+	activityUpdateSchema.extend({ action: z.literal("update") }),
+	activityEndSchema.extend({ action: z.literal("end") })
+]);
+const ACTIVITY_TTL_MS = 18e4;
+var ReviewActivity = class {
+	db;
+	assertReview;
+	timers = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	working = /* @__PURE__ */ new Set();
+	workingListeners = /* @__PURE__ */ new Set();
+	constructor(db, assertReview) {
+		this.db = db;
+		this.assertReview = assertReview;
+		db.exec(`CREATE TABLE IF NOT EXISTS authoring_presences(
+      activity_id TEXT PRIMARY KEY, review_id TEXT NOT NULL, slot INTEGER NOT NULL,
+      started_at INTEGER NOT NULL, expires_at INTEGER NOT NULL, focus TEXT, surface TEXT);
+      DROP TABLE IF EXISTS authoring_sessions;`);
+		for (const row of db.prepare("SELECT DISTINCT review_id FROM authoring_presences WHERE expires_at>?").all(Date.now())) {
+			this.working.add(String(row.review_id));
+			this.scheduleExpiry(String(row.review_id));
+		}
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	/** Fires only when a review starts or stops being authored, never on
+	* renewals or focus changes. */
+	subscribeWorking(listener) {
+		this.workingListeners.add(listener);
+		return () => {
+			this.workingListeners.delete(listener);
+		};
+	}
+	isWorking(reviewId) {
+		return this.working.has(reviewId);
+	}
+	changed(reviewId) {
+		const working = this.db.prepare("SELECT 1 FROM authoring_presences WHERE review_id=? AND expires_at>? LIMIT 1").get(reviewId, Date.now()) !== void 0;
+		if (working !== this.working.has(reviewId)) {
+			if (working) this.working.add(reviewId);
+			else this.working.delete(reviewId);
+			for (const notify of this.workingListeners) notify();
+		}
+		for (const notify of this.listeners) notify(reviewId);
+	}
+	live(reviewId) {
+		return this.db.prepare("SELECT activity_id,slot,expires_at,focus,surface FROM authoring_presences WHERE review_id=? AND expires_at>? ORDER BY rowid").all(reviewId, Date.now());
+	}
+	read(reviewId) {
+		const live = this.live(reviewId);
+		const snapshot = {
+			workingCount: live.length,
+			expiresAt: live.length ? Math.max(...live.map((row) => Number(row.expires_at))) : null
+		};
+		if (live.length) snapshot.activities = live.map((row) => {
+			const presence = {
+				activityId: String(row.activity_id),
+				slot: Number(row.slot)
+			};
+			if (row.focus) presence.focus = focusSchema.parse(JSON.parse(String(row.focus)));
+			if (row.surface === "document" || row.surface === "lenses") presence.surface = row.surface;
+			return presence;
+		});
+		return snapshot;
+	}
+	/** Inside the caller's write transaction: the presence a write belongs to,
+	* renewed and moved to the write's surface. The named one if it is live;
+	* otherwise, with none named, the review's only presence. A write is never
+	* refused for this. Call `extended` once the transaction commits. */
+	attribute(reviewId, surface, activityId) {
+		const live = this.live(reviewId);
+		const owner = activityId === void 0 ? live.length === 1 ? String(live[0].activity_id) : void 0 : live.some((row) => row.activity_id === activityId) ? activityId : void 0;
+		if (owner === void 0) return void 0;
+		this.db.prepare("UPDATE authoring_presences SET expires_at=?,surface=? WHERE activity_id=?").run(Date.now() + ACTIVITY_TTL_MS, surface, owner);
+		return owner;
+	}
+	/** Move the expiry timer after a committed `attribute`. */
+	extended(reviewId) {
+		this.scheduleExpiry(reviewId);
+		this.changed(reviewId);
+	}
+	update(reviewId, value) {
+		const input = activitySchema.parse(value);
+		const now = Date.now();
+		let activityId;
+		this.db.exec("BEGIN IMMEDIATE");
+		try {
+			this.assertReview?.(reviewId);
+			if (input.action === "begin") {
+				activityId = randomUUID();
+				const taken = new Set(this.live(reviewId).map((row) => Number(row.slot)));
+				let slot = 0;
+				while (taken.has(slot)) slot += 1;
+				this.db.prepare("INSERT INTO authoring_presences(activity_id,review_id,slot,started_at,expires_at,focus) VALUES(?,?,?,?,?,?)").run(activityId, reviewId, slot, now, now + ACTIVITY_TTL_MS, input.focus ? JSON.stringify(input.focus) : null);
+			} else {
+				activityId = input.activityId;
+				if (input.action === "end") this.db.prepare("DELETE FROM authoring_presences WHERE activity_id=? AND review_id=?").run(activityId, reviewId);
+				else if (this.db.prepare(`UPDATE authoring_presences SET expires_at=?${input.focus === void 0 ? "" : ",focus=?"}
+              WHERE activity_id=? AND review_id=? AND expires_at>?`).run(...[
+					now + 18e4,
+					...input.focus === void 0 ? [] : [input.focus === null ? null : JSON.stringify(input.focus)],
+					activityId,
+					reviewId,
+					now
+				]).changes === 0) throw new ReviewInputError("This activity ended or expired. Begin a new one.", 409);
+			}
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+		this.scheduleExpiry(reviewId);
+		this.changed(reviewId);
+		const result = this.read(reviewId);
+		if (input.action === "begin") result.activityId = activityId;
+		return result;
+	}
+	/** One timer per review, for its soonest-expiring presence. */
+	scheduleExpiry(reviewId) {
+		clearTimeout(this.timers.get(reviewId));
+		this.timers.delete(reviewId);
+		const next = this.db.prepare("SELECT MIN(expires_at) AS expires_at FROM authoring_presences WHERE review_id=? AND expires_at>?").get(reviewId, Date.now());
+		if (next?.expires_at === null || next?.expires_at === void 0) return;
+		const timer = setTimeout(() => {
+			this.scheduleExpiry(reviewId);
+			this.changed(reviewId);
+		}, Math.max(1, Number(next.expires_at) - Date.now()));
+		timer.unref?.();
+		this.timers.set(reviewId, timer);
+	}
+	/** Called when another database connection commits session changes. */
+	refresh() {
+		const ids = new Set(this.timers.keys());
+		for (const row of this.db.prepare("SELECT DISTINCT review_id FROM authoring_presences WHERE expires_at>?").all(Date.now())) ids.add(String(row.review_id));
+		for (const id of ids) {
+			this.scheduleExpiry(id);
+			this.changed(id);
+		}
+	}
+	/** The store deletes the session atomically with its review before notifying. */
+	deleted(reviewId) {
+		clearTimeout(this.timers.get(reviewId));
+		this.timers.delete(reviewId);
+		this.changed(reviewId);
+	}
+	close() {
+		this.listeners.clear();
+		this.workingListeners.clear();
+		for (const timer of this.timers.values()) clearTimeout(timer);
+		this.timers.clear();
+	}
+};
+/** A semantic selection, independent of comment/thread creation. */
+const AgentSelectionSchema = z.strictObject({
+	target: z.discriminatedUnion("kind", [z.strictObject({
+		kind: z.literal("text"),
+		quote: z.string(),
+		/** Where the quote is: characters `start` to `end` of the text of the
+		* review block `blockId`, which was `text` then. The block keeps its
+		* id across versions; comparing its text then and now finds the quote
+		* again, or tells that it changed. */
+		anchor: z.strictObject({
+			blockId: z.string().min(1).max(200),
+			start: z.number().int().nonnegative(),
+			end: z.number().int().positive(),
+			text: z.string().max(2e4)
+		}).refine((anchor) => anchor.start < anchor.end, "an empty anchor").optional()
+	}), z.strictObject({
+		kind: z.literal("code"),
+		path: z.string(),
+		side: z.enum(["base", "head"]),
+		startLine: z.number().int().positive(),
+		endLine: z.number().int().positive()
+	})]),
+	title: z.string().max(500),
+	detail: z.string().max(24e3).optional(),
+	revision: z.string().max(200).optional(),
+	selectedDiff: ReviewSelectedDiffSchema.optional(),
+	apiSource: ReviewApiSelectionSourceSchema.optional()
+});
+function selectionMarkdown(selection, sourceExcerpt = "", diffPaths) {
+	const target = selection.target;
+	if (selection.selectedDiff) return selectedDiffMarkdown(selection.selectedDiff, diffPaths);
+	if (target.kind === "text") return target.quote.split(/\r?\n/).map((line) => `> ${line}`).join("\n");
+	return [
+		`## ${selection.title}`,
+		selection.detail ?? "",
+		sourceExcerpt
+	].filter(Boolean).join("\n\n");
+}
+function selectedDiffMarkdown(diff, paths) {
+	const oldCount = diff.rows.filter((row) => row.kind !== "added").length;
+	const newCount = diff.rows.filter((row) => row.kind !== "deleted").length;
+	const lines = diff.rows.map((row) => `${row.kind === "added" ? "+" : row.kind === "deleted" ? "-" : " "}${row.text}`);
+	const fence = "`".repeat(Math.max(3, ...lines.flatMap((line) => [...line.matchAll(/`+/g)].map((match) => match[0].length + 1))));
+	return [
+		`Base: ${paths?.base ?? "a/"}`,
+		`Head: ${paths?.head ?? "b/"}`,
+		`Range: -${diff.oldStart},${oldCount} +${diff.newStart},${newCount}`,
+		"",
+		`${fence}diff`,
+		...lines,
+		fence
+	].join("\n");
+}
+//#endregion
+//#region src/ask/thread-state.ts
+const askAgentIds = [
+	"claude",
+	"codex",
+	"cursor",
+	"opencode",
+	"pi"
+];
+const permissionOptionSchema = z.object({
+	optionId: z.string(),
+	name: z.string(),
+	kind: z.enum([
+		"allow_once",
+		"allow_always",
+		"reject_once",
+		"reject_always"
+	])
+});
+/** What a question carries besides its text, as the thread shows it. An
+* image shows by name: its bytes go to the agent, not into the thread. */
+const askAttachmentSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("file"),
+	path: z.string()
+}), z.object({
+	kind: z.literal("image"),
+	name: z.string()
+})]);
+const askEntrySchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("user"),
+		id: z.string(),
+		text: z.string(),
+		/** When it was asked, in epoch milliseconds; unknown for a replayed one. */
+		at: z.number().optional(),
+		attachments: z.array(askAttachmentSchema).optional()
+	}),
+	z.object({
+		kind: z.literal("agent"),
+		id: z.string(),
+		text: z.string()
+	}),
+	z.object({
+		kind: z.literal("tool"),
+		id: z.string(),
+		title: z.string(),
+		toolKind: z.string(),
+		status: z.enum([
+			"pending",
+			"in_progress",
+			"completed",
+			"failed"
+		]),
+		/** The command it ran, or the file it opened. */
+		input: z.string().optional(),
+		/** The agent's own note on why, when it gives one. */
+		summary: z.string().optional(),
+		/** What came back, shortened. */
+		output: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("permission"),
+		id: z.string(),
+		title: z.string(),
+		toolKind: z.string(),
+		/** The command it would run, or the file it would open, when the title
+		* does not say. */
+		input: z.string().optional(),
+		options: z.array(permissionOptionSchema),
+		/** The chosen option, `cancelled`, or absent while the user decides. */
+		outcome: z.string().optional(),
+		/** Refused by Whiteboard's read-only policy, not by the user. */
+		automatic: z.boolean().optional()
+	}),
+	z.object({
+		kind: z.literal("notice"),
+		id: z.string(),
+		severity: z.string(),
+		title: z.string(),
+		description: z.string().optional()
+	})
+]);
+/** One of the agent's settings: its choices, and the one in use. */
+const askSelectSchema = z.object({
+	current: z.string(),
+	options: z.array(z.object({
+		value: z.string(),
+		name: z.string(),
+		description: z.string().optional()
+	}))
+});
+/** The settings a reviewer can pick: the model, and how hard it thinks. */
+const askChoiceKinds = ["model", "effort"];
+/** What the agent offers of each, when it offers it. */
+const askChoicesSchema = z.object({
+	model: askSelectSchema.optional(),
+	effort: askSelectSchema.optional()
+});
+/** The values picked, before the agent says what it offers. */
+const askPicksSchema = z.strictObject({
+	model: z.string().min(1).max(200).optional(),
+	effort: z.string().min(1).max(200).optional()
+});
+/** A slash command the agent takes, its skills among them. */
+const askCommandSchema = z.object({
+	name: z.string(),
+	description: z.string(),
+	/** What it takes after its name, when it takes anything. */
+	hint: z.string().optional()
+});
+/** What a question to the agent may carry besides text and file links. */
+const askAcceptsSchema = z.object({ image: z.boolean() });
+/** What an agent offers before anything is asked of it, as it last said. */
+const askOfferSchema = z.object({
+	choices: askChoicesSchema,
+	commands: z.array(askCommandSchema).optional(),
+	accepts: askAcceptsSchema.optional()
+});
+/** A question as the reviewer asks it: its text, the checkout files it
+* mentions, and any images. */
+const askQuestionSchema = z.strictObject({
+	text: z.string().trim().min(1).max(8e3),
+	/** Paths relative to the checkout's root. */
+	mentions: z.array(z.string().min(1).max(400)).max(20).optional(),
+	images: z.array(z.strictObject({
+		name: z.string().min(1).max(200),
+		mimeType: z.enum([
+			"image/png",
+			"image/jpeg",
+			"image/gif",
+			"image/webp"
+		]),
+		data: z.string().min(1).max(7e6)
+	})).max(4).optional()
+});
+/** How full the agent's context window is, and what the session cost. */
+const askUsageSchema = z.object({
+	used: z.number(),
+	size: z.number(),
+	cost: z.object({
+		amount: z.number(),
+		currency: z.string()
+	}).optional()
+});
+const statusSchema = z.enum([
+	"starting",
+	"running",
+	"waiting",
+	"idle",
+	"failed"
+]);
+/** Everything the Ask panel renders. A watcher gets it whole once, then
+* follows it through `AskChange`s. */
+const askThreadStateSchema = z.object({
+	id: z.string(),
+	agent: z.enum(askAgentIds),
+	agentName: z.string(),
+	status: statusSchema,
+	error: z.string().optional(),
+	/** The agent's login lapsed: the command that signs in again. */
+	signIn: z.string().optional(),
+	/** The mode that keeps the agent from changing files was accepted. */
+	readOnly: z.boolean(),
+	/** The agent edits and runs commands without asking. */
+	bypass: z.boolean(),
+	head: z.string(),
+	/** The checkout the agent works in. */
+	cwd: z.string(),
+	/** Absent until the agent says, or when it offers no choice. */
+	choices: askChoicesSchema.optional(),
+	/** Absent until the agent says, or when it takes none. */
+	commands: z.array(askCommandSchema).optional(),
+	accepts: askAcceptsSchema.optional(),
+	usage: askUsageSchema.optional(),
+	/** What the agent calls the conversation. */
+	title: z.string().optional(),
+	selection: z.object({
+		title: z.string(),
+		quote: z.string().optional()
+	}),
+	entries: z.array(askEntrySchema)
+});
+/** One change to a thread. Answer text arrives as `append`, so a streamed
+* token costs its own length, not the thread's. */
+const askChangeSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("set"),
+		status: statusSchema.optional(),
+		readOnly: z.boolean().optional(),
+		bypass: z.boolean().optional(),
+		choices: askChoicesSchema.optional(),
+		commands: z.array(askCommandSchema).optional(),
+		accepts: askAcceptsSchema.optional(),
+		usage: askUsageSchema.optional(),
+		title: z.string().optional(),
+		/** `null` clears the error; absent leaves it. */
+		error: z.string().nullable().optional(),
+		/** `null` clears it; absent leaves it. */
+		signIn: z.string().nullable().optional()
+	}),
+	z.object({
+		type: z.literal("add"),
+		entry: askEntrySchema
+	}),
+	z.object({
+		type: z.literal("entry"),
+		entry: askEntrySchema
+	}),
+	z.object({
+		type: z.literal("append"),
+		id: z.string(),
+		text: z.string()
+	}),
+	z.object({
+		type: z.literal("remove"),
+		ids: z.array(z.string())
+	})
+]);
+z.union([z.object({
+	seq: z.number().int().nonnegative(),
+	snapshot: askThreadStateSchema
+}), z.object({
+	seq: z.number().int().positive(),
+	change: askChangeSchema
+})]);
+/** The server and the panel both advance a thread with this, so they agree. */
+function applyAskChange(state, change) {
+	switch (change.type) {
+		case "set": {
+			const { error: _error, signIn: _signIn, ...rest } = state;
+			const next = {
+				...rest,
+				status: change.status ?? state.status,
+				readOnly: change.readOnly ?? state.readOnly,
+				bypass: change.bypass ?? state.bypass
+			};
+			const choices = change.choices ?? state.choices;
+			if (choices) next.choices = choices;
+			const commands = change.commands ?? state.commands;
+			if (commands) next.commands = commands;
+			const accepts = change.accepts ?? state.accepts;
+			if (accepts) next.accepts = accepts;
+			const usage = change.usage ?? state.usage;
+			if (usage) next.usage = usage;
+			const title = change.title ?? state.title;
+			if (title) next.title = title;
+			const error = change.error === void 0 ? state.error : change.error;
+			if (error) next.error = error;
+			const signIn = change.signIn === void 0 ? state.signIn : change.signIn;
+			if (signIn) next.signIn = signIn;
+			return next;
+		}
+		case "add": return {
+			...state,
+			entries: [...state.entries, change.entry]
+		};
+		case "entry": return {
+			...state,
+			entries: state.entries.map((entry) => entry.id === change.entry.id && entry.kind === change.entry.kind ? change.entry : entry)
+		};
+		case "remove": {
+			const ids = new Set(change.ids);
+			return {
+				...state,
+				entries: state.entries.filter((entry) => !ids.has(entry.id))
+			};
+		}
+		case "append": return {
+			...state,
+			entries: state.entries.map((entry) => entry.kind === "agent" && entry.id === change.id ? {
+				...entry,
+				text: entry.text + change.text
+			} : entry)
+		};
+	}
+}
+//#endregion
+//#region src/review-api/ask-history.ts
+/** A saved Ask conversation: its history entry, and how to reopen it. */
+const askRecordSchema = z.object({
+	id: z.string(),
+	agent: z.enum(askAgentIds),
+	/** What the agent calls it, else the first question. */
+	title: z.string(),
+	/** The first saved user question, independent of the agent's title. */
+	question: z.string().optional(),
+	selection: AgentSelectionSchema,
+	/** The commit the agent read. */
+	head: z.string(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).extend({
+	reviewId: z.string(),
+	/** The ACP session the agent keeps the transcript under. */
+	sessionId: z.string(),
+	/** The review version asked about; its pins recreate the checkout. */
+	version: z.number().int(),
+	cwd: z.string(),
+	/** What the panel showed last; absent until a turn ends or it closes. */
+	entries: z.array(askEntrySchema).optional(),
+	/** The agent edits and runs commands without asking. */
+	bypass: z.boolean().optional()
+});
+const rowSchema = z.object({
+	id: z.string(),
+	review_id: z.string(),
+	agent: z.string(),
+	session_id: z.string(),
+	version: z.number(),
+	head: z.string(),
+	cwd: z.string(),
+	selection: z.string(),
+	title: z.string(),
+	created_at: z.string(),
+	updated_at: z.string(),
+	entries: z.string().nullable(),
+	bypass: z.number()
+}).transform((row) => askRecordSchema.parse({
+	id: row.id,
+	reviewId: row.review_id,
+	agent: row.agent,
+	sessionId: row.session_id,
+	version: row.version,
+	head: row.head,
+	cwd: row.cwd,
+	selection: JSON.parse(row.selection),
+	title: row.title,
+	createdAt: row.created_at,
+	updatedAt: row.updated_at,
+	entries: row.entries === null ? void 0 : JSON.parse(row.entries),
+	bypass: row.bypass === 1
+}));
+/** Saved Ask conversations, per review. Shared reviews are not in
+* `reviews`, so there is no foreign key; deleting a review deletes its rows. */
+var AskHistory = class {
+	db;
+	constructor(db) {
+		this.db = db;
+		db.exec(`CREATE TABLE IF NOT EXISTS ask_conversations(
+      id TEXT PRIMARY KEY,
+      review_id TEXT NOT NULL,
+      agent TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      version INTEGER NOT NULL,
+      head TEXT NOT NULL,
+      cwd TEXT NOT NULL,
+      selection TEXT NOT NULL,
+      title TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      entries TEXT,
+      bypass INTEGER NOT NULL DEFAULT 0,
+      UNIQUE(agent, session_id));
+    CREATE INDEX IF NOT EXISTS ask_conversations_review ON ask_conversations(review_id, updated_at);`);
+		if (!db.prepare("PRAGMA table_info(ask_conversations)").all().some((column) => String(column.name) === "bypass")) db.exec("ALTER TABLE ask_conversations ADD COLUMN bypass INTEGER NOT NULL DEFAULT 0");
+		db.exec("CREATE TABLE IF NOT EXISTS ask_agent_offers(agent TEXT PRIMARY KEY, offer TEXT NOT NULL)");
+		db.exec("CREATE TABLE IF NOT EXISTS ask_agent_model_offers(agent TEXT NOT NULL, model TEXT NOT NULL, offer TEXT NOT NULL, PRIMARY KEY(agent, model))");
+	}
+	save(record) {
+		this.db.prepare(`INSERT OR REPLACE INTO ask_conversations(id,review_id,agent,session_id,version,head,cwd,selection,title,created_at,updated_at,bypass)
+        VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`).run(record.id, record.reviewId, record.agent, record.sessionId, record.version, record.head, record.cwd, JSON.stringify(record.selection), record.title, record.createdAt, record.updatedAt, record.bypass ? 1 : 0);
+	}
+	/** Whether reopening the conversation bypasses permissions. */
+	setBypass(id, bypass) {
+		this.db.prepare("UPDATE ask_conversations SET bypass=? WHERE id=?").run(bypass ? 1 : 0, id);
+	}
+	/** Points a conversation at a new session, when its agent could not
+	* reopen the one it had. */
+	updateSession(id, sessionId) {
+		this.db.prepare("UPDATE ask_conversations SET session_id=? WHERE id=?").run(sessionId, id);
+	}
+	/** Keeps what the panel shows, so a reopen need not wait on the agent. */
+	saveEntries(id, entries) {
+		this.db.prepare("UPDATE ask_conversations SET entries=? WHERE id=?").run(JSON.stringify(entries), id);
+	}
+	/** The agent's name for the conversation, which the list shows. */
+	rename(id, title) {
+		this.db.prepare("UPDATE ask_conversations SET title=? WHERE id=?").run(title.slice(0, 200), id);
+	}
+	saveOffer(agent, offer) {
+		this.db.prepare("INSERT OR REPLACE INTO ask_agent_offers(agent, offer) VALUES(?, ?)").run(agent, JSON.stringify(offer));
+		this.saveModelOffer(agent, offer);
+	}
+	/** Keeps what the agent offers with the offer's model, without making
+	* it what the agent offered last. */
+	saveModelOffer(agent, offer) {
+		const model = offer.choices.model?.current;
+		if (!model) return;
+		this.db.prepare("INSERT OR REPLACE INTO ask_agent_model_offers(agent, model, offer) VALUES(?, ?, ?)").run(agent, model, JSON.stringify(offer));
+	}
+	/** What the agent offered last, or last with the model given. */
+	offer(agent, model) {
+		const row = z.object({ offer: z.string() }).safeParse(model === void 0 ? this.db.prepare("SELECT offer FROM ask_agent_offers WHERE agent=?").get(agent) : this.db.prepare("SELECT offer FROM ask_agent_model_offers WHERE agent=? AND model=?").get(agent, model)).data;
+		return row && askOfferSchema.safeParse(JSON.parse(row.offer)).data;
+	}
+	touch(id, at = (/* @__PURE__ */ new Date()).toISOString()) {
+		this.db.prepare("UPDATE ask_conversations SET updated_at=? WHERE id=?").run(at, id);
+	}
+	/** Newest first. */
+	list(reviewId) {
+		return this.db.prepare("SELECT * FROM ask_conversations WHERE review_id=? ORDER BY updated_at DESC").all(reviewId).map((row) => {
+			const { reviewId: _reviewId, sessionId: _sessionId, version: _version, cwd: _cwd, entries, bypass: _bypass, ...entry } = rowSchema.parse(row);
+			const question = entries?.find((entry) => entry.kind === "user")?.text;
+			if (question?.trim()) entry.question = question;
+			return entry;
+		});
+	}
+	get(id) {
+		const row = this.db.prepare("SELECT * FROM ask_conversations WHERE id=?").get(id);
+		return row ? rowSchema.parse(row) : void 0;
+	}
+	delete(id) {
+		this.db.prepare("DELETE FROM ask_conversations WHERE id=?").run(id);
+	}
+};
+//#endregion
+//#region src/review-api/origin.ts
+const pullRequestUrl = z.string().regex(/^https:\/\/[a-z0-9.-]+\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/[1-9]\d*$/, "Use a canonical GitHub PR URL: https://github.com/owner/repository/pull/123, or the same path on a GitHub Enterprise host.").refine((url) => Number.isSafeInteger(Number(url.split("/").at(-1))), "PR number is too large.");
+/** One key per PR: GitHub owner and repository names are case-insensitive,
+* and the URL pattern admits only ASCII, so lowercasing is canonical. */
+function pullRequestKey(url) {
+	return url.toLowerCase();
+}
+/** Omission preserves identity; null detaches it without changing import metadata. */
+function setPullRequest(snapshot, url) {
+	if (url === void 0) return;
+	if (url === null) {
+		if (snapshot.origin) {
+			delete snapshot.origin.pullRequestUrl;
+			delete snapshot.origin.pullRequestNumber;
+		}
+		return;
+	}
+	snapshot.origin = {
+		...snapshot.origin,
+		pullRequestUrl: url,
+		pullRequestNumber: Number(url.split("/").at(-1))
+	};
+}
+//#endregion
+//#region src/review-api/store-schema.ts
+function initializeReviewStoreSchema(db) {
+	db.exec(`
+    PRAGMA journal_mode=WAL;
+    PRAGMA foreign_keys=ON;
+    CREATE TABLE IF NOT EXISTS reviews(id TEXT PRIMARY KEY, version INTEGER NOT NULL, next_id INTEGER NOT NULL);
+    CREATE TABLE IF NOT EXISTS versions(review_id TEXT REFERENCES reviews(id), version INTEGER, snapshot TEXT NOT NULL,
+      PRIMARY KEY(review_id,version));
+    DROP TABLE IF EXISTS receipts;
+    CREATE TABLE IF NOT EXISTS review_attention(review_id TEXT PRIMARY KEY REFERENCES reviews(id), viewed_at TEXT, dismissed_at TEXT);
+    CREATE TABLE IF NOT EXISTS repositories(id TEXT PRIMARY KEY, path TEXT NOT NULL UNIQUE, name TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS resources(id TEXT PRIMARY KEY, repository_id TEXT NOT NULL REFERENCES repositories(id),
+      kind TEXT NOT NULL, mime_type TEXT NOT NULL, data BLOB NOT NULL);
+    CREATE TABLE IF NOT EXISTS review_coverage(review_id TEXT REFERENCES reviews(id), file TEXT, fingerprint TEXT NOT NULL, coverage TEXT NOT NULL,
+      PRIMARY KEY(review_id,file));
+    DROP TABLE IF EXISTS review_viewed;
+    CREATE TABLE IF NOT EXISTS comparison_stats(identity TEXT PRIMARY KEY, stats TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS server_identity(one INTEGER PRIMARY KEY CHECK(one=1), id TEXT NOT NULL);
+    DROP TABLE IF EXISTS authoring_drafts;
+  `);
+}
+//#endregion
+//#region src/review-api/store.ts
+const reviewId = z.string().min(1);
+/** There is one scratchpad. Its id is fixed so a skill can name it. */
+const SCRATCHPAD_ID = SCRATCHPAD_REVIEW_ID;
+const DIAGRAM_TYPES = /* @__PURE__ */ new Set([
+	"sequence",
+	"flow_diagram",
+	"call_stack_diff",
+	"database_lens",
+	"software_map"
+]);
+const SCRATCHPAD_TITLE = "Scratchpad";
+const activityId = z.string().min(1).optional().describe("The activityId from review_activity_begin: your courier draws this edit. Never rejects a write.");
+const commandSchema = z.strictObject({ operation: z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("delete"),
+		reviewId
+	}),
+	z.strictObject({
+		type: z.literal("attention"),
+		reviewId,
+		action: z.enum([
+			"view",
+			"dismiss",
+			"restore"
+		])
+	}),
+	z.strictObject({
+		type: z.literal("create"),
+		/** Required unless pullRequestUrl alone names the source; then the PR title. */
+		title: z.string().trim().min(1).optional(),
+		target: reviewTargetSchema.optional(),
+		pullRequestUrl: pullRequestUrl.optional(),
+		/** With pullRequestUrl and no target: the checkout to fetch the PR into. */
+		repositoryId: z.string().min(1).optional().describe("Only with pullRequestUrl and no target: the registered checkout to fetch the PR into. Default: the existing review's, else the first registered checkout with a remote for the PR's repository."),
+		/** Return the existing review for pullRequestUrl instead of creating one. */
+		reuseExisting: z.boolean().optional().describe("Default true: return the existing review for pullRequestUrl. false creates a separate review."),
+		/** The one scratchpad: no target, no pins; every reference names its own. */
+		kind: z.literal("scratchpad").optional()
+	}),
+	z.strictObject({
+		type: z.literal("set_target"),
+		reviewId,
+		target: reviewTargetSchema,
+		pullRequestUrl: pullRequestUrl.nullable().optional()
+	}),
+	z.strictObject({
+		type: z.literal("edit"),
+		reviewId,
+		edit: editSchema,
+		activityId
+	}),
+	z.strictObject({
+		type: z.literal("lens_edit"),
+		reviewId,
+		edit: lensEditSchema,
+		activityId
+	}),
+	z.strictObject({
+		type: z.literal("rename"),
+		reviewId,
+		title: z.string().trim().min(1)
+	}),
+	z.strictObject({
+		type: z.literal("restore"),
+		reviewId,
+		version: z.number().int().nonnegative()
+	})
+]) });
+/** One instance owned by the desktop server. All writers go through execute().
+* The queue includes async validation; SQLite transactions contain only writes.
+* This prototype uses a new, explicitly supplied database, never an existing profile.
+*/
+var ReviewStore = class {
+	providers;
+	activity;
+	askHistory;
+	db;
+	pending = Promise.resolve();
+	closing = false;
+	liveSources = /* @__PURE__ */ new Map();
+	refreshTimer;
+	refreshSubscribers = 0;
+	watchWorktrees() {
+		this.refreshSubscribers++;
+		this.refreshTimer ??= setInterval(() => {
+			this.refreshWorktrees();
+		}, 1e3);
+		this.refreshTimer.unref();
+		return () => {
+			if (--this.refreshSubscribers === 0) {
+				clearInterval(this.refreshTimer);
+				this.refreshTimer = void 0;
+			}
+		};
+	}
+	async projectLiveSource(snapshot, current = snapshot) {
+		if (snapshot.target?.kind !== "worktree") {
+			await this.providers.sourcePins?.(snapshot);
+			const unavailable = await this.providers.unavailableAnchors?.(snapshot) ?? [];
+			const stale = [.../* @__PURE__ */ new Set([...snapshot.staleSources ?? [], ...unavailable])];
+			const staleChanged = JSON.stringify(stale) !== JSON.stringify(current.staleSources ?? []);
+			if (!current.sourceUnavailable && !staleChanged) return current;
+			const projected = {
+				...current,
+				sourceUnavailable: void 0
+			};
+			if (stale.length) projected.staleSources = stale;
+			else delete projected.staleSources;
+			return projected;
+		}
+		const { pins } = await this.providers.resolveTarget(snapshot.target, current.pins);
+		if (JSON.stringify(current.pins) === JSON.stringify(pins) && !current.sourceUnavailable) return current;
+		return this.providers.projectSource ? this.providers.projectSource(snapshot, pins) : {
+			...snapshot,
+			pins,
+			sourceUnavailable: void 0
+		};
+	}
+	refreshPending;
+	/** Refresh source state without writing authored document versions. Serialized with edits. */
+	refreshWorktrees() {
+		if (this.closing || !this.providers.resolveTarget) return Promise.resolve();
+		if (this.refreshPending) return this.refreshPending;
+		const run = this.pending.then(async () => {
+			for (const summary of this.list()) {
+				const snapshot = this.read(summary.reviewId, summary.version);
+				try {
+					const live = this.liveSources.get(summary.reviewId);
+					const last = live?.version === snapshot.version ? live : snapshot;
+					const previous = last.pins;
+					const projected = await this.projectLiveSource(snapshot, last);
+					if (projected === last) continue;
+					this.liveSources.set(snapshot.reviewId, projected);
+					if (JSON.stringify(previous) !== JSON.stringify(projected.pins) || JSON.stringify(last.staleSources ?? []) !== JSON.stringify(projected.staleSources ?? []) || last.sourceUnavailable) this.notify({
+						reviewId: snapshot.reviewId,
+						version: snapshot.version
+					});
+				} catch (error) {
+					if (error instanceof ReviewInputError && error.status === 404) {
+						const last = this.read(snapshot.reviewId);
+						if (!last.sourceUnavailable) {
+							this.liveSources.set(snapshot.reviewId, {
+								...last,
+								sourceUnavailable: true
+							});
+							this.notify({
+								reviewId: snapshot.reviewId,
+								version: snapshot.version
+							});
+						}
+					}
+				}
+			}
+		});
+		this.pending = run.catch(() => {});
+		this.refreshPending = run.finally(() => {
+			this.refreshPending = void 0;
+		});
+		return this.refreshPending;
+	}
+	listeners = /* @__PURE__ */ new Set();
+	catalogListeners = /* @__PURE__ */ new Set();
+	externalChanges;
+	observedDataVersion;
+	observedVersions = /* @__PURE__ */ new Map();
+	subscribeCatalog(listener) {
+		this.catalogListeners.add(listener);
+		return () => {
+			this.catalogListeners.delete(listener);
+		};
+	}
+	/** For a host whose listing changed without the store: a preference flip. */
+	invalidateCatalog() {
+		for (const listener of this.catalogListeners) try {
+			listener();
+		} catch {}
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	constructor(databasePath, providers) {
+		this.providers = providers;
+		this.db = new DatabaseSync(databasePath, { timeout: 5e3 });
+		initializeReviewStoreSchema(this.db);
+		this.activity = new ReviewActivity(this.db, (id) => this.assertExists(id));
+		this.askHistory = new AskHistory(this.db);
+		this.observedDataVersion = this.dataVersion();
+		this.observedVersions = this.currentVersions();
+		this.externalChanges = setInterval(() => this.refreshExternalChanges(), 250);
+		this.externalChanges.unref();
+	}
+	dataVersion() {
+		return Number(this.db.prepare("PRAGMA data_version").get().data_version);
+	}
+	currentVersions() {
+		return new Map(this.db.prepare("SELECT id,version FROM reviews").all().map((row) => [String(row.id), Number(row.version)]));
+	}
+	refreshExternalChanges() {
+		const version = this.dataVersion();
+		if (version === this.observedDataVersion) return;
+		this.observedDataVersion = version;
+		const current = this.currentVersions();
+		const previous = this.observedVersions;
+		this.observedVersions = current;
+		for (const [reviewId, savedVersion] of current) if (previous.get(reviewId) !== savedVersion) this.notify({
+			reviewId,
+			version: savedVersion
+		});
+		for (const [reviewId, savedVersion] of previous) if (!current.has(reviewId)) {
+			this.activity.deleted(reviewId);
+			this.notify({
+				reviewId,
+				version: savedVersion,
+				deleted: true
+			});
+		}
+		this.activity.refresh();
+		for (const listener of this.catalogListeners) try {
+			listener();
+		} catch {}
+	}
+	/** Reader progress never creates a document version or authoring event. */
+	viewedCoverage(reviewId) {
+		this.assertExists(reviewId);
+		return new Map(this.db.prepare("SELECT file,fingerprint,coverage FROM review_coverage WHERE review_id=?").all(reviewId).map((row) => [String(row.file), {
+			fingerprint: String(row.fingerprint),
+			coverage: coverageSchema.parse(JSON.parse(String(row.coverage)))
+		}]));
+	}
+	updateViewedCoverage(reviewId, files, viewed) {
+		this.assertExists(reviewId);
+		this.db.exec("BEGIN IMMEDIATE");
+		try {
+			const current = this.viewedCoverage(reviewId);
+			for (const file of files) {
+				const previous = current.get(file.path);
+				const coverage = updateCoverage(previous?.fingerprint === file.fingerprint ? previous.coverage : emptyCoverage(), file.scope, viewed);
+				this.db.prepare("INSERT OR REPLACE INTO review_coverage(review_id,file,fingerprint,coverage) VALUES(?,?,?,?)").run(reviewId, file.path, file.fingerprint, JSON.stringify(coverage));
+			}
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	repositoryGroups = /* @__PURE__ */ new Map();
+	repositoryGroup(root) {
+		if (this.repositoryGroups.has(root)) return this.repositoryGroups.get(root);
+		const context = resolveRepoContextSync(root);
+		if (!context) return void 0;
+		const group = context.githubSlug ? {
+			key: `remote:https://github.com/${context.githubSlug.toLowerCase()}.git`,
+			label: context.githubSlug
+		} : {
+			key: `git:${context.commonDir}`,
+			label: path.basename(path.dirname(context.commonDir))
+		};
+		this.repositoryGroups.set(root, group);
+		return group;
+	}
+	registerRepository(root) {
+		this.db.prepare("INSERT OR IGNORE INTO repositories(id,path,name) VALUES(?,?,?)").run(randomUUID(), root, root.split(/[\\/]/).at(-1));
+		const row = this.db.prepare("SELECT id,name FROM repositories WHERE path=?").get(root);
+		return {
+			id: String(row.id),
+			name: String(row.name)
+		};
+	}
+	unregisterRepository(id) {
+		this.db.prepare(`DELETE FROM repositories WHERE id=?
+      AND NOT EXISTS (SELECT 1 FROM versions WHERE instr(snapshot, ?) > 0)
+      AND NOT EXISTS (SELECT 1 FROM resources WHERE repository_id=?)`).run(id, `"repositoryId":${JSON.stringify(id)}`, id);
+	}
+	/** Registered checkouts, oldest registration first. */
+	repositories() {
+		return this.db.prepare("SELECT id,path FROM repositories ORDER BY rowid").all().map((row) => ({
+			id: String(row.id),
+			path: String(row.path)
+		}));
+	}
+	repositoryPath(id) {
+		const row = this.db.prepare("SELECT path FROM repositories WHERE id=?").get(id);
+		if (!row) throw new ReviewInputError("Repository is not registered.", 404);
+		return String(row.path);
+	}
+	putResource(id, repositoryId, kind, mimeType, data) {
+		this.db.prepare("INSERT OR IGNORE INTO resources(id,repository_id,kind,mime_type,data) VALUES(?,?,?,?,?)").run(id, repositoryId, kind, mimeType, data);
+		const saved = this.resource(id);
+		if (saved.repositoryId !== repositoryId || saved.kind !== kind || saved.mimeType !== mimeType || !Buffer.from(saved.data).equals(data)) throw new ReviewInputError("Resource ID was already used for different content.", 409);
+		return {
+			id,
+			kind,
+			mimeType
+		};
+	}
+	resource(id) {
+		const row = this.db.prepare("SELECT * FROM resources WHERE id=?").get(id);
+		if (!row) throw new ReviewInputError("Resource not found.", 404);
+		return {
+			id,
+			repositoryId: String(row.repository_id),
+			kind: String(row.kind),
+			mimeType: String(row.mime_type),
+			data: row.data
+		};
+	}
+	async close() {
+		this.closing = true;
+		clearInterval(this.externalChanges);
+		clearInterval(this.refreshTimer);
+		await this.pending;
+		this.listeners.clear();
+		this.catalogListeners.clear();
+		this.activity.close();
+		this.db.close();
+	}
+	/** Stable across restarts; the first host on a new store chooses it. */
+	serverId() {
+		const read = () => this.db.prepare("SELECT id FROM server_identity").get()?.id;
+		let id = read();
+		if (id === void 0) {
+			this.db.prepare("INSERT OR IGNORE INTO server_identity(one,id) VALUES(1,?)").run(randomUUID());
+			id = read();
+		}
+		return String(id);
+	}
+	resetServerId() {
+		const id = randomUUID();
+		this.db.prepare("INSERT OR REPLACE INTO server_identity(one,id) VALUES(1,?)").run(id);
+		return id;
+	}
+	/** The 404 check alone, without loading a snapshot. */
+	assertExists(id) {
+		if (!this.db.prepare("SELECT 1 FROM reviews WHERE id=?").get(id)) throw new ReviewInputError("Review not found. If this is an old Whiteboard review, ask your agent to migrate your old Whiteboard reviews.", 404);
+	}
+	read(id, version) {
+		const row = version === void 0 ? this.db.prepare("SELECT snapshot FROM versions JOIN reviews ON reviews.id=review_id AND reviews.version=versions.version WHERE reviews.id=?").get(id) : this.db.prepare("SELECT snapshot FROM versions WHERE review_id=? AND version=?").get(id, version);
+		if (!row) {
+			this.assertExists(id);
+			throw new ReviewInputError("Review version not found.", 404);
+		}
+		const snapshot = JSON.parse(String(row.snapshot));
+		const { document, lenses } = liftFileLenses(migrateStoredDocument(snapshot.document));
+		snapshot.document = document;
+		if (snapshot.lenses) snapshot.lenses = migrateStoredLenses(snapshot.lenses);
+		if (lenses.length) snapshot.lenses = [...snapshot.lenses ?? [], ...lenses];
+		if (snapshot.pins) snapshot.target ??= {
+			kind: "commits",
+			repositoryId: snapshot.pins.repositoryId,
+			base: snapshot.pins.base,
+			head: snapshot.pins.head
+		};
+		const live = version === void 0 ? this.liveSources.get(id) : void 0;
+		if (live?.version === snapshot.version) return structuredClone(live);
+		return snapshot;
+	}
+	setDiffStats(pins, stats, mode = "structural") {
+		if (this.closing) return;
+		this.db.prepare("INSERT OR REPLACE INTO comparison_stats(identity, stats) VALUES (?, ?)").run(JSON.stringify([pins, mode]), JSON.stringify(stats));
+		for (const listener of this.catalogListeners) try {
+			listener();
+		} catch {}
+	}
+	/** Managed records are discoverable even if their preparation stamp was lost. */
+	tutorialIds() {
+		return this.db.prepare(`SELECT reviews.id FROM reviews JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version WHERE json_extract(versions.snapshot,'$.origin.tutorial') = 1`).all().map((row) => String(row.id));
+	}
+	list(mode = "structural") {
+		return this.summaries(mode);
+	}
+	/** One review's catalog entry, as review_list shows it. */
+	summary(id) {
+		return this.summaries("structural", id)[0];
+	}
+	summaries(mode, id) {
+		const reviews = this.db.prepare(`SELECT json_remove(versions.snapshot,'$.document') AS summary,
+          (SELECT json_extract(first.snapshot,'$.createdAt') FROM versions AS first WHERE first.review_id=reviews.id ORDER BY first.version LIMIT 1) AS first_created_at,
+          review_attention.viewed_at, review_attention.dismissed_at, repositories.name AS repository_name, repositories.path AS repository_path
+        FROM reviews
+        JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+        LEFT JOIN review_attention ON review_attention.review_id=reviews.id
+        LEFT JOIN repositories ON repositories.id=json_extract(versions.snapshot,'$.pins.repositoryId')
+        WHERE COALESCE(json_extract(versions.snapshot,'$.origin.tutorial'), 0) = 0
+        ${id === void 0 ? "" : "AND reviews.id=?"}
+        ORDER BY reviews.rowid`).all(...id === void 0 ? [] : [id]).map((row) => {
+			const summary = JSON.parse(String(row.summary));
+			if (summary.pins) summary.target ??= {
+				kind: "commits",
+				repositoryId: summary.pins.repositoryId,
+				base: summary.pins.base,
+				head: summary.pins.head
+			};
+			const live = this.liveSources.get(summary.reviewId);
+			if (live?.version === summary.version && summary.target?.kind === "worktree") summary.pins = live.pins;
+			const listed = {
+				...summary,
+				firstCreatedAt: row.first_created_at ? String(row.first_created_at) : void 0,
+				repositoryPath: row.repository_path ? String(row.repository_path) : void 0,
+				repositoryGroup: row.repository_path ? this.repositoryGroup(String(row.repository_path)) : void 0,
+				repositoryName: row.repository_name ? String(row.repository_name) : summary.pins?.repositoryId ?? "",
+				viewedAt: row.viewed_at ? String(row.viewed_at) : null,
+				dismissedAt: row.dismissed_at ? String(row.dismissed_at) : null,
+				working: this.activity.isWorking(summary.reviewId)
+			};
+			if (summary.kind === "scratchpad") listed.contents = this.scratchpadContents();
+			return listed;
+		});
+		return this.withDiffStats(reviews, mode);
+	}
+	/** Local and imported summaries use the same persisted, mode-specific counts. */
+	withDiffStats(reviews, mode = "structural") {
+		const stats = new Map(this.db.prepare("SELECT identity, stats FROM comparison_stats").all().map((row) => [String(row.identity), JSON.parse(String(row.stats))]));
+		return reviews.map((review) => ({
+			...review,
+			diffStats: review.pins ? stats.get(JSON.stringify([review.pins, mode])) ?? null : null
+		}));
+	}
+	/** What the pad holds, for its Home card: blocks, and the diagrams among them. */
+	scratchpadContents() {
+		const blocks = elements(this.read(SCRATCHPAD_ID).document).filter((element) => !isUnit(element));
+		return {
+			blocks: blocks.length,
+			diagrams: blocks.filter((block) => DIAGRAM_TYPES.has(block.type)).length
+		};
+	}
+	/** The one scratchpad, made on first use. A host that loses the race to
+	* another on the same home finds it made. */
+	async ensureScratchpad() {
+		if (this.has(SCRATCHPAD_ID)) return;
+		try {
+			await this.execute({ operation: {
+				type: "create",
+				title: SCRATCHPAD_TITLE,
+				kind: "scratchpad"
+			} });
+		} catch (error) {
+			if (!this.has(SCRATCHPAD_ID)) throw error;
+		}
+	}
+	history(id) {
+		return this.db.prepare("SELECT version,json_extract(snapshot,'$.title') AS title,json_extract(snapshot,'$.createdAt') AS created_at FROM versions WHERE review_id=? ORDER BY version").all(id).map((row) => ({
+			version: Number(row.version),
+			title: String(row.title),
+			createdAt: String(row.created_at)
+		}));
+	}
+	inspect(id, targetId, version) {
+		return inspectSnapshot(this.read(id, version), targetId);
+	}
+	/** The host can seed a managed document; transport callers only supply a command. */
+	execute(input, initial) {
+		if (this.closing) return Promise.reject(/* @__PURE__ */ new Error("Review store is closing."));
+		const command = commandSchema.parse(input);
+		if (initial && command.operation.type !== "create") throw new ReviewInputError("Initial content requires a create command.");
+		const pullRequest = this.startPullRequest(command);
+		pullRequest?.catch(() => {});
+		const run = this.pending.then(async () => {
+			const op = command.operation;
+			if (op.type !== "create" && op.type !== "edit" && op.type !== "lens_edit" && op.type !== "restore" && this.read(op.reviewId).kind === "scratchpad") throw new ReviewInputError("The scratchpad has no lifecycle, title or pins of its own.", 409);
+			if (op.type === "create" && op.kind === "scratchpad") {
+				if (op.target) throw new ReviewInputError("A scratchpad has no target of its own.");
+				if (this.has(SCRATCHPAD_ID)) throw new ReviewInputError("The scratchpad already exists.", 409);
+			} else if (op.type === "create") {
+				if (!op.target && !op.pullRequestUrl) throw new ReviewInputError("Supply a target or a pullRequestUrl.");
+				if (op.repositoryId && op.target) throw new ReviewInputError("A checkout for the PR applies only to a create from pullRequestUrl alone; name it in the target instead.");
+				if (!op.title && op.target) throw new ReviewInputError("Supply a title.");
+			}
+			const requestedTarget = op.type === "create" || op.type === "set_target" ? op.target : void 0;
+			const fromPullRequest = await pullRequest;
+			const resolvedTarget = requestedTarget ? await (this.providers.resolveTarget?.(requestedTarget) ?? namedCommits(requestedTarget)) : fromPullRequest;
+			if (requestedTarget && !resolvedTarget) throw new ReviewInputError("Review targets are unavailable.");
+			if (op.type === "create" && op.pullRequestUrl && op.reuseExisting !== false) {
+				const [found, ...others] = this.reviewsForPullRequest(op.pullRequestUrl);
+				if (found) return this.existingReview(found, others, resolvedTarget.pins);
+			}
+			if (op.type === "delete") {
+				const result = {
+					reviewId: op.reviewId,
+					version: this.read(op.reviewId).version,
+					deleted: true
+				};
+				this.commitCommand(result, () => {
+					for (const table of [
+						"ask_conversations",
+						"authoring_presences",
+						"review_coverage",
+						"review_attention",
+						"versions"
+					]) this.db.prepare(`DELETE FROM ${table} WHERE review_id=?`).run(op.reviewId);
+					this.db.prepare("DELETE FROM reviews WHERE id=?").run(op.reviewId);
+				}, () => this.assertMutation(op.reviewId, result.version));
+				return result;
+			}
+			if (op.type === "attention") {
+				const result = {
+					reviewId: op.reviewId,
+					version: this.read(op.reviewId).version,
+					attention: true
+				};
+				this.commitCommand(result, () => {
+					this.db.prepare("INSERT OR IGNORE INTO review_attention(review_id) VALUES(?)").run(op.reviewId);
+					if (op.action === "view") this.db.prepare("UPDATE review_attention SET viewed_at=? WHERE review_id=?").run((/* @__PURE__ */ new Date()).toISOString(), op.reviewId);
+					else this.db.prepare("UPDATE review_attention SET dismissed_at=? WHERE review_id=?").run(op.action === "dismiss" ? (/* @__PURE__ */ new Date()).toISOString() : null, op.reviewId);
+				});
+				return result;
+			}
+			const id = op.type !== "create" ? op.reviewId : op.kind === "scratchpad" ? SCRATCHPAD_ID : randomUUID();
+			const previous = op.type === "create" ? void 0 : this.read(id);
+			let snapshot = op.type === "create" ? createdSnapshot(id, op, resolvedTarget, fromPullRequest?.title) : structuredClone(previous);
+			delete snapshot.sourceUnavailable;
+			delete snapshot.lastEdit;
+			let nextId = previous ? Number(this.db.prepare("SELECT next_id FROM reviews WHERE id=?").get(id).next_id) : 0;
+			let applied;
+			let lensTarget;
+			if ((op.type === "create" || op.type === "set_target") && this.providers.headBranch) {
+				const pins = resolvedTarget?.pins ?? snapshot.pins;
+				if (pins) {
+					const headRef = requestedTarget?.kind === "commits" ? requestedTarget.head : void 0;
+					const branch = await this.providers.headBranch(pins, headRef);
+					snapshot.origin = {
+						...snapshot.origin,
+						branch
+					};
+				}
+			}
+			switch (op.type) {
+				case "create":
+					if (initial) {
+						snapshot.document = documentSchema.parse(initial.document);
+						snapshot.origin = {
+							...snapshot.origin,
+							...structuredClone(initial.origin)
+						};
+						for (const block of snapshot.document) assignFreshIds(block, (prefix) => `${prefix}-${++nextId}`);
+					}
+					setPullRequest(snapshot, op.pullRequestUrl);
+					break;
+				case "rename":
+					snapshot.title = op.title;
+					break;
+				case "set_target":
+					setPullRequest(snapshot, op.pullRequestUrl ?? (op.pullRequestUrl === null || snapshot.pins?.repositoryId !== resolvedTarget.pins.repositoryId ? null : void 0));
+					snapshot.staleSources = [];
+					snapshot.target = resolvedTarget.target;
+					snapshot.pins = resolvedTarget.pins;
+					break;
+				case "restore":
+					snapshot = this.read(id, op.version);
+					delete snapshot.lastEdit;
+					break;
+				case "lens_edit": {
+					if (snapshot.kind === "scratchpad") throw new ReviewInputError("The scratchpad has no changes of its own to lens.", 409);
+					const lenses = snapshot.lenses ?? [];
+					const lens = applyLensEdit(lenses, op.edit, () => `lens-${++nextId}`);
+					if (lenses.length) snapshot.lenses = lenses;
+					else delete snapshot.lenses;
+					lensTarget = {
+						targetId: lens.id,
+						type: "lens"
+					};
+					snapshot.lastEdit = {
+						type: op.edit.type,
+						targetId: lens.id,
+						blockId: lens.id,
+						kind: "lens",
+						...op.edit.type === "update" && { fields: Object.keys(op.edit).filter((key) => key !== "type" && key !== "targetId") }
+					};
+					break;
+				}
+				case "edit":
+					applied = applyEdit(snapshot.document, op.edit, (prefix) => `${prefix}-${++nextId}`, { placement: snapshot.kind === "scratchpad" ? "first" : "last" });
+					snapshot.lastEdit = summarizeEdit(op.edit, applied, previous.document, snapshot.document);
+					if (snapshot.staleSources?.length) {
+						const oldSources = new Map(sourceReferences(previous.document).map((item) => [item.id, JSON.stringify(item.source)]));
+						const newSources = new Map(sourceReferences(snapshot.document).map((item) => [item.id, JSON.stringify(item.source)]));
+						snapshot.staleSources = snapshot.staleSources.filter((id) => oldSources.get(id) === newSources.get(id) && newSources.has(id));
+					}
+			}
+			if (snapshot.target?.kind === "worktree" && op.type !== "restore" && !resolvedTarget) snapshot = await this.projectLiveSource(snapshot);
+			checkReferences(snapshot.document);
+			if (snapshot.pins && (!previous || JSON.stringify(previous.pins) !== JSON.stringify(snapshot.pins))) await this.providers.validatePins(snapshot.pins);
+			const warnings = await this.validateExternal(snapshot, previous, op.type === "set_target");
+			snapshot.version = previous ? previous.version + 1 : 0;
+			snapshot.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+			const result = {
+				...op.type === "create" && { created: true },
+				reviewId: id,
+				version: snapshot.version,
+				targetId: applied?.targetId ?? lensTarget?.targetId,
+				...applied && { type: applied.type },
+				...lensTarget && { type: lensTarget.type },
+				...applied?.children && { children: applied.children }
+			};
+			if (snapshot.staleSources?.length) warnings.push("Some authored source ranges changed. Update their references before presenting this review.");
+			if (warnings.length) result.warnings = warnings;
+			this.commitCommand(result, () => {
+				this.db.prepare("INSERT INTO reviews(id,version,next_id) VALUES(?,?,?) ON CONFLICT(id) DO UPDATE SET version=excluded.version,next_id=excluded.next_id").run(id, snapshot.version, nextId);
+				this.db.prepare("INSERT INTO versions(review_id,version,snapshot) VALUES(?,?,?)").run(id, snapshot.version, JSON.stringify(snapshot));
+			}, previous ? () => this.assertMutation(id, previous.version) : void 0, op.type === "edit" || op.type === "lens_edit" ? {
+				surface: op.type === "edit" ? "document" : "lenses",
+				activityId: op.activityId,
+				owned: (owner) => {
+					if (snapshot.lastEdit) snapshot.lastEdit.activityId = owner;
+				}
+			} : void 0);
+			return result;
+		});
+		this.pending = run.catch(() => {});
+		return run;
+	}
+	/** Resolve a target-less PR create before it queues, when it will need it. */
+	startPullRequest(command) {
+		const op = command.operation;
+		if (op.type !== "create" || op.kind || op.target || !op.pullRequestUrl) return void 0;
+		if (!this.providers.resolvePullRequest) return Promise.reject(new ReviewInputError("Pull request targets are unavailable."));
+		const [existing] = op.reuseExisting === false ? [] : this.reviewsForPullRequest(op.pullRequestUrl);
+		return this.providers.resolvePullRequest(op.pullRequestUrl, {
+			id: op.repositoryId,
+			preferred: existing && this.read(existing).pins?.repositoryId
+		});
+	}
+	/** Reviews whose PR is this one, newest version first. Summaries only. */
+	reviewsForPullRequest(url) {
+		return this.db.prepare(`SELECT reviews.id FROM reviews
+        JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+        WHERE lower(json_extract(versions.snapshot,'$.origin.pullRequestUrl'))=?
+          AND COALESCE(json_extract(versions.snapshot,'$.origin.tutorial'), 0) = 0
+        ORDER BY json_extract(versions.snapshot,'$.createdAt') DESC, reviews.rowid DESC`).all(pullRequestKey(url)).map((row) => String(row.id));
+	}
+	/** The answer to a create that found its PR's review. Its target stays:
+	* moving it would silently point existing links at different code. */
+	existingReview(reviewId, others, requested) {
+		const snapshot = this.read(reviewId);
+		const headMoved = snapshot.pins?.repositoryId !== requested.repositoryId || snapshot.pins?.head !== requested.head;
+		const working = this.activity.read(reviewId).activities ?? [];
+		return {
+			created: false,
+			note: [
+				"Returned the existing review for this PR instead of creating one; the requested title and target were not applied. Update it in place (read it with session_get first), or pass reuseExisting:false to create a separate review.",
+				headMoved && "The PR head moved since this review's target was set, and the target was NOT changed: call review_set_target to move it, then repair the source references it reports.",
+				working.length > 0 && `Another agent is working on it${working[0].focus ? `: ${working[0].focus.description}` : ""}.`,
+				others.length > 0 && "Older reviews also name this PR; see otherReviewIds."
+			].filter(Boolean).join(" "),
+			reviewId,
+			version: snapshot.version,
+			target: snapshot.target,
+			headMoved,
+			...working.length > 0 && { working: true },
+			...others.length > 0 && { otherReviewIds: others }
+		};
+	}
+	commitCommand(result, apply, guard, attribution) {
+		this.db.exec("BEGIN IMMEDIATE");
+		let owner;
+		try {
+			guard?.();
+			if (attribution) {
+				owner = this.activity.attribute(result.reviewId, attribution.surface, attribution.activityId);
+				if (owner) attribution.owned(owner);
+				else if (attribution.activityId) result.warnings = [...result.warnings ?? [], "Your activity has ended or expired, so readers no longer see you working. The edit was saved; call session_activity_begin and pass the new activityId."];
+			}
+			apply();
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+		if (result.deleted) this.activity.deleted(result.reviewId);
+		else if (owner) this.activity.extended(result.reviewId);
+		this.notify(result);
+	}
+	assertMutation(reviewId, version) {
+		const current = this.db.prepare("SELECT version FROM reviews WHERE id=?").get(reviewId);
+		if ((current ? Number(current.version) : void 0) !== version) throw new ReviewInputError("Review changed during validation. Reread it and retry the edit.", 409);
+	}
+	notify(result) {
+		if (result.deleted) this.observedVersions.delete(result.reviewId);
+		else if (!result.attention) this.observedVersions.set(result.reviewId, result.version);
+		if (!result.attention) for (const listener of this.listeners) try {
+			listener(result);
+		} catch {}
+		for (const listener of this.catalogListeners) try {
+			listener();
+		} catch {}
+	}
+	/** Dismissed reviews, as Home lists them; only a restore clears it, not a view. */
+	dismissedIds() {
+		return this.db.prepare("SELECT review_id FROM review_attention WHERE dismissed_at IS NOT NULL").all().map((row) => String(row.review_id));
+	}
+	has(reviewId) {
+		return this.db.prepare("SELECT 1 FROM reviews WHERE id=?").get(reviewId) !== void 0;
+	}
+	async validateExternal(snapshot, previous, repin = false) {
+		const warnings = [];
+		const references = (document, tolerant = false, lenses = []) => {
+			const sources = /* @__PURE__ */ new Map();
+			const resources = /* @__PURE__ */ new Map();
+			const add = (source, peek) => {
+				const key = JSON.stringify(source);
+				const kept = sources.get(key);
+				sources.set(key, {
+					source,
+					peek: peek || (kept?.peek ?? false)
+				});
+			};
+			for (const { source, peek } of sourceReferences(document, { tolerant })) add(source, peek === true);
+			for (const { source } of lensSelections(lenses)) for (const anchor of sourceAnchors(source)) add(anchor, false);
+			for (const block of resourceReferences(document)) resources.set(JSON.stringify(block), block);
+			return {
+				sources,
+				resources
+			};
+		};
+		const current = references(snapshot.document, repin, snapshot.lenses);
+		const pinsChanged = previous && JSON.stringify(previous.pins) !== JSON.stringify(snapshot.pins);
+		const worktreeMoved = pinsChanged && snapshot.target?.kind === "worktree";
+		const changed = repin && pinsChanged && previous.pins && snapshot.pins ? await this.providers.filesChangedBetween?.(previous.pins, snapshot.pins).catch(() => void 0) : void 0;
+		const retained = references(previous?.document ?? [], true, previous?.lenses);
+		const checks = [];
+		const retainedPins = new Set(explicitPins([...retained.sources.values()]).map((pins) => JSON.stringify(pins)));
+		for (const pins of explicitPins([...current.sources.values()])) if (!retainedPins.has(JSON.stringify(pins))) checks.push(this.providers.validatePins(pins));
+		for (const [key, { source, peek }] of current.sources) {
+			const kept = retained.sources.get(key);
+			if (pinsChanged && !source.pins || !kept || peek && !kept.peek) checks.push(this.providers.validateSource(anchorPins(source, snapshot.pins), source, { peek }).then(() => {
+				if (repin && (!changed || changed[source.side].has(source.file))) warnings.push(`${source.side}/${source.file}#L${source.fromLine}-L${source.toLine}: source pins changed; verify that this range still supports the document.`);
+			}, (error) => {
+				if (!repin && !(worktreeMoved && kept) || !(error instanceof ReviewInputError)) throw error;
+				warnings.push(`${source.side}/${source.file}#L${source.fromLine}-L${source.toLine}: ${error.message}`);
+			}));
+		}
+		for (const [key, block] of current.resources) if (pinsChanged || !retained.resources.has(key)) checks.push(this.providers.validateResource(snapshot.pins, block).catch((error) => {
+			if (!repin && !(worktreeMoved && retained.resources.has(key)) || !(error instanceof ReviewInputError)) throw error;
+			warnings.push(`${block.id} (${block.type}): ${error.message}`);
+		}));
+		await Promise.all(checks);
+		return warnings.sort();
+	}
+};
+/** Without a resolver, a commits target that names both commits pins them as
+* given; validatePins still checks they exist. */
+function namedCommits(target) {
+	if (target.kind !== "commits" || target.base === void 0) return void 0;
+	const { repositoryId, base, head } = target;
+	return {
+		target,
+		pins: {
+			repositoryId,
+			base,
+			head
+		}
+	};
+}
+/** A new document's first version, before its initial content. Field order
+* is kept so stored JSON reads as it always has. */
+function createdSnapshot(id, op, resolved, defaultTitle) {
+	const title = op.title ?? defaultTitle;
+	if (!title) throw new ReviewInputError("Supply a title.");
+	if (!resolved) return {
+		reviewId: id,
+		version: 0,
+		title,
+		kind: op.kind,
+		document: [],
+		createdAt: ""
+	};
+	return {
+		reviewId: id,
+		version: 0,
+		title,
+		pins: resolved.pins,
+		target: resolved.target,
+		document: [],
+		createdAt: ""
+	};
+}
+function inspectSnapshot(snapshot, targetId) {
+	if (targetId !== void 0) {
+		const target = elements(snapshot.document).find((element) => element.id === targetId);
+		if (!target) throw new ReviewInputError("Target not found in this version.", 404);
+		return target;
+	}
+	return elements(snapshot.document).map((element) => ({
+		id: element.id,
+		type: element.type,
+		label: "title" in element ? element.title : "label" in element ? element.label : element.type === "markdown" ? element.markdown.slice(0, 120) : void 0
+	}));
+}
+//#endregion
+//#region src/review-api/workspaces.ts
+const OWNED_ELSEWHERE = "Another Desktop owns this review's language workspaces. Quit that Desktop, then retry.";
+/** Local lifecycle only: source and authored history never depend on preparation.
+* Status/queue/process lifecycle follows #334, retaining the legacy prepare config
+* and per-review managed checkout layout instead of a new settings system.
+*/
+var ReviewWorkspaces = class {
+	store;
+	db;
+	requests = /* @__PURE__ */ new Map();
+	jobs = /* @__PURE__ */ new Map();
+	stop;
+	cleanup = Promise.resolve();
+	closed = false;
+	ownerId = randomUUID();
+	constructor(databasePath, store) {
+		this.store = store;
+		this.db = new DatabaseSync(databasePath, { timeout: 5e3 });
+		this.db.exec("PRAGMA journal_mode=WAL; CREATE TABLE IF NOT EXISTS pinned_environments(id TEXT PRIMARY KEY, value TEXT NOT NULL)");
+		this.db.exec("DROP TABLE IF EXISTS workspace_owner; CREATE TABLE IF NOT EXISTS workspace_leases(review_id TEXT PRIMARY KEY,owner TEXT NOT NULL,pid INTEGER NOT NULL)");
+		this.db.exec("BEGIN IMMEDIATE");
+		try {
+			for (const environment of this.all()) {
+				if (this.leasedElsewhere(environment.reviewId)) continue;
+				if (environment.state === "preparing") environment.state = "pending";
+				environment.generation = randomUUID();
+				this.save(environment);
+			}
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			this.db.close();
+			throw error;
+		}
+		this.stop = store.subscribeCatalog(() => {
+			this.collect();
+			this.releaseDismissed();
+		});
+		this.collect();
+		this.releaseDismissed();
+	}
+	dismissed;
+	releasing = /* @__PURE__ */ new Map();
+	/**
+	* Frees a newly dismissed review's checkouts to save disk. The review itself
+	* stays; reopening it rebuilds them. Checkouts rebuilt by peeking at a
+	* dismissed review are kept until the next startup or dismissal, since
+	* the Desktop's canvas tabs and source windows may still show them.
+	*/
+	releaseDismissed() {
+		const dismissed = new Set(this.store.dismissedIds());
+		const released = [...dismissed].filter((id) => !this.dismissed?.has(id));
+		this.dismissed = dismissed;
+		if (!released.length) return;
+		const repositories = this.repositoryDirs();
+		repositories.catch(() => void 0);
+		for (const reviewId of released) this.release(reviewId, repositories);
+	}
+	async repositoryDirs() {
+		const dirs = new Set(this.all().map((item) => item.repository));
+		for (const { path: root } of this.store.repositories()) {
+			const common = await gitCommonDir(root).catch(() => null);
+			if (common) dirs.add(common);
+		}
+		return [...dirs].filter(Boolean);
+	}
+	/** Resolves once no release of the review is pending, so an ensure cannot race it. */
+	released(reviewId) {
+		return this.releasing.get(reviewId) ?? Promise.resolve();
+	}
+	release(reviewId, repositories = this.repositoryDirs()) {
+		const requests = [...this.requests.values()];
+		const done = this.cleanup.then(async () => {
+			await Promise.allSettled(requests);
+			await this.releaseCheckouts(reviewId, await repositories);
+		}).catch((error) => {
+			console.error(`Could not free the pinned checkouts of dismissed review ${reviewId}:`, error);
+		}).finally(() => {
+			if (this.releasing.get(reviewId) === done) this.releasing.delete(reviewId);
+		});
+		this.releasing.set(reviewId, done);
+		this.cleanup = done;
+	}
+	async releaseCheckouts(reviewId, repositories) {
+		if (!this.store.dismissedIds().includes(reviewId)) return;
+		const environments = this.all().filter((item) => item.reviewId === reviewId);
+		const checkouts = repositories.filter((repository) => existsSync(reviewManagedCheckoutRoot(repository, reviewId)));
+		if (!environments.length && !checkouts.length || !this.claim(reviewId)) return;
+		for (const environment of environments) {
+			const job = this.jobs.get(environment.id);
+			job?.abort.abort();
+			await job?.done;
+		}
+		const errors = [];
+		for (const repository of checkouts) await removeReviewManagedCheckouts(repository, reviewId).catch((error) => errors.push(errorMessage(error)));
+		for (const environment of environments) if (errors.length && environment.rootPath && existsSync(environment.rootPath)) {
+			environment.state = "cleanup-failed";
+			environment.log = errors.join("\n");
+			this.save(environment);
+		} else this.db.prepare("DELETE FROM pinned_environments WHERE id=?").run(environment.id);
+		this.db.prepare("DELETE FROM workspace_leases WHERE review_id=? AND owner=? AND NOT EXISTS(SELECT 1 FROM pinned_environments WHERE value->>'reviewId'=?)").run(reviewId, this.ownerId, reviewId);
+		if (errors.length) throw new Error(errors.join("\n"));
+	}
+	external;
+	stopExternal;
+	attachExternalReviews(source) {
+		if (this.external === source) return;
+		this.stopExternal?.();
+		this.external = source;
+		this.stopExternal = source.subscribe(() => this.collect());
+		this.collect();
+	}
+	hasReview(id) {
+		if (id.startsWith("shared-") && !this.external) return true;
+		return this.store.has(id) || Boolean(this.external?.has(id));
+	}
+	assertReview(id) {
+		if (!this.hasReview(id)) this.store.assertExists(id);
+	}
+	async remove(reviewId) {
+		if (!this.claim(reviewId)) throw new ReviewInputError(OWNED_ELSEWHERE, 409);
+		await Promise.all(this.requests.values());
+		this.collect(void 0, reviewId);
+		await this.cleanup;
+		if (this.all().some((item) => item.reviewId === reviewId)) throw new ReviewInputError("Could not remove the managed workspace. Retry deletion.", 409);
+	}
+	lease(reviewId) {
+		return this.db.prepare("SELECT owner,pid FROM workspace_leases WHERE review_id=?").get(reviewId);
+	}
+	leasedElsewhere(reviewId) {
+		const lease = this.lease(reviewId);
+		return Boolean(lease && lease.owner !== this.ownerId && processIsAlive(Number(lease.pid)));
+	}
+	/** Takes the review's lease unless another live Desktop holds it. */
+	claim(reviewId) {
+		if (this.lease(reviewId)?.owner === this.ownerId) return true;
+		this.db.exec("BEGIN IMMEDIATE");
+		try {
+			const free = !this.leasedElsewhere(reviewId);
+			if (free) this.db.prepare("INSERT OR REPLACE INTO workspace_leases VALUES(?,?,?)").run(reviewId, this.ownerId, process.pid);
+			this.db.exec("COMMIT");
+			return free;
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	all() {
+		return this.db.prepare("SELECT value FROM pinned_environments").all().map((row) => JSON.parse(String(row.value)));
+	}
+	get(id) {
+		const row = this.db.prepare("SELECT value FROM pinned_environments WHERE id=?").get(id);
+		return row ? JSON.parse(String(row.value)) : void 0;
+	}
+	save(environment) {
+		this.db.prepare("INSERT INTO pinned_environments VALUES(?,?) ON CONFLICT(id) DO UPDATE SET value=excluded.value").run(environment.id, JSON.stringify(environment));
+	}
+	status(environment) {
+		const { id, commit, rootPath, generation, state, log } = environment;
+		const status = {
+			id,
+			commit,
+			rootPath,
+			generation,
+			state,
+			log
+		};
+		if (state === "failed" && !rootPath) status.issue = log;
+		return status;
+	}
+	list(reviewId) {
+		return this.all().filter((item) => item.reviewId === reviewId).map((item) => this.status(item));
+	}
+	failures() {
+		return this.all().filter((item) => item.state === "cleanup-failed").map((item) => this.status(item));
+	}
+	async retryCleanup(id) {
+		const environment = this.get(id);
+		if (!environment || environment.state !== "cleanup-failed") throw new ReviewInputError("Cleanup failure not found.", 404);
+		if (this.store.has(environment.reviewId)) this.release(environment.reviewId);
+		else this.collect(id);
+		await this.cleanup;
+	}
+	async open(reviewId, pins) {
+		await this.source(reviewId, pins, "head");
+		if (pins.base !== pins.head) await this.source(reviewId, pins, "base");
+	}
+	source(reviewId, pins, side, retryFailed = false) {
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Language environments are closed."));
+		this.assertReview(reviewId);
+		const id = createHash("sha256").update(JSON.stringify([
+			reviewId,
+			pins.repositoryId,
+			pins[side]
+		])).digest("hex");
+		const current = this.requests.get(id);
+		if (current) return current;
+		if (!this.claim(reviewId)) {
+			const environment = this.get(id);
+			return Promise.resolve(environment ? this.status(environment) : {
+				id,
+				commit: pins[side],
+				rootPath: null,
+				generation: "",
+				state: "pending",
+				log: OWNED_ELSEWHERE
+			});
+		}
+		const request = this.acquire(id, reviewId, pins, side, retryFailed).finally(() => this.requests.delete(id));
+		this.requests.set(id, request);
+		return request;
+	}
+	async acquire(id, reviewId, pins, side, retryFailed) {
+		await this.released(reviewId);
+		let environment = this.get(id);
+		if (this.jobs.has(id)) return this.status(environment);
+		environment ??= {
+			id,
+			reviewId,
+			repositoryId: pins.repositoryId,
+			repository: "",
+			commit: pins[side],
+			rootPath: null,
+			generation: randomUUID(),
+			commandsHash: "",
+			role: pins.base === pins.head ? "head" : side,
+			state: "pending",
+			log: ""
+		};
+		this.save(environment);
+		try {
+			const root = this.store.repositoryPath(pins.repositoryId);
+			const repository = environment.repository || await gitCommonDir(root).catch(() => null);
+			if (!repository) throw new Error("Repository Git directory is unavailable. Restore the registered checkout and retry preparation.");
+			environment.repository = repository;
+			const result = await git(repository, [
+				"config",
+				"--null",
+				"--get-all",
+				"devfast.prepare"
+			], { allowFailure: true });
+			const commands = result.stdout.trim() ? result.stdout.split("\0").filter((command) => command.trim()) : [];
+			const commandsHash = reviewPrepareCommandsHash(commands);
+			const existed = environment.rootPath && existsSync(path.join(environment.rootPath, ".git"));
+			const checkout = await ensureReviewPinnedCheckout({
+				rootPath: existsSync(root) ? root : repository,
+				reviewUuid: reviewId,
+				ref: pins[side],
+				role: environment.role
+			});
+			if (!checkout) throw new Error("Pinned checkout is unavailable.");
+			if (!this.hasReview(reviewId)) {
+				environment.rootPath = checkout;
+				this.save(environment);
+				this.collect();
+				return this.status(environment);
+			}
+			const changed = !existed || environment.rootPath !== checkout || environment.commandsHash !== commandsHash;
+			environment.rootPath = checkout;
+			environment.commandsHash = commandsHash;
+			if (!commands.length) {
+				environment.state = "unconfigured";
+				environment.log = "Configure dependencies with git config devfast.prepare '<command>'.";
+			} else if (await markerMatches(reviewPrepareMarkerPath(checkout), commandsHash)) {
+				environment.state = "ready";
+				environment.log = "";
+			} else if (environment.state !== "failed" || changed || retryFailed) {
+				environment.state = "preparing";
+				environment.generation = randomUUID();
+				environment.log = "Preparing pinned checkout…";
+				this.save(environment);
+				this.prepare(environment, commands);
+				return this.status(environment);
+			}
+			if (changed) environment.generation = randomUUID();
+		} catch (error) {
+			environment.state = "failed";
+			environment.rootPath = null;
+			environment.log = errorMessage(error);
+		}
+		this.save(environment);
+		return this.status(environment);
+	}
+	prepare(environment, commands) {
+		const abort = new AbortController();
+		const done = prepareReviewPinnedCheckout({
+			checkoutPath: environment.rootPath,
+			commit: environment.commit,
+			commands,
+			signal: abort.signal,
+			progress: (log) => {
+				environment.log = log;
+				this.save(environment);
+			},
+			warning: (log) => {
+				environment.log = log;
+			}
+		}).then(async (result) => {
+			environment.state = result.prepared ? "ready" : "failed";
+			if (!result.prepared) environment.log = await readFile(reviewPrepareLogPath(environment.rootPath), "utf8").catch(() => environment.log);
+		}).catch((error) => {
+			environment.state = "failed";
+			environment.log = errorMessage(error);
+		}).finally(() => {
+			environment.generation = randomUUID();
+			this.save(environment);
+			this.jobs.delete(environment.id);
+		});
+		this.jobs.set(environment.id, {
+			done,
+			abort
+		});
+	}
+	async retry(reviewId, id) {
+		const environment = this.get(id);
+		if (!environment || environment.reviewId !== reviewId) throw new ReviewInputError("Language environment not found.", 404);
+		if (this.jobs.has(id)) return this.status(environment);
+		if (!this.claim(reviewId)) throw new ReviewInputError(OWNED_ELSEWHERE, 409);
+		if (environment.state === "cleanup-failed") {
+			this.collect();
+			return this.status(environment);
+		}
+		this.assertReview(reviewId);
+		if (environment.rootPath) await rm(reviewPrepareMarkerPath(environment.rootPath), { force: true });
+		environment.state = "pending";
+		environment.generation = randomUUID();
+		this.save(environment);
+		return this.source(reviewId, {
+			repositoryId: environment.repositoryId,
+			base: environment.commit,
+			head: environment.commit
+		}, "head");
+	}
+	collect(retryId, removedReviewId) {
+		const deleted = this.all().filter((environment) => (environment.reviewId === removedReviewId || !this.hasReview(environment.reviewId)) && (environment.state !== "cleanup-failed" || environment.id === retryId || environment.reviewId === removedReviewId) && this.claim(environment.reviewId));
+		this.cleanup = this.cleanup.then(async () => {
+			for (const environment of deleted) {
+				const job = this.jobs.get(environment.id);
+				job?.abort.abort();
+				await job?.done;
+				try {
+					if (environment.rootPath && existsSync(environment.rootPath)) {
+						const managed = reviewManagedCheckoutRoot(environment.repository, environment.reviewId);
+						const relative = path.relative(managed, environment.rootPath);
+						if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) throw new Error("Refusing to remove a non-managed checkout.");
+						await git(environment.repository, [
+							"worktree",
+							"remove",
+							"--force",
+							environment.rootPath
+						]);
+					}
+					if (environment.rootPath) await removeReviewPrepareArtifacts(environment.rootPath);
+					this.db.prepare("DELETE FROM pinned_environments WHERE id=?").run(environment.id);
+					this.db.prepare("DELETE FROM workspace_leases WHERE review_id=? AND owner=? AND NOT EXISTS(SELECT 1 FROM pinned_environments WHERE value->>'reviewId'=?)").run(environment.reviewId, this.ownerId, environment.reviewId);
+				} catch (error) {
+					environment.state = "cleanup-failed";
+					environment.log = errorMessage(error);
+					this.save(environment);
+				}
+			}
+		});
+	}
+	async idle() {
+		await Promise.all(this.requests.values());
+		await Promise.all([...this.jobs.values()].map((job) => job.done));
+		await this.cleanup;
+	}
+	closing;
+	close() {
+		return this.closing ??= this.closeAll();
+	}
+	async closeAll() {
+		this.closed = true;
+		this.stop();
+		this.stopExternal?.();
+		await Promise.all(this.requests.values());
+		for (const job of this.jobs.values()) job.abort.abort();
+		await this.idle();
+		this.db.prepare("DELETE FROM workspace_leases WHERE owner=?").run(this.ownerId);
+		this.db.close();
+	}
+};
+//#endregion
+//#region src/review-api/worktree-source.ts
+const { lstat: lstat$1, readFile: readFile$1, readlink, realpath: realpath$1 } = checkoutFs;
+const exec = promisify(execFile);
+const EMPTY_SOURCE = "empty-worktree-baseline";
+/** Never follow a working-copy link outside the selected checkout. */
+async function localSourcePath(root, file) {
+	const canonicalRoot = await realpath$1(root);
+	const candidate = await realpath$1(resolve(canonicalRoot, file));
+	const child = relative(canonicalRoot, candidate);
+	if (!child || isAbsolute(child) || child === ".." || child.startsWith(`..${sep}`)) throw new ReviewInputError("Source symlink leaves the selected worktree.");
+	if (!(await lstat$1(candidate)).isFile()) throw new ReviewInputError("Source is not a regular file.");
+	return candidate;
+}
+/** List the live checkout's tracked files. jj tracks new files itself; Git's untracked files are left out. */
+async function workingFiles(vcs) {
+	const gitDirectory = vcs.kind === "jj" ? await gitCommonDir(vcs.rootPath) : void 0;
+	if (vcs.kind === "jj" && !gitDirectory) throw new ReviewInputError("Working source requires a Git-backed jj repository.");
+	const { stdout } = await exec("git", [
+		"-C",
+		vcs.rootPath,
+		...gitDirectory ? [
+			"--git-dir",
+			gitDirectory,
+			"--work-tree",
+			vcs.rootPath
+		] : [],
+		"ls-files",
+		"-z",
+		...vcs.kind === "git" ? ["--cached"] : [
+			"--others",
+			"--exclude-standard",
+			"--exclude=.jj/"
+		]
+	], { maxBuffer: 33554432 });
+	const paths = [.../* @__PURE__ */ new Set([...stdout.split("\0").filter(Boolean), ...vcs.kind === "jj" ? await vcs.listTrackedFiles() : []])].sort();
+	return (await Promise.all(paths.map(async (file) => {
+		try {
+			await lstat$1(resolve(vcs.rootPath, file));
+			return file;
+		} catch (error) {
+			if (isMissingFileError(error)) return void 0;
+			throw error;
+		}
+	}))).filter((file) => file !== void 0);
+}
+/**
+* Count Git's untracked, non-ignored files, which working tree reviews leave
+* out. Undefined for jj, which tracks new files itself, or when the listing
+* is too large to read.
+*/
+async function untrackedFileCount(vcs) {
+	if (vcs.kind !== "git") return void 0;
+	try {
+		const { stdout } = await exec("git", [
+			"-C",
+			vcs.rootPath,
+			"ls-files",
+			"-z",
+			"--others",
+			"--exclude-standard",
+			"--exclude=.jj/"
+		], { maxBuffer: 33554432 });
+		return stdout.split("\0").filter(Boolean).length;
+	} catch {
+		return;
+	}
+}
+/** A refresh token, not stored source: all reads still use the checkout. */
+async function inspectWorktree(repositoryId, vcs) {
+	const commit = (await vcs.resolveRevision(vcs.kind === "jj" ? "@" : "HEAD"))?.commit ?? "empty-worktree-baseline";
+	const hash = createHash("sha256").update(`${repositoryId}\0${commit}`);
+	for (const file of await workingFiles(vcs)) try {
+		const info = await lstat$1(resolve(vcs.rootPath, file), { bigint: true });
+		hash.update(`\0${file}\0${info.ino}:${info.size}:${info.mode}:${info.mtimeNs}:${info.ctimeNs}`);
+	} catch (error) {
+		if (!isMissingFileError(error)) throw error;
+	}
+	return {
+		revision: hash.digest("hex"),
+		commit
+	};
+}
+async function readWorkingFile(root, file) {
+	try {
+		const candidate = resolve(root, file);
+		const parent = relative(await realpath$1(root), await realpath$1(dirname(candidate)));
+		if (isAbsolute(parent) || parent === ".." || parent.startsWith(`..${sep}`)) throw new ReviewInputError("Source symlink leaves the selected worktree.");
+		if ((await lstat$1(candidate)).isSymbolicLink()) return readlink(candidate);
+		return await readFile$1(await localSourcePath(root, file), "utf8");
+	} catch (error) {
+		if (isMissingFileError(error)) return null;
+		throw error;
+	}
+}
+//#endregion
+//#region src/review-api/local-data.ts
+const uploadSchema = z.discriminatedUnion("kind", [
+	z.strictObject({
+		id: z.uuid(),
+		repositoryId: z.string(),
+		kind: z.literal("image"),
+		base64: z.string()
+	}),
+	z.strictObject({
+		id: z.uuid(),
+		repositoryId: z.string(),
+		kind: z.literal("trace"),
+		trace: traceSchema
+	}),
+	z.strictObject({
+		id: z.uuid(),
+		repositoryId: z.string(),
+		kind: z.literal("map"),
+		pins: pinsSchema,
+		side: z.enum(["base", "head"]),
+		model: mapInputSchema
+	})
+]);
+const unavailableCheckout = () => new ReviewInputError("The selected local checkout is unavailable.", 404);
+/** File reads cannot name the root or a directory; tree reads can. */
+function checkRelativePath(file) {
+	inputError(() => checkSourcePath(file));
+	if (file === "" || file.endsWith("/")) throw new ReviewInputError("Source file must be a repository-relative path.");
+}
+function sliceRange(file, source) {
+	return {
+		...source,
+		commit: file.commit,
+		text: inputError(() => sliceSourceRange(file.text, source))
+	};
+}
+/** Local source/resource boundary, including Desktop-only local language context. */
+var LocalReviewData = class {
+	store;
+	options;
+	workspaceManager;
+	get workspaces() {
+		if (!this.workspaceManager) throw new ReviewInputError("Open this review in Desktop to prepare language workspaces.", 409);
+		return this.workspaceManager;
+	}
+	currentEnvironmentIssues(snapshot) {
+		if (snapshot.target?.kind !== "commits" || !snapshot.pins) return [];
+		const pins = snapshot.pins;
+		return this.workspaces.list(snapshot.reviewId).flatMap((environment) => {
+			const side = environment.commit === pins.head ? "head" : environment.commit === pins.base ? "base" : void 0;
+			return side && environment.issue ? [{
+				side,
+				message: environment.issue
+			}] : [];
+		});
+	}
+	async environmentIssues(snapshot, retryFailed = false) {
+		const issues = [];
+		if (!snapshot.pins) return issues;
+		const sides = snapshot.target?.kind === "commits" && snapshot.pins.base !== snapshot.pins.head ? ["head", "base"] : ["head"];
+		for (const side of sides) {
+			const context = await this.languageEnvironment(snapshot, side, void 0, retryFailed);
+			if (context.issue) issues.push({
+				side,
+				message: context.issue
+			});
+		}
+		return issues;
+	}
+	untrackedCounts = /* @__PURE__ */ new Map();
+	/**
+	* Untracked files a live worktree review leaves out; undefined otherwise.
+	* Counted once per worktree revision, never by the revision poll, so a
+	* checkout with many untracked files pays for the walk only when read.
+	*/
+	untrackedFiles(pins) {
+		if (!pins.worktreeRevision) return Promise.resolve(void 0);
+		const key = `${pins.repositoryId}\0${pins.worktreeRevision}`;
+		let count = this.untrackedCounts.get(key);
+		if (!count) {
+			count = this.vcs(pins.repositoryId).then((vcs) => vcs ? untrackedFileCount(vcs) : void 0);
+			this.untrackedCounts.set(key, count);
+			for (const cached of this.untrackedCounts.keys()) {
+				if (this.untrackedCounts.size <= 32) break;
+				this.untrackedCounts.delete(cached);
+			}
+		}
+		return count;
+	}
+	/** Local checkout context for live worktree targets only. */
+	/** Desktop language services borrow the registered checkout, never create one. */
+	async liveFile(repositoryId, file, text) {
+		try {
+			const rootPath = await realpath(this.store.repositoryPath(repositoryId));
+			const localPath = await localSourcePath(rootPath, file);
+			if (await checkoutFs.readFile(localPath, "utf8") === text) return {
+				localPath,
+				localRoot: rootPath
+			};
+		} catch {}
+	}
+	/** Source bytes and the language workspace have independent lifetimes. */
+	async languageEnvironment(snapshot, side, commit, retryFailed = false, anchor) {
+		if (!anchor && snapshot.target?.kind === "commits" && snapshot.pins) {
+			const pins = await this.comparison(snapshot.pins, commit);
+			const environment = await this.workspaces.source(snapshot.reviewId, pins, side, retryFailed);
+			return {
+				rootPath: environment.state === "preparing" || environment.state === "pending" ? null : environment.rootPath,
+				identity: environment.generation,
+				issue: environment.issue
+			};
+		}
+		if (commit && !anchor) await this.comparison(await this.documentPins(snapshot), commit);
+		const repositoryId = anchor?.repositoryId ?? snapshot.pins?.repositoryId;
+		if (!repositoryId) throw new ReviewInputError("This document has no source pins of its own.", 409);
+		const unavailable = {
+			rootPath: null,
+			identity: `${repositoryId}:unavailable`,
+			issue: "Could not access the registered language checkout. Check the repository path and permissions, then retry."
+		};
+		let rootPath;
+		try {
+			rootPath = await realpath(this.store.repositoryPath(repositoryId));
+		} catch (error) {
+			if (error instanceof ReviewInputError && error.status !== 404) throw error;
+			return unavailable;
+		}
+		if (!rootPath || !await this.vcs(repositoryId)) return unavailable;
+		const info = await stat(rootPath, { bigint: true }).catch(() => null);
+		return info ? {
+			rootPath,
+			identity: `${repositoryId}:${rootPath}:${info.dev}:${info.ino}:${info.birthtimeNs}`
+		} : unavailable;
+	}
+	/** Resolve source coordinates after selecting a local or imported snapshot.
+	* `anchor` reads at a reference's own pins instead of the document's;
+	* `commit` narrows the document comparison to one of its commits. */
+	async resolveSource(snapshot, commit, anchor) {
+		return {
+			snapshot,
+			pins: anchor ? await this.anchorSourcePins(anchor) : await this.comparison(await this.documentPins(snapshot), commit)
+		};
+	}
+	/** Where an Ask agent reads source: the Review's own head checkout, or the
+	* registered checkout for a live worktree target, as the navigator does. */
+	async agentCheckout(snapshot) {
+		const { pins } = await this.resolveSource(snapshot);
+		const rootPath = pins.worktreeRevision ? await realpath(this.store.repositoryPath(pins.repositoryId)) : (await this.workspaces.source(snapshot.reviewId, pins, "head")).rootPath;
+		if (!rootPath) throw new ReviewInputError("The head checkout for this review is not ready yet.", 409);
+		return {
+			rootPath,
+			head: pins.head,
+			live: !!pins.worktreeRevision
+		};
+	}
+	/** Resolve a native workspace without replacing the selected source with today's HEAD. */
+	async navigatorWorkspace(snapshot, source = {}) {
+		const { pins } = await this.resolveSource(snapshot, source.commit, source.anchor);
+		const repository = this.store.repositoryPath(pins.repositoryId);
+		const side = source.side ?? "head";
+		const live = !!pins.worktreeRevision && (side === "head" || source.empty && pins[side] === "empty-worktree-baseline");
+		const checkoutSide = pins[side] === "empty-worktree-baseline" && source.empty ? "head" : side;
+		const ref = pins[checkoutSide];
+		if (source.file) checkRelativePath(source.file);
+		const rootPath = live ? await realpath(repository) : (await this.workspaces.source(snapshot.reviewId, pins, checkoutSide)).rootPath;
+		const context = await resolveRepoContext(repository);
+		if (!rootPath || !context) throw new ReviewInputError("Could not open the selected source checkout.", 409);
+		if (!live) {
+			const { stdout } = await promisify(execFile)("git", [
+				"-C",
+				rootPath,
+				"status",
+				"--porcelain",
+				"--untracked-files=no"
+			]);
+			if (stdout.trim()) throw new ReviewInputError("The pinned checkout has local changes, possibly from devfast.prepare. Restore those files before browsing this pinned revision.", 409);
+		}
+		const name = context.githubSlug?.split("/").at(-1) ?? path.basename(path.dirname(context.commonDir));
+		const workspaceDirectory = path.join(reviewManagedCheckoutRoot(context.commonDir, snapshot.reviewId), "navigator", "workspaces", live ? "worktree" : ref);
+		const workspacePath = path.join(workspaceDirectory, `${name}.code-workspace`);
+		const current = await readWorkspace(workspacePath);
+		if (current !== null) {
+			const previous = current ?? await readWorkspace(path.join(workspaceDirectory, `${path.basename(repository)}.code-workspace`));
+			const title = `${snapshot.title} — ${live ? "Live source" : side === "base" ? "Base source" : "Source"} — Whiteboard`;
+			const workspace = previous ?? {
+				folders: [],
+				settings: { "files.readonlyInclude": { "**/*": true } }
+			};
+			const next = {
+				...workspace,
+				folders: [{
+					path: rootPath,
+					name
+				}, ...workspace.folders.slice(1)],
+				settings: {
+					...workspace.settings,
+					"window.title": title
+				}
+			};
+			if (JSON.stringify(next) !== JSON.stringify(current)) await writePrivateJsonAtomic(workspacePath, next);
+		}
+		let filePath;
+		if (source.file) {
+			if (source.empty) {
+				filePath = path.join(path.dirname(workspacePath), "empty", path.basename(source.file));
+				await mkdir(path.dirname(filePath), { recursive: true });
+				await writeFile(filePath, "", { mode: 384 });
+			} else try {
+				filePath = await localSourcePath(rootPath, source.file);
+			} catch (error) {
+				if (isMissingFileError(error)) throw new ReviewInputError("File is unavailable at the selected revision.", 404);
+				throw error;
+			}
+		}
+		return {
+			workspacePath,
+			filePath
+		};
+	}
+	/** A document read that needs default pins; 409 when the document has none. */
+	async documentPins(snapshot) {
+		const pins = await this.sourcePins(snapshot);
+		if (!pins) throw new ReviewInputError("This document has no source pins of its own.", 409);
+		return pins;
+	}
+	/** Pins a reference names itself, checked against the registered checkout. */
+	async anchorSourcePins(anchor) {
+		if (!existsSync(this.store.repositoryPath(anchor.repositoryId))) throw unavailableCheckout();
+		return anchorPins({ pins: anchor }, void 0);
+	}
+	/** References whose own repository is unregistered or gone from disk. */
+	async unavailableAnchors(snapshot) {
+		const missing = /* @__PURE__ */ new Set();
+		for (const pins of explicitPins(sourceReferences(snapshot.document, { tolerant: true }))) try {
+			await this.anchorSourcePins(pins);
+		} catch (error) {
+			if (!(error instanceof ReviewInputError)) throw error;
+			missing.add(pins.repositoryId);
+		}
+		if (!missing.size) return [];
+		return sourceReferences(snapshot.document, { tolerant: true }).filter((ref) => ref.source.pins && missing.has(ref.source.pins.repositoryId)).map((ref) => ref.id);
+	}
+	trackedFiles = /* @__PURE__ */ new Map();
+	repositories = /* @__PURE__ */ new Map();
+	readers = /* @__PURE__ */ new Map();
+	commitRanges = /* @__PURE__ */ new Map();
+	constructor(store, options = {}) {
+		this.store = store;
+		this.options = options;
+		if (options.manageWorkspaces !== false) this.workspaceManager = new ReviewWorkspaces(options.workspaceDatabase ?? ":memory:", store);
+	}
+	async *structuralChanges({ reviewId, pins, signal, file }) {
+		if (file !== void 0) checkRelativePath(file);
+		if (pins.worktreeRevision) {
+			const { rootPath, baseRef } = await this.worktreeInput(pins);
+			yield* this.structuralComparisons.stream({
+				repositoryPath: rootPath,
+				comparison: {
+					kind: "worktree",
+					base: baseRef ?? "4b825dc642cb6eb9a060e54bf8d69288fbee4904",
+					revision: pins.worktreeRevision
+				},
+				paths: file === void 0 ? void 0 : [file],
+				signal
+			});
+			return;
+		}
+		await this.workspaceManager?.released(reviewId);
+		const rootPath = await ensureReviewPinnedCheckout({
+			rootPath: this.store.repositoryPath(pins.repositoryId),
+			ref: pins.head,
+			reviewUuid: reviewId
+		});
+		if (!rootPath) throw new ReviewInputError("Cannot prepare the pinned repository for structural diffing.");
+		yield* this.structuralComparisons.stream({
+			repositoryPath: rootPath,
+			comparison: {
+				kind: "trees",
+				base: pins.base,
+				head: pins.head
+			},
+			paths: file === void 0 ? void 0 : [file],
+			signal
+		});
+	}
+	structuralComparisons = new StructuralComparisons();
+	closed = false;
+	worktrees = /* @__PURE__ */ new Map();
+	forgetWorktree(repositoryId) {
+		const entry = this.worktrees.get(repositoryId);
+		if (entry) for (const watcher of entry.watchers) watcher.close();
+		this.worktrees.delete(repositoryId);
+	}
+	async worktreeState(repositoryId, vcs) {
+		let entry = this.worktrees.get(repositoryId);
+		if (!entry) {
+			entry = {
+				epoch: 0,
+				inspectedEpoch: -1,
+				watchers: [],
+				healthy: true,
+				forks: /* @__PURE__ */ new Map()
+			};
+			this.worktrees.set(repositoryId, entry);
+			const state = entry;
+			const roots = /* @__PURE__ */ new Set([vcs.rootPath]);
+			const common = await gitCommonDir(vcs.rootPath);
+			if (common) roots.add(common);
+			for (const root of roots) try {
+				const watcher = (this.options.watch ?? watch)(root, { recursive: true }, () => {
+					state.epoch++;
+				});
+				watcher.on("error", () => {
+					state.epoch++;
+					state.inspectedEpoch = -1;
+					state.healthy = false;
+					watcher.close();
+				});
+				watcher.unref();
+				state.watchers.push(watcher);
+			} catch {
+				state.healthy = false;
+			}
+		}
+		if (entry.inspection && entry.inspectedEpoch === entry.epoch && entry.healthy && entry.watchers.length) return {
+			...entry.inspection,
+			forks: entry.forks
+		};
+		const epoch = entry.epoch;
+		const inspected = await inspectWorktree(repositoryId, vcs);
+		entry.inspection = inspected;
+		entry.inspectedEpoch = epoch;
+		entry.forks = /* @__PURE__ */ new Map();
+		return {
+			...inspected,
+			forks: entry.forks
+		};
+	}
+	async close() {
+		this.coverageAbort.abort();
+		clearTimeout(this.coverageNotification);
+		this.coverageListeners.clear();
+		this.coverageCache.clear();
+		this.structuralComparisons.close();
+		this.closed = true;
+		await this.workspaceManager?.close();
+		for (const entry of this.worktrees.values()) for (const watcher of entry.watchers) watcher.close();
+		this.worktrees.clear();
+		const readers = [...this.readers.values()];
+		this.readers.clear();
+		await Promise.all(readers.map((reader) => reader.close()));
+	}
+	/** Detected once; dropped when the root vanishes or detection found nothing. */
+	vcs(repositoryId) {
+		const cached = this.repositories.get(repositoryId);
+		if (cached && (!cached.vcs || existsSync(cached.vcs.rootPath))) return cached.detection;
+		this.closeReader(repositoryId);
+		this.forgetWorktree(repositoryId);
+		const rootPath = this.store.repositoryPath(repositoryId);
+		const forget = () => {
+			this.repositories.delete(repositoryId);
+			this.closeReader(repositoryId);
+		};
+		const entry = { detection: detectLocalVcs(rootPath).then((vcs) => {
+			if (vcs) entry.vcs = vcs;
+			else forget();
+			return vcs;
+		}, (cause) => {
+			forget();
+			throw cause;
+		}) };
+		this.repositories.set(repositoryId, entry);
+		return entry.detection;
+	}
+	/** None once closed: a read suspended across close() gets its own process. */
+	reader(repositoryId, vcs) {
+		if (this.closed) return void 0;
+		const existing = this.readers.get(repositoryId);
+		if (existing) return existing;
+		const reader = createBlobBatchReader({
+			rootPath: vcs.rootPath,
+			kind: vcs.kind,
+			idleTimeoutMs: this.options.blobReaderIdleTimeoutMs
+		});
+		this.readers.set(repositoryId, reader);
+		return reader;
+	}
+	closeReader(repositoryId) {
+		const reader = this.readers.get(repositoryId);
+		if (!reader) return;
+		this.readers.delete(repositoryId);
+		return reader.close();
+	}
+	async forgetRepository(repositoryId) {
+		await this.closeReader(repositoryId);
+		this.forgetWorktree(repositoryId);
+		this.repositories.delete(repositoryId);
+		for (const key of this.trackedFiles.keys()) if (key.startsWith(repositoryId + "\0")) this.trackedFiles.delete(key);
+		for (const key of this.commitRanges.keys()) if (key.startsWith(repositoryId + ":")) this.commitRanges.delete(key);
+	}
+	async vcsTarget(repositoryId) {
+		const vcs = await this.vcs(repositoryId);
+		if (vcs) return {
+			rootPath: vcs.rootPath,
+			kind: vcs.kind
+		};
+		const rootPath = this.store.repositoryPath(repositoryId);
+		if (!existsSync(rootPath)) throw unavailableCheckout();
+		return { rootPath };
+	}
+	async register(root) {
+		const resolved = await realpath(root).catch(() => {
+			throw new ReviewInputError("Repository path does not exist or is not readable.");
+		});
+		const vcs = await detectLocalVcs(resolved).catch((cause) => {
+			if (cause instanceof LocalVcsToolsMissingError) throw new ReviewInputError(cause.message);
+			throw cause;
+		});
+		if (!vcs) throw new ReviewInputError("Choose a Git or jj repository.");
+		const repository = this.store.registerRepository(await realpath(vcs.rootPath));
+		await this.closeReader(repository.id);
+		this.repositories.delete(repository.id);
+		return repository;
+	}
+	async projectSource(snapshot, pins) {
+		const projected = {
+			...snapshot,
+			pins,
+			staleSources: []
+		};
+		delete projected.sourceUnavailable;
+		for (const reference of sourceReferences(snapshot.document, { tolerant: true })) try {
+			await this.quote(anchorPins(reference.source, pins), reference.source);
+		} catch (error) {
+			if (!(error instanceof ReviewInputError)) throw error;
+			projected.staleSources.push(reference.id);
+		}
+		return projected;
+	}
+	/** Throws 404 when the checkout behind the snapshot is gone. Undefined
+	* for a document without default pins. */
+	async sourcePins(snapshot) {
+		if (snapshot.target?.kind === "worktree") return (await this.resolveTarget(snapshot.target, snapshot.pins)).pins;
+		if (!snapshot.pins) return void 0;
+		if (!existsSync(this.store.repositoryPath(snapshot.pins.repositoryId))) throw unavailableCheckout();
+		return snapshot.pins;
+	}
+	/** Capture a label only when its ref still resolves to these exact pins. */
+	async headBranch(pins, headRef) {
+		const vcs = await this.vcs(pins.repositoryId);
+		if (!vcs || vcs.kind !== "git") return void 0;
+		try {
+			const { stdout } = await promisify(execFile)("git", [
+				"-C",
+				vcs.rootPath,
+				"rev-parse",
+				"--symbolic-full-name",
+				"--verify",
+				"--end-of-options",
+				!headRef || /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(headRef) ? "HEAD" : headRef
+			]);
+			const ref = stdout.trim();
+			if (!ref.startsWith("refs/heads/") && !ref.startsWith("refs/remotes/")) return void 0;
+			if ((await vcs.resolveRevision(ref))?.commit !== pins.head) return void 0;
+			return ref.replace(/^refs\/(heads|remotes)\//, "");
+		} catch {
+			return;
+		}
+	}
+	/** `pinned` refreshes a stored target: a worktree base ref resolves to its
+	* current fork point, and keeps the pinned one if the ref is gone. */
+	async resolveTarget(target, pinned) {
+		const vcs = await this.vcs(target.repositoryId);
+		if (!vcs) throw unavailableCheckout();
+		if (target.kind === "commits") {
+			const head = await vcs.resolveRevision(target.head);
+			if (!head) throw new ReviewInputError("Head revision does not exist.");
+			const base = target.base === void 0 ? head : await vcs.resolveRevision(target.base);
+			if (!base) throw new ReviewInputError("Base revision does not exist.");
+			const resolved = {
+				...target,
+				head: head.commit
+			};
+			if (target.base !== void 0) resolved.base = base.commit;
+			return {
+				target: resolved,
+				pins: {
+					repositoryId: target.repositoryId,
+					base: base.commit,
+					head: head.commit
+				}
+			};
+		}
+		const { revision, commit, forks } = await this.worktreeState(target.repositoryId, vcs);
+		const resolved = { ...target };
+		const fork = () => {
+			const key = `${target.base ?? ""}\0${commit}`;
+			let found = forks.get(key);
+			if (!found) {
+				found = this.worktreeBase(vcs, target.base, commit);
+				forks.set(key, found);
+				found.catch((error) => {
+					if (!(error instanceof ReviewInputError)) forks.delete(key);
+				});
+			}
+			return found;
+		};
+		const base = pinned && target.base === void 0 ? pinned.base === "empty-worktree-baseline" ? EMPTY_SOURCE : commit : commit === "empty-worktree-baseline" && target.base === void 0 ? EMPTY_SOURCE : await fork().then((found) => {
+			resolved.base = found.ref;
+			return found.commit;
+		}, (error) => {
+			if (pinned && error instanceof ReviewInputError) return pinned.base;
+			throw error;
+		});
+		return {
+			target: resolved,
+			pins: {
+				repositoryId: target.repositoryId,
+				base,
+				head: commit,
+				worktreeRevision: revision
+			}
+		};
+	}
+	/** The fork point from `ref`, by default the repository's default branch. */
+	async worktreeBase(vcs, ref, head) {
+		const branch = ref ?? (await vcs.defaultBranch())?.ref;
+		if (!branch) throw new ReviewInputError("No default branch found (tried origin/HEAD, origin/main, origin/master, main and master). Supply target.base.");
+		if (!await vcs.resolveRevision(branch)) throw new ReviewInputError("Base revision does not exist.");
+		const fork = head === "empty-worktree-baseline" ? null : await vcs.mergeBase(branch, head);
+		if (!fork) throw new ReviewInputError(`${branch} shares no history with the checkout's HEAD.`);
+		return {
+			ref: branch,
+			commit: fork.commit
+		};
+	}
+	/** The PR's current comparison, fetched into a registered checkout of its repository. */
+	async resolvePullRequest(url, repository) {
+		const deps = this.options.pullRequests ?? defaultPullRequestDeps;
+		const { host, slug, number } = pullRequestAddress(url);
+		const checkout = await this.pullRequestCheckout(host, slug, repository, deps);
+		const pullRequest = await readPullRequest(url, deps);
+		const { head, base } = await fetchPullRequest({
+			...checkout,
+			pullRequest
+		}, deps);
+		const repositoryId = checkout.repositoryId;
+		return {
+			target: {
+				kind: "commits",
+				repositoryId,
+				head,
+				base
+			},
+			pins: {
+				repositoryId,
+				base,
+				head
+			},
+			title: pullRequest.title.trim() || `PR #${number}`
+		};
+	}
+	/** A registered checkout with a remote for host/owner/repo, and that remote. */
+	async pullRequestCheckout(host, slug, repository, deps) {
+		const registered = this.store.repositories();
+		const candidates = repository.id ? registered.filter((entry) => entry.id === repository.id) : [...registered.filter((entry) => entry.id === repository.preferred), ...registered.filter((entry) => entry.id !== repository.preferred)];
+		if (repository.id && candidates.length === 0) throw new ReviewInputError("Repository is not registered.", 404);
+		for (const { id } of candidates) {
+			if (!existsSync(this.store.repositoryPath(id))) continue;
+			const vcs = await this.vcs(id);
+			const gitDir = vcs && await gitCommonDir(vcs.rootPath);
+			if (!vcs || !gitDir) continue;
+			const remote = (await githubRemotes(gitDir, deps)).find((entry) => entry.host === host && entry.slug.toLowerCase() === slug.toLowerCase());
+			if (remote) return {
+				repositoryId: id,
+				rootPath: vcs.rootPath,
+				gitDir,
+				kind: vcs.kind,
+				remote: remote.name
+			};
+		}
+		const name = host === "github.com" ? slug : `${host}/${slug}`;
+		throw new ReviewInputError(repository.id ? `That checkout has no GitHub remote for ${name}. Add one, or omit repositoryId.` : `No registered checkout has a GitHub remote for ${name}. Register a checkout of ${name} with review_register_repository first, or pass a target.`, 404);
+	}
+	async resolvePins(repositoryId, base, head) {
+		const vcs = await this.vcs(repositoryId);
+		const [left, right] = vcs ? await Promise.all([vcs.resolveRevision(base), vcs.resolveRevision(head)]) : [null, null];
+		if (!left || !right) throw new ReviewInputError(`Base or head revision does not exist in the local checkout (${!left ? `base: ${base}` : `head: ${head}`}). Fetch the requested commits before authoring; in CI, configure checkout depth to include both revisions.`);
+		return {
+			repositoryId,
+			base: left.commit,
+			head: right.commit
+		};
+	}
+	/** Files each side's commit changed from one set of pins to another, under
+	* both names for a rename. A worktree has no commit to diff from. */
+	async filesChangedBetween(from, to) {
+		if (from.repositoryId !== to.repositoryId || from.worktreeRevision || to.worktreeRevision) return void 0;
+		const target = await this.vcsTarget(to.repositoryId);
+		const changed = async (side) => {
+			if (from[side] === to[side]) return /* @__PURE__ */ new Set();
+			const files = await diffFileSummariesTrees({
+				...target,
+				baseRef: from[side],
+				headRef: to[side]
+			});
+			return new Set(files.flatMap((file) => file.previousPath ? [file.previousPath, file.path] : [file.path]));
+		};
+		const [base, head] = await Promise.all([changed("base"), changed("head")]);
+		return {
+			base,
+			head
+		};
+	}
+	async validatePins(pins) {
+		if (pins.worktreeRevision) {
+			if (!await this.vcs(pins.repositoryId)) throw unavailableCheckout();
+			return;
+		}
+		const resolved = await this.resolvePins(pins.repositoryId, pins.base, pins.head);
+		if (resolved.base !== pins.base || resolved.head !== pins.head) throw new ReviewInputError("Use resolved commit IDs, not moving branch names.");
+	}
+	async file(pins, side, file, allowBinary = false) {
+		checkRelativePath(file);
+		const commit = pins[side];
+		const vcs = await this.vcs(pins.repositoryId);
+		const text = pins.worktreeRevision && side === "head" ? vcs ? await readWorkingFile(vcs.rootPath, file) : null : commit === "empty-worktree-baseline" ? null : vcs ? await readFileAtCommit({
+			rootPath: vcs.rootPath,
+			kind: vcs.kind,
+			commit,
+			relativePath: file,
+			reader: this.reader(pins.repositoryId, vcs)
+		}) : null;
+		if (text === null) throw new ReviewInputError("File is unavailable at the pinned commit.", 404);
+		if (!allowBinary && text.includes("\0")) throw new ReviewInputError("Binary files cannot be used as code references.");
+		return {
+			file,
+			side,
+			commit,
+			text
+		};
+	}
+	async tree(pins, side, directory) {
+		inputError(() => checkSourcePath(directory));
+		const prefix = directory ? directory.replace(/\/$/, "") + "/" : "";
+		const entries = /* @__PURE__ */ new Map();
+		const vcs = pins.worktreeRevision ? await this.vcs(pins.repositoryId) : void 0;
+		if (pins.worktreeRevision && !vcs) throw unavailableCheckout();
+		const files = vcs && side === "head" ? await workingFiles(vcs) : pins[side] === "empty-worktree-baseline" ? [] : await this.trackedFilesAt(pins.repositoryId, pins[side]);
+		for (const file of files) {
+			if (!file.startsWith(prefix)) continue;
+			const relative = file.slice(prefix.length);
+			const name = relative.split("/", 1)[0];
+			entries.set(name, {
+				path: prefix + name,
+				kind: relative.includes("/") ? "directory" : "file"
+			});
+		}
+		if (directory && entries.size === 0) throw new ReviewInputError("Directory is unavailable at the pinned commit.", 404);
+		return [...entries.values()];
+	}
+	trackedFilesAt(repositoryId, ref) {
+		const key = `${repositoryId}\0${ref}`;
+		let files = this.trackedFiles.get(key);
+		if (!files) {
+			files = this.vcs(repositoryId).then((vcs) => {
+				if (!vcs) {
+					this.trackedFiles.delete(key);
+					return [];
+				}
+				return listTrackedFilesAtCommit({
+					rootPath: vcs.rootPath,
+					kind: vcs.kind,
+					commit: ref
+				});
+			});
+			this.trackedFiles.set(key, files);
+			files.catch(() => this.trackedFiles.delete(key));
+		}
+		return files;
+	}
+	async validateSources(pins, sources) {
+		const files = /* @__PURE__ */ new Map();
+		for (const input of sources) {
+			const source = fileLineRangeSchema.parse(input);
+			const key = JSON.stringify([
+				pins[source.side],
+				pins.worktreeRevision ? source.side : null,
+				source.file
+			]);
+			const ranges = files.get(key);
+			if (ranges) ranges.push(source);
+			else files.set(key, [source]);
+		}
+		for (const ranges of files.values()) {
+			const first = ranges[0];
+			const file = await this.file(pins, first.side, first.file);
+			for (const source of ranges) sliceRange(file, source);
+		}
+	}
+	async quote(pins, source) {
+		source = fileLineRangeSchema.parse(source);
+		return sliceRange(await this.file(pins, source.side, source.file), source);
+	}
+	/** Every source reference must exist at the pins; only code peeks must also
+	* show something. */
+	async validateSource(pins, source, options) {
+		const quote = await this.quote(pins, source);
+		if (options.peek) inputError(() => requireVisibleSource(quote.text, source));
+	}
+	coverageCache = /* @__PURE__ */ new Map();
+	coverageAbort = new AbortController();
+	coverageListeners = /* @__PURE__ */ new Set();
+	coverageRevision = 0;
+	subscribeCoverage(listener) {
+		this.coverageListeners.add(listener);
+		return () => {
+			this.coverageListeners.delete(listener);
+		};
+	}
+	/** Start shared coverage work without occupying an HTTP request until it completes. */
+	coveragePending(reviewId, pins, mode) {
+		const key = JSON.stringify([pins, mode]);
+		const existing = this.coverageCache.get(key);
+		if (existing?.state === "error") {
+			this.coverageCache.delete(key);
+			throw existing.error;
+		}
+		this.coverage(reviewId, pins, mode).catch(() => {});
+		return this.coverageCache.get(key).state === "pending";
+	}
+	coverageSnapshot(reviewId, pins, mode) {
+		return {
+			pending: this.coveragePending(reviewId, pins, mode),
+			comparison: this.coverageCache.get(JSON.stringify([pins, mode])).partial ?? {
+				files: [],
+				fileSources: /* @__PURE__ */ new Map(),
+				alignments: /* @__PURE__ */ new Map()
+			}
+		};
+	}
+	coverageNotification;
+	notifyCoverage() {
+		if (this.closed || this.coverageNotification) return;
+		this.coverageNotification = setTimeout(() => {
+			this.coverageNotification = void 0;
+			this.coverageRevision++;
+			for (const listener of this.coverageListeners) listener();
+		}, 50);
+	}
+	coverage(reviewId, pins, mode) {
+		const key = JSON.stringify([pins, mode]);
+		let entry = this.coverageCache.get(key);
+		if (!entry || entry.state === "error") {
+			const promise = comparisonCoverage(this, reviewId, pins, mode, this.coverageAbort.signal, (partial) => {
+				const current = this.coverageCache.get(key);
+				if (current) current.partial = partial;
+				this.notifyCoverage();
+			});
+			entry = {
+				promise,
+				state: "pending"
+			};
+			this.coverageCache.set(key, entry);
+			const current = entry;
+			const settled = (state, error) => {
+				current.state = state;
+				current.error = error;
+				this.notifyCoverage();
+				for (const [cachedKey, cached] of this.coverageCache) {
+					if (this.coverageCache.size <= 32) break;
+					if (cached.state !== "pending" && cachedKey !== key) this.coverageCache.delete(cachedKey);
+				}
+			};
+			promise.then((value) => {
+				current.partial = value;
+				if (!this.closed) this.store.setDiffStats(pins, {
+					fileCount: value.files.length,
+					additions: value.files.reduce((sum, file) => sum + structuralChangeCounts(file.changed).added, 0),
+					deletions: value.files.reduce((sum, file) => sum + structuralChangeCounts(file.changed).removed, 0)
+				}, mode);
+				settled("ready");
+			}, (error) => settled("error", error));
+		}
+		return entry.promise;
+	}
+	async changes(pins, file) {
+		if (file === void 0) return this.summaries(pins);
+		checkRelativePath(file);
+		return this.rawPatch(pins, { paths: [file] });
+	}
+	async summaries(pins) {
+		if (pins.worktreeRevision) return diffFileSummariesWorkingTree(await this.worktreeInput(pins));
+		return diffFileSummariesTrees({
+			...await this.vcsTarget(pins.repositoryId),
+			baseRef: pins.base,
+			headRef: pins.head
+		});
+	}
+	/** Raw Git patch text for exact filenames, or every change. */
+	async rawPatch(pins, options) {
+		if (pins.worktreeRevision) return diffWorkingTree({
+			...await this.worktreeInput(pins),
+			...options
+		});
+		return diffTrees({
+			...await this.vcsTarget(pins.repositoryId),
+			baseRef: pins.base,
+			headRef: pins.head,
+			...options,
+			literalPaths: options.paths !== void 0
+		});
+	}
+	async worktreeInput(pins) {
+		const vcs = await this.vcs(pins.repositoryId);
+		if (!vcs) throw unavailableCheckout();
+		return {
+			rootPath: vcs.rootPath,
+			kind: vcs.kind,
+			baseRef: pins.base === "empty-worktree-baseline" ? void 0 : pins.base,
+			headRef: pins.head === "empty-worktree-baseline" ? void 0 : pins.head
+		};
+	}
+	commits(pins) {
+		if (pins.base === pins.head || pins.base === "empty-worktree-baseline" || pins.head === "empty-worktree-baseline") return Promise.resolve([]);
+		const key = `${pins.repositoryId}:${pins.base}:${pins.head}`;
+		const cached = this.commitRanges.get(key);
+		if (cached) return cached;
+		const pending = this.readCommitRange(pins).catch((cause) => {
+			this.commitRanges.delete(key);
+			throw cause;
+		});
+		this.commitRanges.set(key, pending);
+		return pending;
+	}
+	async readCommitRange(pins) {
+		return listCommitRange({
+			...await this.vcsTarget(pins.repositoryId),
+			baseRef: pins.base,
+			headRef: pins.head
+		});
+	}
+	async comparison(pins, commit) {
+		if (!commit) return pins;
+		const selected = (await this.commits(pins)).find((item) => item.commit === commit);
+		if (!selected) throw new ReviewInputError("The selected commit is not part of this review version.", 404);
+		return {
+			repositoryId: pins.repositoryId,
+			base: selected.parentCommit,
+			head: selected.commit
+		};
+	}
+	async map(documentPins, resourceId) {
+		await this.validateResource(documentPins, {
+			type: "software_map",
+			mapVersionId: resourceId
+		});
+		const resource = this.store.resource(resourceId);
+		const saved = JSON.parse(Buffer.from(resource.data).toString());
+		const pins = documentPins ?? {
+			repositoryId: resource.repositoryId,
+			base: saved.commit,
+			head: saved.commit
+		};
+		const target = await this.vcsTarget(pins.repositoryId);
+		const resolved = await resolveSoftwareMapDiffCounts({
+			patch: pins.worktreeRevision ? await diffWorkingTree({
+				...target,
+				kind: target.kind ?? "git",
+				baseRef: pins.base === "empty-worktree-baseline" ? void 0 : pins.base,
+				headRef: pins.head === "empty-worktree-baseline" ? void 0 : pins.head
+			}) : void 0,
+			sourceRootPath: target.rootPath,
+			sourceVcsKind: target.kind,
+			baseRef: pins.base,
+			headRef: pins.head,
+			side: saved.side,
+			codeElements: saved.elements.filter((element) => element.type === "codeElement"),
+			coverageClaims: saved.elements.flatMap((element) => element.coverage ? [{
+				path: element.path,
+				...element.coverage
+			}] : [])
+		});
+		return {
+			...saved,
+			countsByElementPath: resolved.countsByElementPath,
+			unmappedByElementPath: resolved.unmappedByElementPath
+		};
+	}
+	async upload(value) {
+		const input = uploadSchema.parse(value);
+		this.store.repositoryPath(input.repositoryId);
+		let mimeType = "application/json", data;
+		switch (input.kind) {
+			case "image":
+				data = await decodeImage(Buffer.from(input.base64, "base64"));
+				mimeType = "image/png";
+				break;
+			case "trace":
+				if (new Set(input.trace.events.map((event) => event.id)).size !== input.trace.events.length) throw new ReviewInputError("Trace event IDs must be unique.");
+				data = Buffer.from(JSON.stringify({
+					...input.trace,
+					provenance: "client_supplied"
+				}));
+				break;
+			case "map": {
+				if (input.pins.repositoryId !== input.repositoryId) throw new ReviewInputError("Map belongs to a different repository.");
+				await this.validatePins(input.pins);
+				let model;
+				try {
+					model = defineSoftwareMap(input.model);
+				} catch (error) {
+					if (error instanceof SoftwareModelValidationError) throw new ReviewInputError(error.message);
+					throw error;
+				}
+				const files = /* @__PURE__ */ new Map();
+				await Promise.all(model.elements.flatMap((element) => (element.sourceRanges ?? []).map(async (source) => {
+					const range = fileLineRangeSchema.parse({
+						...source,
+						side: input.side
+					});
+					let read = files.get(range.file);
+					if (!read) files.set(range.file, read = this.file(input.pins, range.side, range.file));
+					sliceRange(await read, range);
+				})));
+				data = Buffer.from(JSON.stringify({
+					commit: input.pins[input.side],
+					side: input.side,
+					elements: model.elements,
+					relationships: model.relationships
+				}));
+				break;
+			}
+		}
+		return this.store.putResource(input.id, input.repositoryId, input.kind, mimeType, data);
+	}
+	/** A resource must belong to the document's repository when it has one;
+	* a document without pins may use any registered repository's resources. */
+	async validateResource(pins, block) {
+		const reference = resourceReference(block);
+		if (!reference) return;
+		const { id, kind } = reference;
+		const resource = this.store.resource(id);
+		if (pins && resource.repositoryId !== pins.repositoryId || resource.kind !== kind) throw new ReviewInputError("Resource belongs to a different repository or component type.");
+		if (!pins) this.store.repositoryPath(resource.repositoryId);
+		if (block.type === "trace_quote") {
+			const event = traceSchema.parse(JSON.parse(Buffer.from(resource.data).toString())).events.find((event) => event.id === block.eventId);
+			if (!event || !textIncludesQuote(event.text, block.text)) throw new ReviewInputError("Quote does not match the retained trace event.");
+		}
+		if (block.type === "software_map") {
+			const map = JSON.parse(Buffer.from(resource.data).toString());
+			if (pins && map.commit !== pins[map.side]) throw new ReviewInputError("Map does not match this review's source pins.");
+			if (block.focusElementId && !map.elements.some((element) => element.id === block.focusElementId || element.path === block.focusElementId)) throw new ReviewInputError("Map focus element does not exist.");
+		}
+	}
+};
+/** The pure source checks throw their own error; API clients see it as input. */
+function inputError(run) {
+	try {
+		return run();
+	} catch (error) {
+		if (error instanceof SourceRangeError) throw new ReviewInputError(error.message);
+		throw error;
+	}
+}
+function openLocalReviewStore(databasePath, options = {}) {
+	const store = new ReviewStore(databasePath, {
+		projectSource: (snapshot, pins) => data.projectSource(snapshot, pins),
+		resolveTarget: (target, pinned) => data.resolveTarget(target, pinned),
+		resolvePullRequest: (url, repository) => data.resolvePullRequest(url, repository),
+		headBranch: (pins, headRef) => data.headBranch(pins, headRef),
+		sourcePins: (snapshot) => data.sourcePins(snapshot),
+		unavailableAnchors: (snapshot) => data.unavailableAnchors(snapshot),
+		validatePins: (pins) => data.validatePins(pins),
+		filesChangedBetween: (from, to) => data.filesChangedBetween(from, to),
+		validateSource: (pins, source, options) => data.validateSource(pins, source, options),
+		validateResource: (pins, block) => data.validateResource(pins, block)
+	});
+	let data;
+	try {
+		data = new LocalReviewData(store, {
+			...options,
+			workspaceDatabase: `${databasePath}.workspaces`
+		});
+	} catch (error) {
+		store.close();
+		throw error;
+	}
+	return {
+		store,
+		data
+	};
+}
+/** The parts of a VS Code workspace file the navigator owns; everything else
+* VS Code or the user adds is kept as is. */
+const codeWorkspaceSchema = z.looseObject({
+	folders: z.array(z.json()).default([]),
+	settings: z.record(z.string(), z.json()).default({})
+});
+/** A workspace file's contents, undefined when it does not exist, or null when
+* it is not plain JSON (VS Code accepts comments), which is left untouched. */
+async function readWorkspace(file) {
+	const text = await readFile(file, "utf8").catch((error) => {
+		if (isMissingFileError(error)) return void 0;
+		throw error;
+	});
+	if (text === void 0) return void 0;
+	try {
+		return codeWorkspaceSchema.safeParse(JSON.parse(text)).data ?? null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { invalidateStructuralComparisons as _, inspectSnapshot as a, installFullDiffr as b, askAgentIds as c, askQuestionSchema as d, AgentSelectionSchema as f, activityUpdateSchema as g, activityEndSchema as h, commandSchema as i, askChoiceKinds as l, activityBeginSchema as m, uploadSchema as n, initializeReviewStoreSchema as o, selectionMarkdown as p, SCRATCHPAD_ID as r, applyAskChange as s, openLocalReviewStore as t, askPicksSchema as u, diffrExecutable as v, diffrMissingError as y };