@dev.fast/whiteboard 0.3.4 → 0.3.5-preview.20261021.131

package/dist/{local-data-D_9tvdsp.js → local-data-mbCb1HDH.js}

@@ -1,22 +1,24 @@
-import { _ as parseGitRemote, a as diff, b as resolveRepoContextSync, c as diffFileSummariesWorkingTree, d as git, g as listTrackedFilesAtCommit, h as listCommitRange, i as detectLocalVcs, l as diffTrees, m as jjRevisionIsConflicted, n as createBlobBatchReader, p as gitCommonDir, s as diffFileSummariesTrees, t as LocalVcsToolsMissingError, u as diffWorkingTree, v as readFileAtCommit, x as resolveRevision, y as resolveRepoContext } from "./src-BMPuxWv4.js";
-import { c as jsonString, o as jsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
-import { N as decodeStructuralDiffEvent, P as structuralChangeCounts, j as SCRATCHPAD_REVIEW_ID } from "./src-DsM3jO8G.js";
-import { s as safeStorageSegment } from "./review-home-paths-j2BRAaNv.js";
-import { $ as intersectIntervals, A as documentAdvice, B as requireVisibleSource, C as resourceReference, D as sourceReferences, I as lensSelections, L as SourceRangeError, N as applyLensEdit, O as summarizeEdit, P as lensEditSchema, Q as emptyCoverage, R as checkSourcePath, T as reviewTargetSchema, V as sliceSourceRange, X as coverageSchema, Y as sourceAnchors, a as defineSoftwareMap, b as pinnedRepositoryIds, c as traceSchema, d as applyEdit, f as assignFreshIds, g as explicitPins, h as elements, i as SoftwareModelValidationError, k as checkReferences, l as textIncludesQuote, m as editSchema, n as migrateStoredDocument, nt as unionIntervals, p as documentSchema, r as migrateStoredLenses, rt as updateCoverage, t as liftFileLenses, tt as subtractIntervals, u as anchorPins, v as isUnit, w as resourceReferences, x as pinsSchema, z as fileLineRangeSchema } from "./stored-document-migration-CChxtFAy.js";
+import { C as renderVcsArgs, T as runVcsSync, _ as listTrackedFilesAtCommit, a as diff, b as resolveRepoContext, c as diffFileSummariesWorkingTree, d as git, g as listCommitRange, h as jjRevisionIsConflicted, i as detectLocalVcs, l as diffTrees, m as gitCommonDirSync, n as createBlobBatchReader, p as gitCommonDir, s as diffFileSummariesTrees, t as LocalVcsToolsMissingError, u as diffWorkingTree, v as parseGitRemote, w as runVcs, x as resolveRevision, y as readFileAtCommit } from "./src-DtfSndqS.js";
+import { c as jsonString, m as isStringValue, n as isJsonObject, o as jsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
+import { F as structuralChangeCounts, P as decodeStructuralDiffEvent, c as boardIconKind, l as boardTitle } from "./src-DYZLCUP_.js";
+import { s as safeStorageSegment } from "./review-home-paths-BwH08ihj.js";
+import { b as updateCoverage, c as parseAnchor, f as sourceAnchors, g as intersectIntervals, h as emptyCoverage, p as coverageSchema, v as subtractIntervals, y as unionIntervals } from "./lens-selection-BxPk53c8.js";
+import { $ as parseMarkdown, A as resourceReferences, E as pinsSchema, G as lensSelections, H as applyLensEdit, I as sourceReferences, J as fileLineRangeSchema, K as SourceRangeError, L as summarizeEdit, M as respellDocumentLinks, N as respellEditLinks, P as reviewTargetSchema, Q as markdownText, R as checkReferences, S as explicitPins, T as pinnedRepositoryIds, U as lensEditSchema, X as sliceSourceRange, Y as requireVisibleSource, Z as markdownNodes, _ as boardRepositoryId, a as SoftwareModelValidationError, b as editSchema, d as adoptFlowUnits, f as anchorPins, g as boardLinks, h as assignMissingIds, i as readStoredDocument, j as respellCommitLinks, k as resourceReference, l as traceSchema, m as assignFreshIds, n as migrateStoredDocument, o as defineSoftwareMap, p as applyEdit, q as checkSourcePath, r as migrateStoredLenses, u as textIncludesQuote, v as commitLinkCommits, w as pinDocumentReferences, x as elements, y as documentSchema, z as documentAdvice } from "./stored-document-migration-B29lve9-.js";
 import { t as ReviewInputError } from "./input-error-OLgB_h31.js";
-import { A as processStartIdentity, L as writePrivateJsonAtomic, O as pidReused, j as withFileLock, k as processIsAlive } from "./s3-config-BTO12tCC.js";
+import { A as processStartIdentity, L as writePrivateJsonAtomic, O as pidReused, j as withFileLock, k as processIsAlive } from "./s3-config-CjcLyFV5.js";
 import { t as errorMessage } from "./error-message-OtiDonty.js";
 import { r as isMissingFileError } from "./fs-utils-BMPLt0cr.js";
-import { a as askHistoryEntrySchema, i as askEntrySchema, o as askOfferSchema, s as askPermissionsSchema } from "./thread-state-5pYr6_zM.js";
+import { a as askHistoryEntrySchema, i as askEntrySchema, o as askOfferSchema, s as askPermissionsSchema } from "./thread-state-BPpvKFwQ.js";
 import { createRequire } from "node:module";
 import crypto, { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
-import { existsSync, realpathSync, rmSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } 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 { homedir } from "node:os";
 import { execFile, spawn } from "node:child_process";
-import { promisify } from "node:util";
+import { isDeepStrictEqual, promisify } from "node:util";
 import { DatabaseSync } from "node:sqlite";
 import { createInterface } from "node:readline";
 //#region ../../diffr/diffr-ts/dist/binary.js
@@ -93,6 +95,366 @@ function structuralRows(diff) {
 	return rows;
 }
 //#endregion
+//#region src/review-api/azure-remote.ts
+const REMOTE_URLS = [
+	/^https:\/\/(?:[^@]+@)?dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/]+?)(?:\.git)?\/?$/,
+	/^https:\/\/([^.]+)\.visualstudio\.com\/(?:DefaultCollection\/)?([^/]+)\/_git\/([^/]+?)(?:\.git)?\/?$/,
+	/^git@ssh\.dev\.azure\.com:v3\/([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/,
+	/^[^@]+@vs-ssh\.visualstudio\.com:v3\/([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/
+];
+/** org/project/repository, decoded; undefined for malformed escapes. */
+function slugOf(patterns, url) {
+	const match = patterns.map((pattern) => pattern.exec(url)).find(Boolean);
+	try {
+		return match && match.slice(1, 4).map(decodeURIComponent).join("/");
+	} catch {
+		return;
+	}
+}
+function azureRepositoryOf(remoteUrl) {
+	return slugOf(REMOTE_URLS, remoteUrl.trim());
+}
+//#endregion
+//#region src/review-api/checkout-groups.ts
+/** A command's output, or undefined if it fails; the runner's rules (no
+* lazy fetch, no prompt, a timeout) apply. */
+function quietly(tool, args, options = {}) {
+	try {
+		return runVcsSync(tool, args, {
+			cwd: options.cwd,
+			input: options.input,
+			encoding: "utf8",
+			stdio: [
+				options.input === void 0 ? "ignore" : "pipe",
+				"pipe",
+				"ignore"
+			],
+			maxBuffer: 67108864
+		});
+	} catch {
+		return;
+	}
+}
+/** A path with its parent's symlinks resolved, for a path that may be gone. */
+function canonicalPath(file) {
+	try {
+		return path.join(realpathSync(path.dirname(file)), path.basename(file));
+	} catch {
+		return path.resolve(file);
+	}
+}
+/** The git directory a checkout's worktrees share, read from its `.git`
+* without running git; undefined when that can't be read so. */
+function commonDirOf(root) {
+	const dotGit = path.join(root, ".git");
+	try {
+		if (statSync(dotGit).isDirectory()) return realpathSync(dotGit);
+		const gitdir = /^gitdir:\s*(.+)$/m.exec(readFileSync(dotGit, "utf8"))?.[1];
+		if (!gitdir) return void 0;
+		const own = path.resolve(root, gitdir.trim());
+		try {
+			return realpathSync(path.resolve(own, readFileSync(path.join(own, "commondir"), "utf8").trim()));
+		} catch {
+			return realpathSync(own);
+		}
+	} catch {
+		return;
+	}
+}
+/** The origin remote's URL from a git config file; undefined when the file
+* can't settle it (a URL rewrite, an include), so git must be asked. */
+function originUrlOf(commonDir) {
+	let config;
+	try {
+		config = readFileSync(path.join(commonDir, "config"), "utf8");
+	} catch {
+		return;
+	}
+	if (/insteadof|^\s*\[include/im.test(config)) return void 0;
+	const section = /^\s*\[remote\s+"origin"\]([^[]*)/im.exec(config)?.[1];
+	return section ? /^\s*url\s*=\s*(.+)$/im.exec(section)?.[1]?.trim() ?? null : null;
+}
+/** Undefined for a URL no forge parses. */
+function remoteGroup(url) {
+	const azure = azureRepositoryOf(url);
+	if (azure) return {
+		key: `remote:dev.azure.com/${azure.toLowerCase()}`,
+		label: azure
+	};
+	const remote = parseGitRemote(url);
+	return remote ? {
+		key: `remote:${remote.host}/${remote.slug.toLowerCase()}`,
+		label: remote.slug
+	} : void 0;
+}
+function groupOf(commonDir, origin) {
+	return origin && remoteGroup(origin) || {
+		key: `git:${commonDir}`,
+		label: path.basename(path.dirname(commonDir))
+	};
+}
+/** A checkout's repository group; undefined if it isn't a readable git
+* checkout. Reads `.git` and its config directly where it can, so many
+* checkouts group in a moment; git answers the rest. */
+function repositoryGroupAt(root) {
+	if (!existsSync(root)) return void 0;
+	const commonDir = commonDirOf(root);
+	const origin = commonDir ? originUrlOf(commonDir) : void 0;
+	if (commonDir && origin !== void 0) return groupOf(commonDir, origin);
+	const resolved = gitCommonDirSync(root);
+	if (!resolved) return void 0;
+	return groupOf(resolved, quietly("git", [
+		"--git-dir",
+		resolved,
+		"remote",
+		"get-url",
+		"origin"
+	])?.trim() || null);
+}
+/** The probe that reads `.git` directly, running git only where it must. */
+const gitCheckoutProbe = {
+	groupAt: repositoryGroupAt,
+	worktreesOf(root) {
+		const commonDir = commonDirOf(root) ?? gitCommonDirSync(root) ?? void 0;
+		if (!commonDir) return void 0;
+		let entries = [];
+		try {
+			entries = readdirSync(path.join(commonDir, "worktrees"));
+		} catch {}
+		return {
+			commonDir,
+			worktrees: entries.flatMap((entry) => {
+				try {
+					const gitdir = readFileSync(path.join(commonDir, "worktrees", entry, "gitdir"), "utf8").trim();
+					return [path.dirname(gitdir)];
+				} catch {
+					return [];
+				}
+			})
+		};
+	},
+	commitsIn: (commonDir, commits) => commitsListed(quietly("git", [
+		"--git-dir",
+		commonDir,
+		"cat-file",
+		"--batch-check"
+	], { input: commits.join("\n") + "\n" })),
+	findCommits: async (commonDir, commits) => commitsListed(await runVcs("git", [
+		"--git-dir",
+		commonDir,
+		"cat-file",
+		"--batch-check"
+	], {
+		input: commits.join("\n") + "\n",
+		maxBuffer: 67108864
+	}).then(({ stdout }) => stdout, () => void 0))
+};
+/** How many repositories are asked about commits at once. */
+const PARALLEL_GIT = 8;
+/**
+* How a store's checkouts group into projects, worked out in one pass and
+* kept for the life of the process. `prepare` asks each checkout still on
+* disk for its group and its worktrees, once each, before an upgrade takes
+* the write lock; projects are then assigned from the maps it builds,
+* without touching git. A deleted checkout joins the checkout that lists it
+* as a worktree, else one whose repository has the commits its boards
+* pinned (a pruned worktree's history lives on in its repository),
+* preferring the one whose folder held it; unmatched, it gets its own
+* project.
+*/
+var CheckoutGroups = class {
+	db;
+	probe;
+	groups = /* @__PURE__ */ new Map();
+	owners;
+	constructor(db, probe = gitCheckoutProbe, prepared) {
+		this.db = db;
+		this.probe = probe;
+		this.owners = prepared;
+	}
+	/** A checkout's group, asked once per path. */
+	group(root) {
+		if (!this.groups.has(root)) {
+			let group;
+			if (existsSync(root)) try {
+				group = this.probe.groupAt(root);
+			} catch {
+				group = void 0;
+			}
+			this.groups.set(root, group);
+		}
+		return this.groups.get(root);
+	}
+	/** A file as a commit has it, or undefined if this repository can't say
+	* without fetching. */
+	fileAt(root, commit, file) {
+		return quietly("git", [
+			"-C",
+			root,
+			"show",
+			{ rev: `${commit}:${file}` }
+		]);
+	}
+	/** Works everything out now, ahead of a migration that needs it. */
+	prepare() {
+		if (this.owners) return;
+		const finding = this.findOwners();
+		let step = finding.next();
+		while (!step.done) step = finding.next(new Map([...step.value].map(([commonDir, commits]) => [commonDir, this.commitsIn(commonDir, commits)])));
+		this.owners = step.value;
+	}
+	/** As `prepare`, asking several repositories at once: before a store
+	* opens, while nothing waits on its write lock yet. */
+	async prepareConcurrently() {
+		if (this.owners) return;
+		const finding = this.findOwners();
+		let step = finding.next();
+		while (!step.done) {
+			const questions = [...step.value];
+			const answers = /* @__PURE__ */ new Map();
+			const ask = async () => {
+				for (let next = questions.shift(); next; next = questions.shift()) {
+					const [commonDir, commits] = next;
+					answers.set(commonDir, await this.findCommits(commonDir, commits));
+				}
+			};
+			await Promise.all(Array.from({ length: PARALLEL_GIT }, ask));
+			step = finding.next(answers);
+		}
+		this.owners = step.value;
+	}
+	/** The grouping `prepare` worked out, to hand to another connection's. */
+	get prepared() {
+		return this.owners;
+	}
+	ownerOf(repositoryId) {
+		this.prepare();
+		return this.owners.get(repositoryId);
+	}
+	repositories() {
+		return this.db.prepare("SELECT id, path FROM repositories").all();
+	}
+	commitsIn(commonDir, commits) {
+		try {
+			return this.probe.commitsIn(commonDir, commits);
+		} catch {
+			return /* @__PURE__ */ new Set();
+		}
+	}
+	async findCommits(commonDir, commits) {
+		try {
+			return await (this.probe.findCommits?.(commonDir, commits) ?? this.probe.commitsIn(commonDir, commits));
+		} catch {
+			return /* @__PURE__ */ new Set();
+		}
+	}
+	/** Works out each deleted checkout's owner, yielding the questions for
+	* git it needs answered: once about the commits boards pin now, and
+	* again about older ones only for a checkout those leave unsettled. */
+	*findOwners() {
+		const owners = /* @__PURE__ */ new Map();
+		const existing = [];
+		const deleted = [];
+		for (const { id, path: root } of this.repositories()) (existsSync(String(root)) ? existing : deleted).push({
+			id: String(id),
+			root: String(root)
+		});
+		const listed = /* @__PURE__ */ new Map();
+		const repositories = /* @__PURE__ */ new Map();
+		const repositoryOf = /* @__PURE__ */ new Map();
+		for (const checkout of existing) {
+			this.group(checkout.root);
+			if (!deleted.length) continue;
+			let found;
+			try {
+				found = this.probe.worktreesOf(checkout.root);
+			} catch {
+				found = void 0;
+			}
+			if (!found) continue;
+			repositoryOf.set(checkout.id, found.commonDir);
+			if (repositories.has(found.commonDir)) continue;
+			repositories.set(found.commonDir, checkout.id);
+			for (const worktree of found.worktrees) listed.set(canonicalPath(worktree), checkout.id);
+		}
+		for (const gone of deleted) {
+			const owner = listed.get(canonicalPath(gone.root));
+			if (owner) owners.set(gone.id, owner);
+		}
+		const folders = existing.map((checkout) => ({
+			id: checkout.id,
+			folder: canonicalPath(checkout.root) + path.sep
+		}));
+		const containers = (gone) => {
+			const at = canonicalPath(gone.root);
+			return folders.flatMap(({ id, folder }) => at.startsWith(folder) && repositoryOf.has(id) ? [{
+				id,
+				commonDir: repositoryOf.get(id)
+			}] : []);
+		};
+		const unmatched = deleted.filter(({ id }) => !owners.has(id));
+		const now = this.pinnedCommits(new Set(unmatched.map(({ id }) => id)), "current");
+		const historyFirst = unmatched.some(({ id }) => !now.has(id));
+		const pinned = historyFirst ? this.pinnedCommits(new Set(unmatched.map(({ id }) => id)), "all") : now;
+		const having = /* @__PURE__ */ new Map();
+		if (pinned.size) {
+			const answers = yield questionsFor(repositories, pinned);
+			for (const [gone, theirs] of pinned) having.set(gone, repositoriesWith(repositories, answers, theirs));
+		}
+		const unsettled = historyFirst ? [] : unmatched.filter(({ id, root }) => {
+			const first = containers({ root })[0]?.commonDir ?? repositories.keys().next().value;
+			return !having.get(id)?.includes(first ?? "");
+		});
+		if (unsettled.length) {
+			const older = new Map([...this.pinnedCommits(new Set(unsettled.map(({ id }) => id)), "all")].map(([gone, commits]) => [gone, commits.filter((commit) => !now.get(gone)?.includes(commit))]));
+			const answers = yield questionsFor(repositories, older);
+			for (const [gone, theirs] of older) {
+				const more = repositoriesWith(repositories, answers, theirs);
+				const known = having.get(gone) ?? [];
+				having.set(gone, [...repositories.keys()].filter((commonDir) => known.includes(commonDir) || more.includes(commonDir)));
+			}
+		}
+		for (const gone of unmatched) {
+			const withCommits = having.get(gone.id);
+			if (!withCommits?.length) continue;
+			const container = containers(gone).find(({ commonDir }) => withCommits.includes(commonDir));
+			owners.set(gone.id, container?.id ?? repositories.get(withCommits[0]));
+		}
+		return owners;
+	}
+	/** The commits each of these checkouts' boards pin: in their current
+	* versions, or in every version. */
+	pinnedCommits(checkouts, versions) {
+		const pinned = /* @__PURE__ */ new Map();
+		if (!checkouts.size) return pinned;
+		for (const row of this.db.prepare(`SELECT json_extract(snapshot,'$.pins.repositoryId') AS repository,
+          json_extract(snapshot,'$.pins.head') AS head,
+          json_extract(snapshot,'$.pins.base') AS base
+        FROM ${versions === "current" ? "reviews CROSS JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version" : "versions"}
+        WHERE json_valid(snapshot) AND json_type(snapshot,'$.pins')='object'`).all()) {
+			const repository = String(row.repository);
+			if (!checkouts.has(repository)) continue;
+			const commits = pinned.get(repository) ?? [];
+			for (const commit of [String(row.head), String(row.base)]) if (/^[0-9a-f]{40}$/.test(commit) && !/^0+$/.test(commit) && !commits.includes(commit)) commits.push(commit);
+			if (commits.length) pinned.set(repository, commits);
+		}
+		return pinned;
+	}
+};
+/** Every repository asked about every commit pinned. */
+function questionsFor(repositories, pinned) {
+	const commits = [...new Set([...pinned.values()].flat())];
+	return new Map(commits.length ? [...repositories.keys()].map((commonDir) => [commonDir, commits]) : []);
+}
+/** The repositories, in order, that have any of these commits. */
+function repositoriesWith(repositories, answers, commits) {
+	return [...repositories.keys()].filter((commonDir) => commits.some((commit) => answers.get(commonDir)?.has(commit)));
+}
+/** The commits `git cat-file --batch-check` found. */
+function commitsListed(output) {
+	return new Set((output ?? "").split("\n").filter((line) => / commit /.test(line)).map((line) => line.split(" ")[0]));
+}
+//#endregion
 //#region src/review-checkout-paths.ts
 /**
 * Root for Review-owned checkouts. A Review UUID identifies one subtree.
@@ -500,6 +862,7 @@ var StructuralComparisons = class {
 		input.signal.throwIfAborted();
 		const key = JSON.stringify([
 			configGeneration,
+			await classificationStamp(input.repositoryPath),
 			input.repositoryPath,
 			input.comparison,
 			input.paths
@@ -530,6 +893,30 @@ var StructuralComparisons = class {
 	}
 };
 let configGeneration = 0;
+const classificationFiles = /* @__PURE__ */ new Map();
+/** Git attribute and diffr config files that diffr's classifier reads. */
+function classificationInputs(root) {
+	let files = classificationFiles.get(root);
+	if (!files) {
+		const config = process.env.XDG_CONFIG_HOME || path.join(homedir(), ".config");
+		const diffrDirectory = process.env.DIFFR_CONFIG_DIR || path.join(config, "diffr");
+		files = Promise.all([gitCommonDir(root), git(root, [
+			"config",
+			"--path",
+			"core.attributesFile"
+		], { allowFailure: true })]).then(([common, user]) => [
+			...common ? [path.join(common, "info", "attributes")] : [],
+			path.join(root, ".gitattributes"),
+			user.stdout.trim() || path.join(config, "git", "attributes"),
+			path.join(diffrDirectory, "config.toml")
+		]);
+		classificationFiles.set(root, files);
+	}
+	return files;
+}
+async function classificationStamp(root) {
+	return Promise.all((await classificationInputs(root)).map((file) => stat(file).then(({ mtimeMs, size }) => [mtimeMs, size], () => null)));
+}
 function invalidateStructuralComparisons() {
 	configGeneration++;
 }
@@ -1226,26 +1613,31 @@ const mapInputSchema = z.strictObject({
 });
 //#endregion
 //#region src/review-api/pull-request.ts
+const execFileAsync = promisify(execFile);
 const FETCH_TIMEOUT_MS = 12e4;
 const LOCAL_TIMEOUT_MS = 3e4;
 const defaultPullRequestDeps = {
-	run: (file, args, options) => new Promise((resolve, reject) => {
-		execFile(file, args, {
+	run: async (file, args, options) => {
+		const spawnOptions = {
 			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}`));
-		});
-	}),
+		};
+		try {
+			return (file === "az" || file === "cmd.exe" ? await execFileAsync(file, renderVcsArgs(args), {
+				...spawnOptions,
+				encoding: "utf8"
+			}) : await runVcs(file, args, spawnOptions)).stdout;
+		} catch (error) {
+			const failure = error;
+			const reason = failure.killed ? `timed out after ${options.timeoutMs / 1e3}s` : String(failure.stderr ?? "").trim() || errorMessage(error);
+			throw new Error(`${file} ${String(args[0])}: ${reason}`);
+		}
+	},
 	fetch: (input, init) => fetch(input, init)
 };
 /** Remotes by their configured URL, not the insteadOf rewrite: a mirror
@@ -1298,32 +1690,45 @@ async function fetchPullRequest(input, deps) {
 		"--no-tags",
 		"--no-write-fetch-head",
 		"--quiet",
-		input.remote,
+		{ remote: input.remote },
 		...refspecs
 	], FETCH_TIMEOUT_MS);
 	const commit = (ref) => git([
 		"rev-parse",
 		"--verify",
 		"--quiet",
-		`${ref}^{commit}`
+		{ rev: `${ref}^{commit}` }
 	]).catch(() => void 0);
 	const mergeBase = (left, right) => git([
 		"merge-base",
-		left,
-		right
+		{ rev: left },
+		{ rev: 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);
+		if (!await commit(pr.baseRefOid)) await fetchRefs({ refspec: {
+			from: pr.baseRefOid,
+			to: refs.frozenBase,
+			force: true
+		} }).catch(() => void 0);
 		return commit(pr.baseRefOid);
 	};
 	let baseTip;
+	const pullHead = { refspec: {
+		from: pr.headRef,
+		to: refs.head,
+		force: true
+	} };
 	try {
-		await fetchRefs(`+${pr.headRef}:${refs.head}`, `+refs/heads/${pr.baseRefName}:${refs.base}`);
+		await fetchRefs(pullHead, { refspec: {
+			from: `refs/heads/${pr.baseRefName}`,
+			to: refs.base,
+			force: true
+		} });
 		baseTip = await commit(refs.base);
 	} catch (error) {
 		try {
-			await fetchRefs(`+${pr.headRef}:${refs.head}`);
+			await fetchRefs(pullHead);
 		} 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);
 		}
@@ -1365,8 +1770,8 @@ async function indexForJj(rootPath, commits, git, deps) {
 	try {
 		for (const [index, tag] of tags.entries()) await git([
 			"update-ref",
-			tag,
-			commits[index]
+			{ ref: tag },
+			{ commit: commits[index] }
 		]);
 		await jjImport();
 	} finally {
@@ -1378,6 +1783,15 @@ async function indexForJj(rootPath, commits, git, deps) {
 		await jjImport().catch(() => void 0);
 	}
 }
+/** GitHub refused a read, as it does past a rate limit; it takes reads
+* again at `retryAt`. */
+var GitHubRefusedRead = class extends ReviewInputError {
+	retryAt;
+	constructor(message, retryAt) {
+		super(message, 409);
+		this.retryAt = retryAt;
+	}
+};
 function firstLine(text) {
 	return text.split("\n")[0].slice(0, 300);
 }
@@ -1385,12 +1799,6 @@ function firstLine(text) {
 //#region src/review-api/azure-devops-provider.ts
 const AZ_TIMEOUT_MS = 3e4;
 const PULL_REQUEST_URLS = [/^https:\/\/dev\.azure\.com\/([A-Za-z0-9-]+)\/([^/]+)\/_git\/([^/]+)\/pullrequest\/([1-9]\d*)$/, /^https:\/\/([A-Za-z0-9-]+)\.visualstudio\.com\/(?:DefaultCollection\/)?([^/]+)\/_git\/([^/]+)\/pullrequest\/([1-9]\d*)$/];
-const REMOTE_URLS = [
-	/^https:\/\/(?:[^@]+@)?dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/]+?)(?:\.git)?\/?$/,
-	/^https:\/\/([^.]+)\.visualstudio\.com\/(?:DefaultCollection\/)?([^/]+)\/_git\/([^/]+?)(?:\.git)?\/?$/,
-	/^git@ssh\.dev\.azure\.com:v3\/([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/,
-	/^[^@]+@vs-ssh\.visualstudio\.com:v3\/([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/
-];
 const metadataSchema$1 = z.object({
 	title: z.string(),
 	sourceRefName: z.string().min(1),
@@ -1402,15 +1810,6 @@ const metadataSchema$1 = z.object({
 		project: z.object({ name: z.string() })
 	})
 });
-/** org/project/repository, decoded; undefined for malformed escapes. */
-function slugOf(patterns, url) {
-	const match = patterns.map((pattern) => pattern.exec(url)).find(Boolean);
-	try {
-		return match && match.slice(1, 4).map(decodeURIComponent).join("/");
-	} catch {
-		return;
-	}
-}
 function azFailure(url, failure) {
 	const unreadable = (hint) => new ReviewInputError(`Could not read ${url}: az failed (${failure}). ${hint}`, 409);
 	if (/not recognized as an internal or external command|command not found|enoent/i.test(failure)) return unreadable("Install the Azure CLI and the azure-devops extension, then retry.");
@@ -1480,7 +1879,7 @@ const azureDevOpsProvider = {
 		};
 	},
 	matchesRemote(remoteUrl, address) {
-		return slugOf(REMOTE_URLS, remoteUrl.trim())?.toLowerCase() === address.slug.toLowerCase();
+		return azureRepositoryOf(remoteUrl)?.toLowerCase() === address.slug.toLowerCase();
 	}
 };
 //#endregion
@@ -1494,8 +1893,20 @@ const metadataSchema = z.object({
 	baseRefName: z.string().min(1),
 	baseRefOid: z.string().optional(),
 	headRefName: z.string().min(1),
-	isCrossRepository: z.boolean()
+	isCrossRepository: z.boolean(),
+	state: z.enum([
+		"OPEN",
+		"CLOSED",
+		"MERGED"
+	]).optional(),
+	isDraft: z.boolean().optional()
 });
+/** gh's state and draft flag as one state. */
+function ghState(state, isDraft) {
+	if (state === "MERGED") return "merged";
+	if (state === "CLOSED") return "closed";
+	if (state === "OPEN") return isDraft ? "draft" : "open";
+}
 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);
 }
@@ -1523,19 +1934,21 @@ const providers = [{
 			const stdout = await deps.run("gh", [
 				"pr",
 				"view",
-				String(number),
+				{ value: String(number) },
 				"--repo",
-				`${host}/${slug}`,
+				{ value: `${host}/${slug}` },
 				"--json",
-				"number,title,baseRefName,baseRefOid,headRefName,isCrossRepository"
+				"number,title,baseRefName,baseRefOid,headRefName,isCrossRepository,state,isDraft"
 			], { timeoutMs: GH_TIMEOUT_MS });
-			const { headRefName, isCrossRepository, ...metadata } = metadataSchema.parse(JSON.parse(stdout));
+			const { headRefName, isCrossRepository, state, isDraft, ...metadata } = metadataSchema.parse(JSON.parse(stdout));
+			const pullRequestState = ghState(state, isDraft);
 			return {
 				host,
 				slug,
 				headRef,
 				...metadata,
-				headBranch: isCrossRepository ? void 0 : headRefName
+				headBranch: isCrossRepository ? void 0 : headRefName,
+				...pullRequestState && { state: pullRequestState }
 			};
 		} catch (error) {
 			ghFailure = firstLine(errorMessage(error));
@@ -1554,7 +1967,10 @@ const providers = [{
 			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.status === 403 || response.status === 429) {
+			const reset = Number(response.headers.get("x-ratelimit-reset"));
+			throw new GitHubRefusedRead(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").message, reset > 0 ? reset * 1e3 : Date.now() + 9e5);
+		}
 		if (!response.ok) throw unreadable(url, ghFailure, `the GitHub API returned HTTP ${response.status}`);
 		const parsed = z.object({
 			number: z.number(),
@@ -1567,7 +1983,10 @@ const providers = [{
 			head: z.object({
 				ref: z.string().min(1),
 				repo: z.object({ id: z.number() }).nullable()
-			})
+			}),
+			state: z.enum(["open", "closed"]).optional(),
+			draft: z.boolean().optional(),
+			merged_at: z.string().nullable().optional()
 		}).safeParse(await response.json().catch(() => void 0));
 		if (!parsed.success) throw unreadable(url, ghFailure, "the GitHub API response was malformed");
 		return {
@@ -1578,7 +1997,8 @@ const providers = [{
 			title: parsed.data.title,
 			baseRefName: parsed.data.base.ref,
 			baseRefOid: parsed.data.base.sha,
-			headBranch: parsed.data.head.repo?.id === parsed.data.base.repo.id ? parsed.data.head.ref : void 0
+			headBranch: parsed.data.head.repo?.id === parsed.data.base.repo.id ? parsed.data.head.ref : void 0,
+			...parsed.data.state && { state: parsed.data.merged_at ? "merged" : parsed.data.state === "closed" ? "closed" : parsed.data.draft ? "draft" : "open" }
 		};
 	},
 	matchesRemote(remoteUrl, address) {
@@ -1630,8 +2050,7 @@ var ReviewActivity = class {
 		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;`);
+      started_at INTEGER NOT NULL, expires_at INTEGER NOT NULL, focus TEXT, surface TEXT);`);
 		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));
@@ -1774,7 +2193,13 @@ var ReviewActivity = class {
 //#region src/review-api/ask-history.ts
 /** A saved Ask conversation: its history entry, and how to reopen it. */
 const askRecordSchema = askHistoryEntrySchema.extend({
-	reviewId: z.string(),
+	/** The board the conversation started on, and the block if any. */
+	anchor: z.object({
+		board: z.string(),
+		block: z.string().optional()
+	}),
+	/** Absent for a shared board. */
+	projectId: z.string().optional(),
 	/** The ACP session the agent keeps the transcript under. */
 	sessionId: z.string(),
 	/** The review version asked about; its pins recreate the checkout. */
@@ -1787,7 +2212,9 @@ const askRecordSchema = askHistoryEntrySchema.extend({
 });
 const rowSchema = z.object({
 	id: z.string(),
-	review_id: z.string(),
+	anchor_board: z.string(),
+	anchor_block: z.string().nullable(),
+	project_id: z.string().nullable(),
 	agent: z.string(),
 	session_id: z.string(),
 	version: z.number(),
@@ -1802,7 +2229,11 @@ const rowSchema = z.object({
 	permissions: z.string().nullable()
 }).transform((row) => askRecordSchema.parse({
 	id: row.id,
-	reviewId: row.review_id,
+	anchor: row.anchor_block === null ? { board: row.anchor_board } : {
+		board: row.anchor_board,
+		block: row.anchor_block
+	},
+	projectId: row.project_id ?? void 0,
 	agent: row.agent,
 	sessionId: row.session_id,
 	version: row.version,
@@ -1815,19 +2246,28 @@ const rowSchema = z.object({
 	entries: row.entries === null ? void 0 : JSON.parse(row.entries),
 	permissions: row.permissions ?? (row.bypass === 1 ? "bypass" : "read-only")
 }));
-/** Saved Ask conversations, per review. Shared reviews are not in
-* `reviews`, so there is no foreign key; deleting a review deletes its rows. */
+/** A thread's project is always its anchor board's. */
+const THREAD_PROJECT_SQL = "(SELECT project_id FROM reviews WHERE reviews.id=ask_conversations.anchor_board)";
+/** Every column of a thread, with its project. */
+const THREAD_COLUMNS = `ask_conversations.*, ${THREAD_PROJECT_SQL} AS project_id`;
+/** Saved Ask conversations by project, each anchored on the board it started
+* on. No foreign key on the anchor: shared reviews are not in `reviews`.
+* So deleting a board removes its threads by hand (removeReview). */
 var AskHistory = class {
 	db;
+	writable;
+	listeners = /* @__PURE__ */ new Set();
 	externalWriteGuard;
 	setExternalWriteGuard(guard) {
 		this.externalWriteGuard = guard;
 	}
-	constructor(db) {
+	constructor(db, writable = () => {}) {
 		this.db = db;
+		this.writable = writable;
 		db.exec(`CREATE TABLE IF NOT EXISTS ask_conversations(
       id TEXT PRIMARY KEY,
-      review_id TEXT NOT NULL,
+      anchor_board TEXT NOT NULL,
+      anchor_block TEXT,
       agent TEXT NOT NULL,
       session_id TEXT NOT NULL,
       version INTEGER NOT NULL,
@@ -1840,30 +2280,39 @@ var AskHistory = class {
       entries TEXT,
       bypass INTEGER NOT NULL DEFAULT 0,
       permissions TEXT,
-      UNIQUE(agent, session_id));
-    CREATE INDEX IF NOT EXISTS ask_conversations_review ON ask_conversations(review_id, updated_at);`);
-		const columns = new Set(db.prepare("PRAGMA table_info(ask_conversations)").all().map((column) => String(column.name)));
-		if (!columns.has("bypass")) db.exec("ALTER TABLE ask_conversations ADD COLUMN bypass INTEGER NOT NULL DEFAULT 0");
-		if (!columns.has("permissions")) db.exec("ALTER TABLE ask_conversations ADD COLUMN permissions TEXT");
+      viewed_at TEXT,
+      UNIQUE(agent, session_id));`);
+		db.exec("CREATE INDEX IF NOT EXISTS ask_conversations_review ON ask_conversations(anchor_board, updated_at)");
 		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))");
 	}
+	/** Calls back when a conversation is saved, renamed, used or deleted. */
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	changed() {
+		for (const listener of this.listeners) listener();
+	}
 	assertWritable(reviewId) {
 		if (reviewId.startsWith("shared-")) this.externalWriteGuard?.(reviewId);
-		const row = this.db.prepare("SELECT deleted_at FROM review_attention WHERE review_id=?").get(reviewId);
-		if (row?.deleted_at) throw new ReviewInputError(`This whiteboard was moved to Trash on ${new Date(String(row.deleted_at)).toLocaleDateString("en-US", {
-			month: "short",
-			day: "numeric"
-		})}. Restore it with session_lifecycle({"sessionId":"${reviewId}","state":"active"}) to continue.`, 409);
+		else this.writable(reviewId);
 	}
 	assertThreadWritable(id) {
 		const record = this.get(id);
-		if (record) this.assertWritable(record.reviewId);
+		if (record) this.assertWritable(record.anchor.board);
 	}
 	save(record) {
-		this.assertWritable(record.reviewId);
-		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,permissions)
-        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.permissions === "bypass" ? 1 : 0, record.permissions ?? null);
+		this.assertWritable(record.anchor.board);
+		this.db.prepare(`INSERT INTO ask_conversations(id,anchor_board,anchor_block,agent,session_id,version,head,cwd,selection,title,created_at,updated_at,bypass,permissions)
+        VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+        ON CONFLICT(id) DO UPDATE SET anchor_board=excluded.anchor_board, anchor_block=excluded.anchor_block,
+          agent=excluded.agent, session_id=excluded.session_id, version=excluded.version, head=excluded.head,
+          cwd=excluded.cwd, selection=excluded.selection, title=excluded.title, created_at=excluded.created_at,
+          updated_at=excluded.updated_at, bypass=excluded.bypass, permissions=excluded.permissions`).run(record.id, record.anchor.board, record.anchor.block ?? null, record.agent, record.sessionId, record.version, record.head, record.cwd, JSON.stringify(record.selection), record.title, record.createdAt, record.updatedAt, record.permissions === "bypass" ? 1 : 0, record.permissions ?? null);
+		this.changed();
 	}
 	/** What the agent may do without asking when the conversation reopens. */
 	setPermissions(id, permissions) {
@@ -1880,11 +2329,13 @@ var AskHistory = class {
 	saveEntries(id, entries) {
 		this.assertThreadWritable(id);
 		this.db.prepare("UPDATE ask_conversations SET entries=? WHERE id=?").run(JSON.stringify(entries), id);
+		this.changed();
 	}
 	/** The agent's name for the conversation, which the list shows. */
 	rename(id, title) {
 		this.assertThreadWritable(id);
 		this.db.prepare("UPDATE ask_conversations SET title=? WHERE id=?").run(title.slice(0, 200), id);
+		this.changed();
 	}
 	saveOffer(agent, offer) {
 		this.db.prepare("INSERT OR REPLACE INTO ask_agent_offers(agent, offer) VALUES(?, ?)").run(agent, JSON.stringify(offer));
@@ -1905,29 +2356,195 @@ var AskHistory = class {
 	touch(id, at = (/* @__PURE__ */ new Date()).toISOString()) {
 		this.assertThreadWritable(id);
 		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, permissions: _permissions, ...entry } = rowSchema.parse(row);
-			const question = entries?.find((entry) => entry.kind === "user")?.text;
-			if (question?.trim()) entry.question = question;
-			return entry;
+		this.changed();
+	}
+	/** Conversations in a board's project, or started on the board when it
+	* has none. Newest first. */
+	list(board, projectId) {
+		return this.entries("anchor_board=? OR anchor_board IN (SELECT id FROM reviews WHERE project_id=?)", board, projectId ?? null);
+	}
+	/** Every project's conversations, newest first. */
+	listAll() {
+		return this.entries("1");
+	}
+	entries(where, ...params) {
+		return this.db.prepare(`SELECT id, anchor_board, anchor_block, ${THREAD_PROJECT_SQL} AS project_id, agent, session_id, version, head, cwd, selection, title,
+          created_at, updated_at, NULL AS entries, bypass, permissions, viewed_at,
+          (SELECT json_extract(value,'$.text') FROM json_each(entries)
+            WHERE json_extract(value,'$.kind')='user' LIMIT 1) AS question
+        FROM ask_conversations WHERE ${where} ORDER BY updated_at DESC`).all(...params).map((row) => {
+			const { anchor, sessionId: _sessionId, version: _version, cwd: _cwd, entries: _entries, permissions: _permissions, ...entry } = rowSchema.parse(row);
+			const question = z.string().nullable().parse(row.question) ?? "";
+			if (question.trim()) entry.question = question;
+			const viewedAt = z.string().nullable().parse(row.viewed_at);
+			return {
+				...entry,
+				anchor,
+				...viewedAt !== null && { viewedAt }
+			};
 		});
 	}
 	get(id) {
-		const row = this.db.prepare("SELECT * FROM ask_conversations WHERE id=?").get(id);
+		const row = this.db.prepare(`SELECT ${THREAD_COLUMNS} FROM ask_conversations WHERE id=?`).get(id);
 		return row ? rowSchema.parse(row) : void 0;
 	}
+	/** The reviewer saw the thread, on screen with the app focused. Only
+	* when it was seen changes: not its order, nor when it was used. */
+	markViewed(id, at = (/* @__PURE__ */ new Date()).toISOString()) {
+		this.db.prepare("UPDATE ask_conversations SET viewed_at=? WHERE id=?").run(at, id);
+		this.changed();
+	}
+	/** Forgets the threads that started on a board gone for good. */
 	removeReview(reviewId) {
-		this.db.prepare("DELETE FROM ask_conversations WHERE review_id=?").run(reviewId);
+		this.db.prepare("DELETE FROM ask_conversations WHERE anchor_board=?").run(reviewId);
+		this.changed();
 	}
 	delete(id) {
 		this.assertThreadWritable(id);
 		this.db.prepare("DELETE FROM ask_conversations WHERE id=?").run(id);
+		this.changed();
 	}
 };
 //#endregion
+//#region src/review-api/board-order.ts
+/**
+* Siblings in reading order. A comes after B when A reaches B through
+* depends_on, directly or through boards outside the siblings. Between two
+* siblings with no such chain either way, commits decide: A comes after B
+* when A's base is, or descends from, B's head, or A's PR merges into B's
+* branch. Remaining ties go newest made first, then by id, so an edit
+* never reorders them.
+*/
+function orderSiblings(siblings, dependsOn, isAncestor) {
+	const reach = new Map(siblings.map((board) => [board.id, reachable(board.id, dependsOn)]));
+	const after = (a, b) => {
+		if (reach.get(a.id).has(b.id)) return true;
+		if (reach.get(b.id).has(a.id)) return false;
+		return buildsOn(a, b, isAncestor) && !buildsOn(b, a, isAncestor);
+	};
+	const before = new Map(siblings.map((a) => [a.id, new Set(siblings.flatMap((b) => b !== a && after(a, b) ? [b.id] : []))]));
+	const newestFirst = [...siblings].sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt) || a.id.localeCompare(b.id));
+	const placed = /* @__PURE__ */ new Set();
+	const order = [];
+	while (order.length < siblings.length) {
+		const remaining = newestFirst.filter((board) => !placed.has(board.id));
+		const next = remaining.find((board) => [...before.get(board.id)].every((id) => placed.has(id))) ?? remaining[0];
+		placed.add(next.id);
+		order.push(next.id);
+	}
+	return order;
+}
+function reachable(id, dependsOn) {
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [...dependsOn(id)];
+	while (stack.length) {
+		const next = stack.pop();
+		if (seen.has(next)) continue;
+		seen.add(next);
+		stack.push(...dependsOn(next));
+	}
+	return seen;
+}
+/** Whether a's change sits on top of b's. */
+function buildsOn(a, b, isAncestor) {
+	if (a.repositoryId !== b.repositoryId) return false;
+	if (a.baseBranch && a.baseBranch === b.headBranch) return true;
+	if (!a.base || !b.head) return false;
+	if (a.base === b.head) return true;
+	return a.base !== a.head && isAncestor(a.repositoryId, b.head, a.base);
+}
+/**
+* The path that adding `from → to` would close, from `from` back to itself,
+* or undefined when it closes none.
+*/
+function dependencyCycle(from, to, dependsOn) {
+	if (from === to) return [from, from];
+	const previous = /* @__PURE__ */ new Map();
+	const queue = [to];
+	const seen = /* @__PURE__ */ new Set([to]);
+	while (queue.length) {
+		const current = queue.shift();
+		if (current === from) {
+			const path = [from];
+			for (let at = from; at !== to; at = previous.get(at)) path.unshift(previous.get(at));
+			return [from, ...path];
+		}
+		for (const next of dependsOn(current)) if (!seen.has(next)) {
+			seen.add(next);
+			previous.set(next, current);
+			queue.push(next);
+		}
+	}
+}
+//#endregion
+//#region src/review-api/link-preview.ts
+/** About what the card shows before it fades; more is cut, not sent. */
+const PROSE_CHARACTERS = 700;
+const CODE_LINES = 6;
+function childBlocks(block) {
+	return "children" in block ? block.children : [];
+}
+/** Paragraphs of markdown, without headings. */
+function paragraphs(markdown) {
+	return markdown.split(/\n\s*\n/).map((paragraph) => paragraph.trim()).filter((paragraph) => paragraph && !paragraph.startsWith("#"));
+}
+/** The prose from the first markdown block on, in reading order, until the
+* card has enough. Diagrams and code before it are skipped. */
+function openingProse(blocks) {
+	const prose = [];
+	let length = 0;
+	const walk = (list) => {
+		for (const block of list) if (block.type === "markdown") for (const paragraph of paragraphs(block.markdown)) {
+			prose.push(paragraph);
+			length += paragraph.length;
+			if (length >= PROSE_CHARACTERS) return true;
+		}
+		else if (walk(childBlocks(block))) return true;
+		return false;
+	};
+	walk(blocks);
+	return prose;
+}
+/** The block and the title of the section it is in. */
+function find(blocks, id, section) {
+	for (const block of blocks) {
+		if (block.id === id) return {
+			block,
+			section
+		};
+		const found = find(childBlocks(block), id, block.type === "section" ? block.title : section);
+		if (found) return found;
+	}
+}
+/** The opening prose of a board, or one block of it. */
+function boardLinkPreview(document, blockId) {
+	if (blockId === void 0) return { prose: openingProse(document) };
+	const found = find(document, blockId);
+	if (!found) return {};
+	const { block } = found;
+	const section = block.type === "section" ? block.title : found.section;
+	if (block.type === "code") return {
+		...section && { section },
+		code: {
+			language: block.language,
+			lines: block.text.split("\n").slice(0, CODE_LINES)
+		}
+	};
+	const prose = openingProse([block]);
+	if (prose.length) return {
+		...section && { section },
+		prose
+	};
+	const title = "title" in block ? block.title : void 0;
+	return {
+		...section && { section },
+		figure: {
+			type: block.type,
+			title: title ?? ""
+		}
+	};
+}
+//#endregion
 //#region src/review-api/origin.ts
 const pullRequestUrl = z.string().refine((url) => pullRequestProvider(url) !== void 0, "Use a canonical PR URL: https://github.com/owner/repository/pull/123, the same path on a GitHub Enterprise host, or https://dev.azure.com/org/project/_git/repository/pullrequest/123.");
 /** One key per PR: GitHub owner and repository names are case-insensitive,
@@ -1954,36 +2571,496 @@ function setPullRequest(snapshot, url, title) {
 	};
 }
 //#endregion
+//#region src/review-api/foreign-references.ts
+const LANGUAGES = /* @__PURE__ */ new Map([
+	[".ts", "typescript"],
+	[".tsx", "tsx"],
+	[".js", "javascript"],
+	[".jsx", "jsx"],
+	[".mjs", "javascript"],
+	[".rs", "rust"],
+	[".go", "go"],
+	[".py", "python"],
+	[".rb", "ruby"],
+	[".java", "java"],
+	[".kt", "kotlin"],
+	[".swift", "swift"],
+	[".c", "c"],
+	[".h", "c"],
+	[".cc", "cpp"],
+	[".cpp", "cpp"],
+	[".css", "css"],
+	[".html", "html"],
+	[".json", "json"],
+	[".md", "markdown"],
+	[".sh", "bash"],
+	[".sql", "sql"],
+	[".toml", "toml"],
+	[".yaml", "yaml"],
+	[".yml", "yaml"]
+]);
+/** A source link in Markdown, in either spelling. */
+const SOURCE_LINK = /^(?:whiteboard:source\/|review-source:)/i;
+/**
+* Migrates the old global scratchpad, which quoted several repositories.
+* A board may only quote its own, so each quote of another repository is
+* replaced:
+* - a code peek becomes a `code` block of those lines;
+* - a source link becomes its text, then what it pointed at in code;
+* - a diagram attachment leaves the diagram and its lines follow it as
+*   a `code` block;
+* - a step keeps its label and takes the lines as its code;
+* - a call stack or database lens becomes a line saying what it was,
+*   then a `code` block for each range it quoted, in any repository; the
+*   first takes its id. A lens that quotes only its own repository is
+*   kept.
+* New blocks take ids from `allocate`.
+*/
+function snapshotForeignReferences(document, own, read, repositoryName, allocate) {
+	const foreign = (pins) => isJsonObject(pins) && isStringValue(pins.repositoryId) && pins.repositoryId !== own ? pins : void 0;
+	const caption = (pins, anchor) => {
+		const selection = parseAnchor(anchor);
+		const commit = selection?.start.side === "base" ? pins.base ?? pins.head : pins.head;
+		const range = selection ? `${selection.file}:${selection.start.line}-${selection.end.line}` : anchor;
+		return `${repositoryName(pins.repositoryId)} · ${range} @ ${commit.slice(0, 7)}`;
+	};
+	const snapshot = (id, pins, anchor) => {
+		const selection = parseAnchor(anchor);
+		const commit = selection?.start.side === "base" ? pins.base ?? pins.head : pins.head;
+		const file = selection ? read(pins.repositoryId, commit, selection.file) : void 0;
+		const label = caption(pins, anchor);
+		const text = file !== void 0 && selection ? file.split("\n").slice(selection.start.line - 1, selection.end.line).join("\n") : `${label}\n(source unavailable)`;
+		return {
+			type: "code",
+			...isStringValue(id) && { id },
+			language: selection ? LANGUAGES.get(path.extname(selection.file).toLowerCase()) ?? "text" : "text",
+			text,
+			caption: label
+		};
+	};
+	const pinsIn = (pins) => {
+		return isJsonObject(pins) && isStringValue(pins.repositoryId) && isStringValue(pins.head) ? {
+			repositoryId: pins.repositoryId,
+			head: pins.head,
+			...isStringValue(pins.base) && { base: pins.base }
+		} : void 0;
+	};
+	const pinsOf = (value) => pinsIn(foreign(value));
+	const peeks = (blocks) => blocks.map((block) => {
+		if (!isJsonObject(block)) return block;
+		if (Array.isArray(block.children)) return {
+			...block,
+			children: peeks(block.children)
+		};
+		const pins = pinsOf(block.pins);
+		if (block.type === "code_peek" && pins && isStringValue(block.source)) return snapshot(block.id, pins, block.source);
+		return block;
+	});
+	const rest = (blocks) => blocks.flatMap((block) => {
+		if (!isJsonObject(block)) return block;
+		if (Array.isArray(block.children)) return {
+			...block,
+			children: rest(block.children)
+		};
+		const blockPins = pinsOf(block.pins);
+		if (block.type === "markdown" && blockPins && isStringValue(block.markdown)) {
+			const { pins: _pins, ...kept } = block;
+			return {
+				...kept,
+				markdown: unlinkSourceLinks(block.markdown, blockPins)
+			};
+		}
+		if (block.type === "sequence" && Array.isArray(block.steps)) return {
+			...block,
+			steps: block.steps.map((step) => {
+				if (!isJsonObject(step) || !isStringValue(step.source)) return step;
+				const pins = pinsOf(step.pins ?? block.pins);
+				if (!pins) return step;
+				const { source, pins: _pins, ...kept } = step;
+				const quoted = snapshot(void 0, pins, source);
+				return isJsonObject(quoted) ? {
+					...kept,
+					code: {
+						language: quoted.language,
+						text: quoted.text
+					}
+				} : kept;
+			})
+		};
+		if (block.type === "flow_diagram" && Array.isArray(block.nodes)) {
+			const moved = [];
+			return [{
+				...block,
+				nodes: block.nodes.map((node) => isJsonObject(node) && Array.isArray(node.attachments) ? {
+					...node,
+					attachments: node.attachments.filter((attachment) => {
+						if (!isJsonObject(attachment) || !pinsOf(attachment.pins ?? block.pins)) return true;
+						for (const [pins, anchor] of quotes(attachment, pinsIn, block.pins)) moved.push(snapshot(allocate("block"), pins, anchor));
+						return false;
+					})
+				} : node)
+			}, ...moved];
+		}
+		if (block.type === "call_stack_diff" || block.type === "database_lens") {
+			const foreignQuote = quotes(block, pinsOf)[0];
+			if (!foreignQuote) return block;
+			const what = block.type === "call_stack_diff" ? "Call stack" : "Database lens";
+			const title = isStringValue(block.title) ? ` “${block.title}”` : "";
+			return [{
+				type: "markdown",
+				id: allocate("block"),
+				markdown: `${what}${title} (from ${repositoryName(foreignQuote[0].repositoryId)}), kept as snapshots below.`
+			}, ...quotes(block, pinsIn).map(([pins, anchor], index) => snapshot(index === 0 ? block.id : allocate("block"), pins, anchor))];
+		}
+		return block;
+	});
+	/** The ranges a block's frames or operations quote at the pins `read`
+	* accepts. */
+	function quotes(block, read, inherited) {
+		if (Array.isArray(block)) return block.flatMap((item) => quotes(item, read, inherited));
+		if (!isJsonObject(block)) return [];
+		const scope = block.pins ?? inherited;
+		const pins = read(scope);
+		return [...pins ? [
+			block.source,
+			block.callSite,
+			...Array.isArray(block.contextSources) ? block.contextSources : [],
+			...Array.isArray(block.sources) ? block.sources : []
+		].flatMap((anchor) => isStringValue(anchor) ? [[pins, anchor]] : []) : [], ...Object.entries(block).filter(([key]) => key !== "pins").flatMap(([, value]) => Array.isArray(value) || isJsonObject(value) ? quotes(value, read, scope) : [])];
+	}
+	function unlinkSourceLinks(markdown, pins) {
+		let result = markdown;
+		const links = [...markdownNodes(parseMarkdown(markdown))].filter((node) => node.type === "link" && SOURCE_LINK.test(node.url ?? "") && node.position?.start.offset !== void 0 && node.position.end.offset !== void 0).reverse();
+		for (const node of links) result = result.slice(0, node.position.start.offset) + `${markdownText(node)} (\`${caption(pins, node.url.replace(SOURCE_LINK, ""))}\`)` + result.slice(node.position.end.offset);
+		return result;
+	}
+	return rest(peeks(document));
+}
+//#endregion
 //#region src/review-api/store-schema.ts
+/** A board version's repository in SQL over `versions.snapshot`, as
+* `boardRepositoryId` reads it: its target's, else its pins'. */
+const BOARD_REPOSITORY_ID_SQL = "CASE WHEN json_valid(versions.snapshot) THEN COALESCE(json_extract(versions.snapshot,'$.target.repositoryId'),json_extract(versions.snapshot,'$.pins.repositoryId')) END";
+const columnsOf = (db, table) => new Set(db.prepare("SELECT name FROM pragma_table_info(?)").all(table).map(({ name }) => String(name)));
 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 reviews(id TEXT PRIMARY KEY, version INTEGER NOT NULL, next_id INTEGER NOT NULL,
+      project_id TEXT NOT NULL REFERENCES projects(id), parent_id TEXT REFERENCES reviews(id) ON DELETE SET NULL);
     CREATE TABLE IF NOT EXISTS versions(review_id TEXT REFERENCES reviews(id), version INTEGER, snapshot TEXT NOT NULL,
+      thread_id TEXT, author_kind TEXT,
       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, deleted_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 projects(id TEXT PRIMARY KEY, name TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS repositories(id TEXT PRIMARY KEY, path TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
+      project_id TEXT REFERENCES projects(id));
     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;
+    CREATE TABLE IF NOT EXISTS board_dependencies(review_id TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE,
+      depends_on TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE, PRIMARY KEY(review_id,depends_on));
+    CREATE INDEX IF NOT EXISTS board_dependencies_depends_on ON board_dependencies(depends_on);
+    -- A link goes with the board it is on. Where it points stays plain
+    -- text, no foreign key: a link to a deleted board stays, and reads
+    -- "Board deleted" from the deleted_boards tombstone.
+    CREATE TABLE IF NOT EXISTS board_links(from_review TEXT NOT NULL REFERENCES reviews(id) ON DELETE CASCADE, from_block TEXT NOT NULL,
+      to_review TEXT NOT NULL, to_block TEXT);
+    CREATE INDEX IF NOT EXISTS board_links_from ON board_links(from_review);
+    CREATE INDEX IF NOT EXISTS board_links_to ON board_links(to_review);
+    CREATE TABLE IF NOT EXISTS deleted_boards(id TEXT PRIMARY KEY, title TEXT NOT NULL, deleted_at TEXT NOT NULL,
+      project_id TEXT);
   `);
-	db.exec("BEGIN IMMEDIATE");
+}
+//#endregion
+//#region src/review-api/scratchpad-plan-upgrade.ts
+const OLD_SCRATCHPAD_ID = "scratchpad";
+const hasScratchpadVersions = ({ db }) => Boolean(db.prepare("SELECT 1 FROM versions WHERE review_id=? LIMIT 1").get(OLD_SCRATCHPAD_ID));
+/** A pad version's snapshot with its document in today's form (old pads
+* held anchors as objects); undefined for one that won't parse. */
+function parsePadVersion(text) {
 	try {
-		if (db.prepare("PRAGMA table_info(review_attention)").all().some((column) => column.name === "dismissed_at")) {
+		const snapshot = JSON.parse(text);
+		const document = migrateStoredDocument(snapshot.document);
+		snapshot.document = Array.isArray(document) ? document : [];
+		return snapshot;
+	} catch {
+		return;
+	}
+}
+/** Each pad version as parsed, by version, for one open. The run, inside
+* the write lock, reads the rows again: it reuses a parse only of text that
+* hasn't changed since. */
+const parsedPads = /* @__PURE__ */ new WeakMap();
+function padVersion(context, version, text) {
+	let parsed = parsedPads.get(context);
+	if (!parsed) parsedPads.set(context, parsed = /* @__PURE__ */ new Map());
+	const known = parsed.get(version);
+	if (known?.text === text) return known.snapshot;
+	const snapshot = parsePadVersion(text);
+	parsed.set(version, {
+		text,
+		snapshot
+	});
+	return snapshot;
+}
+/** The pad's versions, oldest first, each parsed once per open. */
+const scratchpadVersions = (context) => context.db.prepare("SELECT version,snapshot FROM versions WHERE review_id=? ORDER BY version").all(OLD_SCRATCHPAD_ID).map((row) => ({
+	version: Number(row.version),
+	snapshot: padVersion(context, Number(row.version), String(row.snapshot))
+}));
+/** The pad's newest version that parses, reading no further back. */
+function latestScratchpadDocument(context) {
+	for (const row of context.db.prepare("SELECT version,snapshot FROM versions WHERE review_id=? ORDER BY version DESC").iterate(OLD_SCRATCHPAD_ID)) {
+		const snapshot = padVersion(context, Number(row.version), String(row.snapshot));
+		if (snapshot) return snapshot.document;
+	}
+}
+/** The checkout the pad quotes most, else the one opened last. Only a
+* checkout that still exists: a plan opens on it. */
+function scratchpadRepository(context) {
+	const exists = (repositoryId) => {
+		try {
+			return existsSync(context.repositoryPath(repositoryId));
+		} catch {
+			return false;
+		}
+	};
+	const counts = /* @__PURE__ */ new Map();
+	const latest = latestScratchpadDocument(context);
+	for (const { source } of sourceReferences(latest ?? [], { tolerant: true })) {
+		const repositoryId = source.pins?.repositoryId;
+		if (repositoryId && exists(repositoryId)) counts.set(repositoryId, (counts.get(repositoryId) ?? 0) + 1);
+	}
+	const [quoted] = [...counts].sort((a, b) => b[1] - a[1])[0] ?? [];
+	if (quoted) return quoted;
+	return [...context.db.prepare(`SELECT ${BOARD_REPOSITORY_ID_SQL} AS repository
+      FROM review_attention
+      JOIN reviews ON reviews.id=review_attention.review_id
+      JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+      WHERE review_attention.viewed_at IS NOT NULL AND repository IS NOT NULL
+      ORDER BY review_attention.viewed_at DESC`).all().map(({ repository }) => String(repository)), ...context.repositories().map(({ id }) => id)].find(exists);
+}
+const snapshots = (context, own, document, allocate) => snapshotForeignReferences(document, own, context.fileAtCommit, context.repositoryName, allocate);
+/** Reads the files the pad quotes, which the context keeps, before the
+* write lock other hosts on this home wait on. */
+function readScratchpadQuotes(context) {
+	if (!hasScratchpadVersions(context)) return;
+	const quoting = scratchpadRepository(context);
+	if (quoting) {
+		for (const { snapshot } of scratchpadVersions(context)) if (snapshot) snapshots(context, quoting, snapshot.document, (prefix) => prefix);
+	}
+}
+function planFromScratchpad(context) {
+	const { db } = context;
+	if (!hasScratchpadVersions(context)) return;
+	const own = scratchpadRepository(context);
+	const id = randomUUID();
+	db.prepare("INSERT INTO reviews(id,version,next_id,project_id) SELECT ?,version,next_id,? FROM reviews WHERE id=?").run(id, own ? context.projectOfRepository(own) : context.fallbackProject(), OLD_SCRATCHPAD_ID);
+	let nextId = Number(db.prepare("SELECT next_id FROM reviews WHERE id=?").get(id).next_id);
+	const old = scratchpadVersions(context);
+	parsedPads.delete(context);
+	db.prepare("UPDATE versions SET review_id=? WHERE review_id=?").run(id, OLD_SCRATCHPAD_ID);
+	for (const { version, snapshot } of old) {
+		if (!snapshot) continue;
+		delete snapshot.kind;
+		snapshot.reviewId = id;
+		snapshot.title = "Scratchpad";
+		if (own) {
+			snapshot.target = {
+				kind: "project",
+				repositoryId: own
+			};
+			snapshot.document = snapshots(context, own, snapshot.document, (prefix) => `${prefix}-${++nextId}`);
+		}
+		context.rewriteVersion(id, version, snapshot);
+	}
+	db.prepare("UPDATE reviews SET next_id=? WHERE id=?").run(nextId, id);
+	for (const [table, ...names] of [
+		[
+			"ask_conversations",
+			"review_id",
+			"anchor_board"
+		],
+		["authoring_presences", "review_id"],
+		["review_coverage", "review_id"],
+		["review_attention", "review_id"]
+	]) {
+		const columns = columnsOf(db, table);
+		const column = names.find((name) => columns.has(name));
+		if (column) db.prepare(`UPDATE ${table} SET ${column}=? WHERE ${column}=?`).run(id, OLD_SCRATCHPAD_ID);
+	}
+	db.prepare("DELETE FROM reviews WHERE id=?").run(OLD_SCRATCHPAD_ID);
+}
+//#endregion
+//#region src/review-api/store-migrations.ts
+/** Keep versions.author_kind to its values, as a CHECK would. */
+const VERSION_AUTHOR_TRIGGERS = `
+  CREATE TRIGGER IF NOT EXISTS versions_author_kind_insert BEFORE INSERT ON versions
+    WHEN NEW.author_kind NOT IN ('person','agent','system')
+    BEGIN SELECT RAISE(ABORT, 'versions.author_kind must be person, agent or system'); END;
+  CREATE TRIGGER IF NOT EXISTS versions_author_kind_update BEFORE UPDATE OF author_kind ON versions
+    WHEN NEW.author_kind NOT IN ('person','agent','system')
+    BEGIN SELECT RAISE(ABORT, 'versions.author_kind must be person, agent or system'); END;`;
+const STORE_UPGRADES = [
+	{
+		version: 1,
+		name: "retired-tables",
+		run: ({ db }) => db.exec(`DROP TABLE IF EXISTS receipts;
+        DROP TABLE IF EXISTS review_viewed;
+        DROP TABLE IF EXISTS authoring_drafts;
+        DROP TABLE IF EXISTS authoring_sessions;`)
+	},
+	{
+		version: 2,
+		name: "archive-to-trash",
+		run: ({ db }) => {
+			if (!columnsOf(db, "review_attention").has("dismissed_at")) return;
 			db.exec("ALTER TABLE review_attention RENAME COLUMN dismissed_at TO deleted_at");
 			db.prepare("UPDATE review_attention SET deleted_at=? WHERE deleted_at IS NOT NULL").run((/* @__PURE__ */ new Date()).toISOString());
 		}
-		db.exec("COMMIT");
-	} catch (error) {
-		db.exec("ROLLBACK");
-		throw error;
+	},
+	{
+		version: 3,
+		name: "board-projects",
+		groupsCheckouts: true,
+		foreignKeysOff: true,
+		run: ({ db, repositories, projectOfRepository, firstRepositoryProject }) => {
+			const parents = () => db.exec("CREATE INDEX IF NOT EXISTS reviews_parent ON reviews(parent_id)");
+			if (columnsOf(db, "reviews").has("project_id")) return parents();
+			if (!columnsOf(db, "repositories").has("project_id")) db.exec("ALTER TABLE repositories ADD COLUMN project_id TEXT REFERENCES projects(id)");
+			const boards = db.prepare(`SELECT reviews.id, CASE WHEN json_valid(versions.snapshot) THEN COALESCE(json_extract(versions.snapshot,'$.target.repositoryId'),json_extract(versions.snapshot,'$.pins.repositoryId')) END AS repository_id,
+            review_attention.viewed_at
+          FROM reviews LEFT JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+          LEFT JOIN review_attention ON review_attention.review_id=reviews.id
+          ORDER BY reviews.rowid`).all();
+			const registered = new Set(repositories().map(({ id }) => id));
+			const projects = /* @__PURE__ */ new Map();
+			for (const { id, repository_id: repository } of boards) if (repository && registered.has(String(repository))) projects.set(String(id), projectOfRepository(String(repository)));
+			const [opened] = boards.filter(({ id, viewed_at }) => viewed_at && projects.has(String(id))).sort((a, b) => String(b.viewed_at).localeCompare(String(a.viewed_at)));
+			let fallback = opened && projects.get(String(opened.id));
+			const brokenReferences = () => db.prepare("PRAGMA foreign_key_check").all().filter(({ parent }) => parent === "reviews").length;
+			const broken = brokenReferences();
+			db.exec(`CREATE TABLE reviews_with_projects(id TEXT PRIMARY KEY, version INTEGER NOT NULL, next_id INTEGER NOT NULL,
+        project_id TEXT NOT NULL REFERENCES projects(id),
+        parent_id TEXT REFERENCES reviews(id) ON DELETE SET NULL)`);
+			const insert = db.prepare("INSERT INTO reviews_with_projects(id,version,next_id,project_id) SELECT id,version,next_id,? FROM reviews WHERE id=?");
+			for (const { id } of boards) insert.run(projects.get(String(id)) ?? (fallback ??= firstRepositoryProject()), String(id));
+			db.exec(`DROP TABLE reviews;
+        ALTER TABLE reviews_with_projects RENAME TO reviews;`);
+			parents();
+			if (brokenReferences() > broken) throw new Error("Giving boards projects broke a reference.");
+		}
+	},
+	{
+		version: 4,
+		name: "scratchpad-plan",
+		beforeLock: readScratchpadQuotes,
+		run: planFromScratchpad
+	},
+	{
+		version: 5,
+		name: "ask-threads-by-project",
+		run: ({ db }) => {
+			db.exec("CREATE INDEX IF NOT EXISTS reviews_project ON reviews(project_id)");
+			const columns = columnsOf(db, "ask_conversations");
+			if (columns.size === 0) return;
+			if (columns.has("review_id")) db.exec("ALTER TABLE ask_conversations RENAME COLUMN review_id TO anchor_board");
+			if (!columns.has("anchor_block")) db.exec("ALTER TABLE ask_conversations ADD COLUMN anchor_block TEXT");
+		}
+	},
+	{
+		version: 6,
+		name: "version-threads",
+		run: ({ db }) => {
+			if (!columnsOf(db, "versions").has("thread_id")) db.exec("ALTER TABLE versions ADD COLUMN thread_id TEXT");
+			db.exec("CREATE INDEX IF NOT EXISTS versions_thread_id ON versions(thread_id)");
+		}
+	},
+	{
+		version: 7,
+		name: "viewed-on-upgrade",
+		run: ({ db }) => db.exec(`INSERT OR IGNORE INTO review_attention(review_id) SELECT id FROM reviews;
+        UPDATE review_attention SET viewed_at=COALESCE(NULLIF((
+          SELECT MAX(COALESCE(review_attention.viewed_at, ''), COALESCE(CASE WHEN json_valid(versions.snapshot) THEN json_extract(versions.snapshot,'$.createdAt') END, ''))
+          FROM reviews JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+          WHERE reviews.id=review_attention.review_id), ''), review_attention.viewed_at)
+        WHERE review_id IN (SELECT id FROM reviews);`)
+	},
+	{
+		version: 8,
+		name: "ask-thread-viewed",
+		run: ({ db }) => {
+			const columns = columnsOf(db, "ask_conversations");
+			if (columns.size > 0 && !columns.has("viewed_at")) db.exec("ALTER TABLE ask_conversations ADD COLUMN viewed_at TEXT");
+		}
+	},
+	{
+		version: 9,
+		name: "version-authors",
+		run: ({ db }) => {
+			if (!columnsOf(db, "versions").has("author_kind")) db.exec("ALTER TABLE versions ADD COLUMN author_kind TEXT");
+			db.exec(VERSION_AUTHOR_TRIGGERS);
+		}
+	},
+	{
+		version: 10,
+		name: "ask-permissions",
+		run: ({ db }) => {
+			const columns = columnsOf(db, "ask_conversations");
+			if (columns.size > 0 && !columns.has("permissions")) db.exec("ALTER TABLE ask_conversations ADD COLUMN permissions TEXT");
+		}
+	}
+];
+STORE_UPGRADES.at(-1).version;
+const storeVersion = (db) => Number(db.prepare("PRAGMA user_version").get().user_version);
+/** Runs every step the store hasn't, each in its own transaction with the
+* version it reaches, so a failed step rolls back alone and stops the store
+* opening, naming the step; the ones before it stay done. A store at a
+* later version than this build knows is left as it is. */
+function upgradeStore(context) {
+	const { db } = context;
+	for (const step of STORE_UPGRADES) {
+		if (storeVersion(db) >= step.version) continue;
+		if (step.groupsCheckouts) context.prepareCheckouts();
+		step.beforeLock?.(context);
+		if (step.foreignKeysOff) db.exec("PRAGMA foreign_keys=OFF");
+		db.exec("BEGIN IMMEDIATE");
+		try {
+			if (storeVersion(db) < step.version) {
+				step.run(context);
+				db.exec(`PRAGMA user_version=${step.version}`);
+			}
+			db.exec("COMMIT");
+		} catch (error) {
+			if (db.isTransaction) db.exec("ROLLBACK");
+			throw new Error(`Could not upgrade the whiteboard store: step ${step.version} (${step.name}) failed and was rolled back. ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		} finally {
+			if (step.foreignKeysOff) db.exec("PRAGMA foreign_keys=ON");
+		}
+	}
+}
+/** How the store's checkouts group, worked out before it opens, asking
+* several repositories at once, when an upgrade still to run needs it;
+* undefined otherwise, or when the store can't be read so, and the step
+* works it out itself. */
+async function groupCheckoutsAhead(databasePath) {
+	if (!existsSync(databasePath)) return void 0;
+	let db;
+	try {
+		db = new DatabaseSync(databasePath, { timeout: 5e3 });
+		const version = storeVersion(db);
+		if (!STORE_UPGRADES.some((step) => step.groupsCheckouts && step.version > version) || !columnsOf(db, "repositories").size) return void 0;
+		const groups = new CheckoutGroups(db);
+		await groups.prepareConcurrently();
+		return groups.prepared;
+	} catch {
+		return;
+	} finally {
+		db?.close();
 	}
 }
 //#endregion
@@ -1991,17 +3068,11 @@ function initializeReviewStoreSchema(db) {
 const reviewId = z.string().min(1);
 /** The key older hosts read and write. */
 const statsKey = (pins) => JSON.stringify([pins, "structural"]);
-/** 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";
+/** How long a board stays in Trash before it is deleted. */
+const TRASH_DAYS = 30;
 const activityId = z.string().min(1).optional().describe("The activityId from review_activity_begin: your courier draws this edit. Never rejects a write.");
+const parentId = reviewId.describe("The reviewId of a top-level review in the same project to nest this one under.");
+const dependsOn = z.array(reviewId).describe("The reviewIds of reviews in the same project this one builds on. Siblings list after what they depend on.");
 const commandSchema = z.strictObject({ operation: z.discriminatedUnion("type", [
 	z.strictObject({
 		type: z.literal("delete"),
@@ -2019,16 +3090,29 @@ const commandSchema = z.strictObject({ operation: z.discriminatedUnion("type", [
 	}),
 	z.strictObject({
 		type: z.literal("create"),
-		/** Required unless pullRequestUrl alone names the source; then the PR title. */
-		title: z.string().trim().min(1).optional(),
+		/** Required unless pullRequestUrl alone names the source; then the PR
+		* title. A person's new board may start with none; it reads
+		* "Untitled" until they name it. */
+		title: z.string().trim().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."),
+		repositoryId: z.string().min(1).optional().describe("Only with pullRequestUrl and no target: the registered checkout to fetch the PR into."),
 		/** 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()
+		projectId: z.string().min(1).optional().describe("The project to file the whiteboard in: a project.id from session_list. Defaults to its checkout's."),
+		parentId: parentId.optional(),
+		dependsOn: dependsOn.optional()
+	}),
+	z.strictObject({
+		type: z.literal("set_parent"),
+		reviewId,
+		parentId: parentId.nullable()
+	}),
+	z.strictObject({
+		type: z.literal("set_dependencies"),
+		reviewId,
+		dependsOn
 	}),
 	z.strictObject({
 		type: z.literal("set_target"),
@@ -2059,12 +3143,60 @@ const commandSchema = z.strictObject({ operation: z.discriminatedUnion("type", [
 		version: z.number().int().nonnegative()
 	})
 ]) });
+/** A person's save of a whole board from the canvas. A block they added
+* has no id and may carry a clientKey, which the response maps to its id. */
+const personEditSchema = z.strictObject({
+	baseVersion: z.number().int().nonnegative(),
+	/** Empty until the person names the board; it reads "Untitled". */
+	title: z.string().trim(),
+	document: z.array(z.json())
+});
+/** The block a person's canvas has focus in; null clears it. */
+const focusLeaseSchema = z.strictObject({
+	clientId: z.string().min(1),
+	blockId: z.string().min(1).nullable(),
+	/** false when the canvas closes the board. */
+	open: z.boolean().optional()
+});
+/** A focus lease lasts this long unless renewed. The canvas renews it every
+* few seconds, so a closed or crashed app releases its block on its own. */
+const FOCUS_LEASE_TTL_MS = 15e3;
+/** How often a discard looks again for a canvas letting go of the board. */
+const DISCARD_POLL_MS = 100;
+/**
+* The project of a registered checkout, made on first use. Checkouts of one
+* repository (worktrees, or clones of one GitHub repository) share it. A
+* deleted checkout joins the project of the existing one it belonged to
+* (see `CheckoutGroups.ownerOf`), else gets its own.
+*/
+function projectOfCheckout(db, repositoryId, groups = new CheckoutGroups(db)) {
+	const { path: root, name, project_id: projectOf } = db.prepare("SELECT path, name, project_id FROM repositories WHERE id=?").get(repositoryId);
+	if (projectOf) return String(projectOf);
+	const join = (projectId) => {
+		db.prepare("UPDATE repositories SET project_id=? WHERE id=?").run(projectId, repositoryId);
+		return projectId;
+	};
+	if (!existsSync(String(root))) {
+		const owner = groups.ownerOf(repositoryId);
+		if (owner) return join(projectOfCheckout(db, owner, groups));
+	}
+	const group = groups.group(String(root));
+	const sibling = group && db.prepare("SELECT project_id, path FROM repositories WHERE project_id IS NOT NULL").all().find(({ path: checkout }) => groups.group(String(checkout))?.key === group.key);
+	if (sibling) return join(String(sibling.project_id));
+	const projectId = randomUUID();
+	db.prepare("INSERT INTO projects(id,name) VALUES(?,?)").run(projectId, group?.label ?? String(name));
+	return join(projectId);
+}
+/** The Ask thread a version names, on its edit or on itself; stored in
+* `versions.thread_id` so a thread's boards are one index away. */
+const versionThread = (snapshot) => snapshot.lastEdit?.threadId ?? snapshot.threadId ?? null;
 /** 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;
+	checkoutOwners;
 	activity;
 	askHistory;
 	db;
@@ -2212,24 +3344,43 @@ var ReviewStore = class {
 			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) {
+	constructor(databasePath, providers, checkoutOwners) {
 		this.providers = providers;
+		this.checkoutOwners = checkoutOwners;
 		this.db = new DatabaseSync(databasePath, { timeout: 5e3 });
 		initializeReviewStoreSchema(this.db);
+		const files = /* @__PURE__ */ new Map();
+		upgradeStore({
+			db: this.db,
+			prepareCheckouts: () => this.checkouts.prepare(),
+			repositories: () => this.repositories(),
+			repositoryPath: (repositoryId) => this.repositoryPath(repositoryId),
+			repositoryName: (repositoryId) => this.repositoryName(repositoryId),
+			fileAtCommit: (repositoryId, commit, file) => {
+				const key = JSON.stringify([
+					repositoryId,
+					commit,
+					file
+				]);
+				if (!files.has(key)) files.set(key, this.fileAtCommit(repositoryId, commit, file));
+				return files.get(key);
+			},
+			projectOfRepository: (repositoryId) => this.projectOfRepository(repositoryId),
+			fallbackProject: () => this.fallbackProject(),
+			rewriteVersion: (reviewId, version, snapshot) => this.rewriteVersion(reviewId, version, snapshot),
+			firstRepositoryProject: () => {
+				const [first] = this.repositories();
+				return first ? this.projectOfRepository(first.id) : this.fallbackProject();
+			}
+		});
 		this.activity = new ReviewActivity(this.db, (id) => this.assertWritable(id));
-		this.askHistory = new AskHistory(this.db);
+		this.askHistory = new AskHistory(this.db, (id) => this.assertOutOfTrash(id));
 		this.purgeExpired();
 		this.purgeTimer = setInterval(() => this.purgeExpired(), 6e4);
 		this.purgeTimer.unref();
@@ -2239,6 +3390,64 @@ var ReviewStore = class {
 		this.externalChanges = setInterval(() => this.refreshExternalChanges(), 250);
 		this.externalChanges.unref();
 	}
+	/** Saves a version over what it was; the current one re-indexes its
+	* board's links, as every written version does. */
+	rewriteVersion(reviewId, version, snapshot) {
+		this.db.prepare("UPDATE versions SET snapshot=? WHERE review_id=? AND version=?").run(JSON.stringify(snapshot), reviewId, version);
+		if (version !== this.currentVersion(reviewId)) return;
+		try {
+			this.indexBoardLinks(reviewId, this.read(reviewId).document);
+		} catch {}
+	}
+	/** The project of a registered checkout, made on first use. Checkouts of
+	* one repository (worktrees, or clones with one origin) share it. */
+	projectOfRepository(repositoryId) {
+		const row = this.db.prepare("SELECT project_id FROM repositories WHERE id=?").get(repositoryId);
+		if (!row) return this.fallbackProject();
+		if (row.project_id) return String(row.project_id);
+		return projectOfCheckout(this.db, repositoryId, this.checkouts);
+	}
+	fallbackProject() {
+		const found = this.db.prepare("SELECT id FROM projects WHERE name='Whiteboards' AND id NOT IN (SELECT project_id FROM repositories WHERE project_id IS NOT NULL) ORDER BY rowid LIMIT 1").get();
+		if (found) return String(found.id);
+		const projectId = randomUUID();
+		this.db.prepare("INSERT INTO projects(id,name) VALUES(?,?)").run(projectId, "Whiteboards");
+		return projectId;
+	}
+	/** A checkout's project, as the catalog lists it; undefined once the
+	* checkout is unregistered. */
+	checkoutProject(repositoryId) {
+		if (!this.repositories().some(({ id }) => id === repositoryId)) return void 0;
+		const id = this.projectOfRepository(repositoryId);
+		const { name } = this.db.prepare("SELECT name FROM projects WHERE id=?").get(id);
+		return {
+			id,
+			name: String(name)
+		};
+	}
+	/** Undefined when the file can't be read. */
+	fileAtCommit(repositoryId, commit, file) {
+		try {
+			return this.checkouts.fileAt(this.repositoryPath(repositoryId), commit, file);
+		} catch {
+			return;
+		}
+	}
+	/** A checkout's name as its project labels it, else its folder. */
+	repositoryName(repositoryId) {
+		try {
+			const root = this.repositoryPath(repositoryId);
+			return this.repositoryGroup(root)?.label.split("/").at(-1) ?? path.basename(root);
+		} catch {
+			return "another repository";
+		}
+	}
+	/** A board's project. */
+	projectOf(id) {
+		const row = this.db.prepare("SELECT project_id FROM reviews WHERE id=?").get(id);
+		if (!row) this.assertExists(id);
+		return String(row.project_id);
+	}
 	dataVersion() {
 		return Number(this.db.prepare("PRAGMA data_version").get().data_version);
 	}
@@ -2260,7 +3469,8 @@ var ReviewStore = class {
 		this.observedVersions = current;
 		for (const [reviewId, savedVersion] of current) if (previous.get(reviewId) !== savedVersion) this.notify({
 			reviewId,
-			version: savedVersion
+			version: savedVersion,
+			external: true
 		});
 		else if (previousDeletions.get(reviewId) !== deletions.get(reviewId)) this.notify({
 			reviewId,
@@ -2306,34 +3516,57 @@ var ReviewStore = class {
 			throw error;
 		}
 	}
-	repositoryGroups = /* @__PURE__ */ new Map();
+	checkoutGroups;
+	/** How the store's checkouts group into projects, kept for the open. */
+	get checkouts() {
+		return this.checkoutGroups ??= new CheckoutGroups(this.db, void 0, this.checkoutOwners);
+	}
 	repositoryGroup(root) {
-		if (this.repositoryGroups.has(root)) return this.repositoryGroups.get(root);
-		if (!existsSync(root)) return void 0;
-		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;
+		return this.checkouts.group(root);
 	}
 	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);
+		this.projectOfRepository(String(row.id));
 		return {
 			id: String(row.id),
 			name: String(row.name)
 		};
 	}
+	/** Forgets a checkout no board uses, after every write queued before it,
+	* so a board being made with it keeps it. */
 	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);
+		const run = this.pending.then(async () => {
+			this.db.exec("BEGIN IMMEDIATE");
+			try {
+				if (!this.db.prepare(`SELECT EXISTS (SELECT 1 FROM versions WHERE instr(snapshot, ?) > 0)
+          OR EXISTS (SELECT 1 FROM resources WHERE repository_id=?) AS used`).get(`"repositoryId":${JSON.stringify(id)}`, id).used) this.db.prepare("DELETE FROM repositories WHERE id=?").run(id);
+				this.db.exec("COMMIT");
+			} catch (error) {
+				if (this.db.isTransaction) this.db.exec("ROLLBACK");
+				throw error;
+			}
+		});
+		this.pending = run.catch(() => {});
+		return run;
+	}
+	/** Checkouts whose remote is cloneUrl, most recently used first. */
+	checkoutsOf(cloneUrl) {
+		const key = remoteGroup(cloneUrl)?.key;
+		if (!key) return [];
+		const used = (repositoryId) => String(this.db.prepare(`SELECT MAX(json_extract(versions.snapshot,'$.createdAt')) AS at
+            FROM reviews JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+            WHERE json_extract(versions.snapshot,'$.target.repositoryId')=?`).get(repositoryId)?.at ?? "");
+		return this.repositories().filter((repository) => {
+			try {
+				return this.repositoryGroup(repository.path)?.key === key;
+			} catch {
+				return false;
+			}
+		}).map((repository) => ({
+			id: repository.id,
+			at: used(repository.id)
+		})).sort((left, right) => right.at.localeCompare(left.at)).map((repository) => repository.id);
 	}
 	/** Registered checkouts, oldest registration first. */
 	repositories() {
@@ -2398,8 +3631,14 @@ var ReviewStore = class {
 	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);
 	}
+	/** A board that exists and isn't in Trash: the one rule every write
+	* about a board keeps. */
 	assertWritable(id) {
 		this.assertExists(id);
+		this.assertOutOfTrash(id);
+	}
+	/** Refuses a board in Trash, which is read-only until it is restored. */
+	assertOutOfTrash(id) {
 		const trashedAt = this.trashTime(id);
 		if (trashedAt) throw new ReviewInputError(`This whiteboard was moved to Trash on ${new Date(trashedAt).toLocaleDateString("en-US", {
 			month: "short",
@@ -2410,40 +3649,28 @@ var ReviewStore = class {
 		const row = this.db.prepare("SELECT deleted_at FROM review_attention WHERE review_id=?").get(id);
 		return row?.deleted_at ? String(row.deleted_at) : null;
 	}
+	/** Removes a board for good, from Delete… or Trash's purge. Links into
+	* it stay, and show it as deleted. */
 	removePermanently(id) {
+		const { title } = this.read(id);
 		for (const table of [
-			"ask_conversations",
 			"authoring_presences",
 			"review_coverage",
 			"review_attention",
 			"versions"
 		]) this.db.prepare(`DELETE FROM ${table} WHERE review_id=?`).run(id);
+		this.askHistory.removeReview(id);
+		this.db.prepare("INSERT OR REPLACE INTO deleted_boards(id,title,deleted_at,project_id) VALUES(?,?,?,(SELECT project_id FROM reviews WHERE id=?))").run(id, title, (/* @__PURE__ */ new Date()).toISOString(), id);
 		this.db.prepare("DELETE FROM reviews WHERE id=?").run(id);
 		this.liveSources.delete(id);
 	}
+	/** Deletes the boards 30 days in Trash, each as Delete… would. */
 	purgeExpired() {
-		const cutoff = (/* @__PURE__ */ new Date(Date.now() - 2592e6)).toISOString();
-		const expired = [];
-		this.db.exec("BEGIN IMMEDIATE");
-		try {
-			for (const row of this.db.prepare("SELECT review_id,version FROM review_attention JOIN reviews ON reviews.id=review_id WHERE deleted_at <= ?").all(cutoff)) {
-				const reviewId = String(row.review_id);
-				expired.push({
-					reviewId,
-					version: Number(row.version),
-					deleted: true
-				});
-				this.removePermanently(reviewId);
-			}
-			this.db.exec("COMMIT");
-		} catch (error) {
-			this.db.exec("ROLLBACK");
-			throw error;
-		}
-		for (const result of expired) {
-			this.activity.deleted(result.reviewId);
-			this.notify(result);
-		}
+		const cutoff = (/* @__PURE__ */ new Date(Date.now() - TRASH_DAYS * 864e5)).toISOString();
+		const expired = () => this.db.prepare("SELECT review_id FROM review_attention JOIN reviews ON reviews.id=review_id WHERE deleted_at <= ?").all(cutoff).map((row) => String(row.review_id));
+		for (const reviewId of expired()) this.deleteBoard(this.read(reviewId), { kind: "person" }, { guard: () => {
+			if (!expired().includes(reviewId)) throw new ReviewInputError("Restored from Trash.", 409);
+		} });
 	}
 	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);
@@ -2452,7 +3679,7 @@ var ReviewStore = class {
 			throw new ReviewInputError("Review version not found.", 404);
 		}
 		const snapshot = JSON.parse(String(row.snapshot));
-		const { document, lenses } = liftFileLenses(migrateStoredDocument(snapshot.document));
+		const { document, lenses } = readStoredDocument(snapshot.document);
 		snapshot.document = document;
 		if (snapshot.lenses) snapshot.lenses = migrateStoredLenses(snapshot.lenses);
 		if (lenses.length) snapshot.lenses = [...snapshot.lenses ?? [], ...lenses];
@@ -2477,27 +3704,28 @@ var ReviewStore = class {
 			listener();
 		} catch {}
 	}
-	/** Reviews of the tutorial earlier versions shipped, for their removal. */
-	legacyTutorialIds() {
-		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() {
 		return this.summaries();
 	}
+	listProject(projectId) {
+		return this.summaries("reviews.project_id=?", projectId);
+	}
 	/** One review's catalog entry, as review_list shows it. */
 	summary(id) {
-		return this.summaries(id)[0];
+		return this.summaries("reviews.id=?", id)[0];
 	}
-	summaries(id) {
+	summaries(where = "1", ...params) {
 		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.deleted_at, repositories.name AS repository_name, repositories.path AS repository_path
+          review_attention.viewed_at, review_attention.deleted_at, repositories.name AS repository_name, repositories.path AS repository_path,
+          projects.id AS project_id, projects.name AS project_name
         FROM reviews
+        JOIN projects ON projects.id=reviews.project_id
         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')
-        ${id === void 0 ? "" : "WHERE reviews.id=?"}
-        ORDER BY reviews.rowid`).all(...id === void 0 ? [] : [id]).map((row) => {
+        LEFT JOIN repositories ON repositories.id=${BOARD_REPOSITORY_ID_SQL}
+        WHERE ${where}
+        ORDER BY reviews.rowid`).all(...params).map((row) => {
 			const summary = JSON.parse(String(row.summary));
 			if (summary.pins) summary.target ??= {
 				kind: "commits",
@@ -2507,19 +3735,30 @@ var ReviewStore = class {
 			};
 			const live = this.liveSources.get(summary.reviewId);
 			if (live?.version === summary.version && summary.target?.kind === "worktree") summary.pins = live.pins;
-			const listed = {
+			return {
 				...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 ?? "",
+				project: {
+					id: String(row.project_id),
+					name: String(row.project_name)
+				},
+				repositoryName: row.repository_name ? String(row.repository_name) : "(unknown repository)",
 				viewedAt: row.viewed_at ? String(row.viewed_at) : null,
 				trashedAt: row.deleted_at ? String(row.deleted_at) : null,
+				changed: !row.viewed_at || summary.createdAt > String(row.viewed_at),
 				working: this.activity.isWorking(summary.reviewId)
 			};
-			if (summary.kind === "scratchpad") listed.contents = this.scratchpadContents();
-			return listed;
 		});
+		const graph = this.relationGraph();
+		for (const listed of reviews) {
+			const parentId = graph.parents.get(listed.reviewId);
+			const children = graph.children.get(listed.reviewId);
+			const dependsOn = graph.dependsOn.get(listed.reviewId);
+			if (parentId) listed.parentId = parentId;
+			if (children) listed.children = this.orderChildren(children, graph);
+			if (dependsOn) listed.dependsOn = dependsOn;
+		}
 		return this.withDiffStats(reviews);
 	}
 	/** Local and imported summaries use the same persisted counts. */
@@ -2530,117 +3769,80 @@ var ReviewStore = class {
 			diffStats: review.pins ? stats.get(statsKey(review.pins)) ?? 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;
-		}
-	}
 	/** Two saved board/day pairs in the last fourteen days. */
 	feedbackEligible(now = Date.now()) {
 		const row = this.db.prepare(`SELECT count(*) AS pairs FROM (
         SELECT DISTINCT review_id, date(json_extract(snapshot, '$.createdAt')) AS utc_date
         FROM versions
         WHERE (version = 0 OR json_type(snapshot, '$.lastEdit') = 'object')
-          AND json_extract(snapshot, '$.kind') IS NOT 'scratchpad'
-          AND json_extract(snapshot, '$.origin.tutorial') IS NOT 1
           AND julianday(json_extract(snapshot, '$.createdAt')) BETWEEN julianday(?) AND julianday(?)
         LIMIT 2
       )`).get((/* @__PURE__ */ new Date(now - 12096e5)).toISOString(), new Date(now).toISOString());
 		return Number(row?.pairs) >= 2;
 	}
 	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)
-		}));
+		return this.db.prepare(`SELECT version,
+          CASE WHEN json_valid(snapshot) THEN json_extract(snapshot,'$.title') END AS title,
+          CASE WHEN json_valid(snapshot) THEN json_extract(snapshot,'$.createdAt') END AS created_at,
+          author_kind,
+          thread_id
+        FROM versions WHERE review_id=? ORDER BY version`).all(id).map((row) => {
+			const entry = {
+				version: Number(row.version),
+				title: String(row.title ?? ""),
+				createdAt: String(row.created_at ?? "")
+			};
+			if (row.author_kind !== null) entry.author = row.author_kind === "person" ? "you" : "agent";
+			if (row.author_kind !== "person" && row.thread_id !== null) entry.threadId = String(row.thread_id);
+			return entry;
+		});
 	}
 	inspect(id, targetId, version) {
 		return inspectSnapshot(this.read(id, version), targetId);
 	}
 	/** The host can seed a document; transport callers only supply a command. */
-	execute(input, initial) {
+	execute(input, initial, author = { kind: "agent" }) {
 		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 pullRequestTitle = pullRequest ? pullRequest.then(({ title }) => title || void 0, () => void 0) : this.startPullRequestTitle(command);
-		const run = this.pending.then(async () => {
+		return this.enqueue(async () => {
 			const op = command.operation;
-			this.purgeExpired();
-			if (op.type !== "create" && op.type !== "delete" && op.type !== "lifecycle") this.assertWritable(op.reviewId);
-			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.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.");
+				if (!op.title && op.target && author.kind !== "person") 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;
+			const resolvedTarget = requestedTarget?.kind === "project" ? (this.repositoryPath(requestedTarget.repositoryId), { target: requestedTarget }) : 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") {
-				this.assertExists(op.reviewId);
-				if (!this.trashTime(op.reviewId)) throw new ReviewInputError("Move this whiteboard to Trash before deleting it.", 409);
-				const result = {
-					reviewId: op.reviewId,
-					version: this.read(op.reviewId).version,
-					deleted: true
-				};
-				this.commitCommand(result, () => this.removePermanently(op.reviewId), () => this.assertMutation(op.reviewId, result.version));
-				return result;
-			}
-			if (op.type === "attention" || op.type === "lifecycle") {
-				const result = {
-					reviewId: op.reviewId,
-					version: this.read(op.reviewId).version,
-					attention: true,
-					...op.type === "lifecycle" && { lifecycle: true }
-				};
-				this.commitCommand(result, () => {
-					this.db.prepare("INSERT OR IGNORE INTO review_attention(review_id) VALUES(?)").run(op.reviewId);
-					if (op.type === "attention") this.db.prepare("UPDATE review_attention SET viewed_at=? WHERE review_id=?").run((/* @__PURE__ */ new Date()).toISOString(), op.reviewId);
-					else {
-						const timestamp = op.state === "trash" ? (/* @__PURE__ */ new Date()).toISOString() : null;
-						this.db.prepare("UPDATE review_attention SET deleted_at=CASE WHEN ? IS NULL THEN NULL ELSE COALESCE(deleted_at, ?) END WHERE review_id=?").run(timestamp, timestamp, op.reviewId);
-					}
-				});
-				return result;
+				if (found) {
+					const result = this.existingReview(found, others, resolvedTarget.pins);
+					if (op.parentId || op.dependsOn) result.note += ` Its parent and dependencies were not changed either: set them with session_set_parent and session_set_dependencies.`;
+					return result;
+				}
 			}
-			const id = op.type !== "create" ? op.reviewId : op.kind === "scratchpad" ? SCRATCHPAD_ID : randomUUID();
+			if (op.type === "set_parent") return this.commitBoardFacts(op.reviewId, author, { parentId: op.parentId });
+			if (op.type === "set_dependencies") return this.commitBoardFacts(op.reviewId, author, { dependsOn: op.dependsOn });
+			if (op.type === "lifecycle") return this.commitBoardFacts(op.reviewId, author, { state: op.state });
+			if (op.type === "attention") return this.commitBoardFacts(op.reviewId, author, { viewed: true });
+			if (op.type === "delete") return this.deleteBoard(this.read(op.reviewId), author, { fromTrash: true });
+			const id = op.type === "create" ? randomUUID() : op.reviewId;
 			const previous = op.type === "create" ? void 0 : this.read(id);
-			let snapshot = op.type === "create" ? createdSnapshot(id, op, resolvedTarget, fromPullRequest && (fromPullRequest.title || `PR #${op.pullRequestUrl.split("/").at(-1)}`)) : structuredClone(previous);
+			let snapshot = op.type === "create" ? createdSnapshot(id, op, resolvedTarget, fromPullRequest && (fromPullRequest.title || `PR #${op.pullRequestUrl.split("/").at(-1)}`), author.kind === "person") : structuredClone(previous);
 			delete snapshot.trashedAt;
 			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;
+			/** The head a worktree board read at, when it becomes a plan. */
+			let unpinnedWorktree;
 			if ((op.type === "create" || op.type === "set_target") && this.providers.headBranch) {
 				const pins = resolvedTarget?.pins ?? snapshot.pins;
 				if (pins) {
@@ -2657,14 +3859,18 @@ var ReviewStore = class {
 				branch: fromPullRequest.branch ?? snapshot.origin?.branch,
 				baseBranch: fromPullRequest.baseBranch
 			};
-			if (requestedTarget) snapshot.origin = {
-				...snapshot.origin,
-				baseBranch: requestedTarget.base === resolvedTarget?.pins.base ? void 0 : requestedTarget.base
-			};
+			if (requestedTarget && requestedTarget.kind !== "project") {
+				const named = requestedTarget.base;
+				const base = resolvedTarget?.pins?.base;
+				snapshot.origin = {
+					...snapshot.origin,
+					baseBranch: named && !base?.startsWith(named.toLowerCase()) ? named : void 0
+				};
+			}
 			switch (op.type) {
 				case "create":
 					if (initial) {
-						snapshot.document = documentSchema.parse(initial.document);
+						snapshot.document = await this.resolveCommitLinks(documentSchema.parse(initial.document), snapshot);
 						snapshot.origin = {
 							...snapshot.origin,
 							...structuredClone(initial.origin)
@@ -2677,17 +3883,22 @@ var ReviewStore = class {
 					snapshot.title = op.title;
 					break;
 				case "set_target":
-					setPullRequest(snapshot, op.pullRequestUrl ?? (op.pullRequestUrl === null || snapshot.pins?.repositoryId !== resolvedTarget.pins.repositoryId ? null : void 0), await pullRequestTitle);
+					setPullRequest(snapshot, op.pullRequestUrl ?? (op.pullRequestUrl === null || snapshot.target?.repositoryId !== resolvedTarget.target.repositoryId ? null : void 0), await pullRequestTitle);
 					snapshot.staleSources = [];
+					if (snapshot.pins && !resolvedTarget.pins) {
+						const pinned = pinDocumentReferences(snapshot.document, snapshot.pins);
+						if (snapshot.target?.kind === "worktree" && JSON.stringify(pinned) !== JSON.stringify(snapshot.document)) unpinnedWorktree = snapshot.pins.head;
+						snapshot.document = pinned;
+					}
 					snapshot.target = resolvedTarget.target;
-					snapshot.pins = resolvedTarget.pins;
+					if (resolvedTarget.pins) snapshot.pins = resolvedTarget.pins;
+					else delete snapshot.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;
@@ -2705,65 +3916,691 @@ var ReviewStore = class {
 					};
 					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 advised = new Set(documentAdvice(previous?.document ?? []));
-			const warnings = [...documentAdvice(snapshot.document).filter((advice) => !advised.has(advice)), ...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 (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.assertWritable(id);
-				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;
+				case "edit": {
+					const edit = respellEditLinks(op.edit);
+					applied = applyEdit(snapshot.document, edit, (prefix) => `${prefix}-${++nextId}`);
+					snapshot.lastEdit = summarizeEdit(edit, applied, previous.document, snapshot.document);
+					break;
 				}
-			} : void 0);
-			return result;
+			}
+			const warnings = unpinnedWorktree ? [`Its references now read at ${unpinnedWorktree.slice(0, 7)}, the checkout's last commit, which lacks any uncommitted lines they quoted. Check them.`] : [];
+			return this.commitVersion({
+				snapshot,
+				previous,
+				nextId,
+				author,
+				warnings,
+				restore: op.type === "restore",
+				repin: op.type === "set_target",
+				projectLive: op.type !== "restore" && !resolvedTarget,
+				result: {
+					...op.type === "create" && { created: true },
+					targetId: applied?.targetId ?? lensTarget?.targetId,
+					...applied && { type: applied.type },
+					...lensTarget && { type: lensTarget.type },
+					...applied?.children && { children: applied.children }
+				},
+				...op.type === "create" && {
+					projectId: op.projectId,
+					relations: {
+						parentId: op.parentId,
+						dependsOn: op.dependsOn
+					}
+				},
+				...(op.type === "edit" || op.type === "lens_edit") && { courier: {
+					surface: op.type === "edit" ? "document" : "lenses",
+					activityId: op.activityId
+				} }
+			});
 		});
+	}
+	/**
+	* Commits a board's next version: the one place a version is written.
+	* Whoever writes it, it keeps the same rules:
+	*  - an agent may not change a block a person holds;
+	*  - the version names its author: a thread's names the thread, a
+	*    person's is theirs and never inherits a thread;
+	*  - only a change of repository moves a board to another project, and an
+	*    existing board never takes the project of the board opened last;
+	*  - only links the change adds are checked;
+	*  - the version, its link index, the board's project and its relations
+	*    are written together, and only if the board is still at the version
+	*    read and the rules still hold.
+	* Runs inside the write queue.
+	*/
+	async commitVersion(change) {
+		const { previous, author } = change;
+		const id = change.snapshot.reviewId;
+		let snapshot = change.snapshot;
+		delete snapshot.threadId;
+		delete snapshot.personEdit;
+		if (snapshot.lastEdit) delete snapshot.lastEdit.threadId;
+		if (previous && !change.restore) await this.normalizeDocument(snapshot, previous);
+		if (change.unchangedSavesNothing && previous && snapshot.title === previous.title && isDeepStrictEqual(snapshot.document, previous.document)) return {
+			reviewId: id,
+			version: previous.version
+		};
+		const touched = previous ? changedBlocks(previous.document, snapshot.document) : [];
+		const holds = () => {
+			if (author.kind !== "person") this.assertUnleased(id, touched);
+		};
+		holds();
+		if (author.kind === "person") snapshot.personEdit = {
+			changed: touched,
+			...change.personIds && { ids: change.personIds }
+		};
+		else if (author.threadId) {
+			if (snapshot.lastEdit) snapshot.lastEdit.threadId = author.threadId;
+			else snapshot.threadId = author.threadId;
+		}
+		let warnings;
+		({snapshot, warnings} = await this.prepareVersion(snapshot, previous, {
+			restore: change.restore,
+			repin: change.repin,
+			projectLive: change.projectLive,
+			person: author.kind === "person"
+		}));
+		warnings = [...change.warnings ?? [], ...warnings];
+		const result = {
+			...change.result,
+			reviewId: id,
+			version: snapshot.version
+		};
+		if (warnings.length) result.warnings = warnings;
+		const projectId = this.projectFor(snapshot, previous, change.projectId);
+		const previousProject = previous ? this.projectOf(id) : void 0;
+		const threadId = versionThread(snapshot);
+		const shown = {
+			...previous && snapshot.title !== previous.title && { titleChanged: true },
+			...previous && (projectId !== previousProject || boardRepositoryId(snapshot) !== boardRepositoryId(previous) || boardIconKind(snapshot.target) !== boardIconKind(previous.target)) && { placeChanged: true },
+			...threadId && { threadId }
+		};
+		this.commitCommand(result, () => {
+			this.saveVersion(snapshot, change.nextId, projectId, change.author);
+			if (change.relations?.parentId) this.setParent(id, change.relations.parentId);
+			if (change.relations?.dependsOn) this.setDependencies(id, change.relations.dependsOn);
+			if (previous && projectId !== previousProject && this.dropRelationsOutside(id, projectId)) result.warnings = [...result.warnings ?? [], "Its parent, children and dependencies were in its old project, so they were dropped: whiteboards relate only within a project."];
+		}, previous ? () => {
+			this.assertWritable(id);
+			if (change.baseVersion !== void 0) assertBaseVersion(change.baseVersion, this.currentVersion(id));
+			else this.assertMutation(id, previous.version);
+			holds();
+		} : void 0, change.courier && {
+			...change.courier,
+			owned: (owner) => {
+				if (snapshot.lastEdit) snapshot.lastEdit.activityId = owner;
+			}
+		}, shown);
+		return result;
+	}
+	/** A create's named project, else its repository's; an edit keeps its
+	* project unless it moves repository. */
+	projectFor(snapshot, previous, named) {
+		if (named !== void 0) {
+			if (!this.db.prepare("SELECT 1 FROM projects WHERE id=?").get(named)) throw new ReviewInputError(`Unknown project ${named}; use a project.id from session_list.`);
+			return named;
+		}
+		const repository = snapshot.target?.repositoryId;
+		if (previous && (!repository || repository === previous.target?.repositoryId || !this.db.prepare("SELECT 1 FROM repositories WHERE id=?").get(repository))) return this.projectOf(snapshot.reviewId);
+		return repository ? this.projectOfRepository(repository) : this.fallbackProject();
+	}
+	currentVersion(reviewId) {
+		return Number(this.db.prepare("SELECT version FROM reviews WHERE id=?").get(reviewId).version);
+	}
+	/** Runs one write after every write queued before it. */
+	enqueue(work) {
+		if (this.closing) return Promise.reject(/* @__PURE__ */ new Error("Review store is closing."));
+		const run = this.pending.then(work);
 		this.pending = run.catch(() => {});
 		return run;
 	}
+	/** Respells a document's links and resolves its commit links, as every
+	* save does. A changed reference is no longer stale. */
+	async normalizeDocument(snapshot, previous) {
+		snapshot.document = await this.resolveCommitLinks(respellDocumentLinks(snapshot.document), snapshot, previous.document);
+		if (snapshot.staleSources?.length) {
+			const oldSources = new Map(sourceReferences(previous.document, { repositoryId: boardRepositoryId(previous) }).map((item) => [item.id, JSON.stringify(item.source)]));
+			const newSources = new Map(sourceReferences(snapshot.document, { repositoryId: boardRepositoryId(snapshot) }).map((item) => [item.id, JSON.stringify(item.source)]));
+			snapshot.staleSources = snapshot.staleSources.filter((id) => oldSources.get(id) === newSources.get(id) && newSources.has(id));
+		}
+	}
+	/** Checks a candidate version and numbers it. A worktree board's version
+	* may come back with its live source projected. */
+	async prepareVersion(candidate, previous, options) {
+		const snapshot = candidate.target?.kind === "worktree" && options.projectLive ? await this.projectLiveSource(candidate) : candidate;
+		checkReferences(snapshot.document);
+		if (!options.restore) this.checkBoardLinks(snapshot, previous, options.person);
+		if (snapshot.pins && (!previous || JSON.stringify(previous.pins) !== JSON.stringify(snapshot.pins))) await this.providers.validatePins(snapshot.pins);
+		const advised = new Set(documentAdvice(previous?.document ?? []));
+		const warnings = [...documentAdvice(snapshot.document).filter((advice) => !advised.has(advice)), ...await this.validateExternal(snapshot, previous, options.repin)];
+		snapshot.version = previous ? previous.version + 1 : 0;
+		snapshot.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+		return {
+			snapshot,
+			warnings
+		};
+	}
+	/** Writes a version; call inside commitCommand. */
+	saveVersion(snapshot, nextId, projectId, author) {
+		const id = snapshot.reviewId;
+		this.db.prepare("INSERT INTO reviews(id,version,next_id,project_id) VALUES(?,?,?,?) ON CONFLICT(id) DO UPDATE SET version=excluded.version,next_id=excluded.next_id,project_id=excluded.project_id").run(id, snapshot.version, nextId, projectId);
+		this.db.prepare("INSERT INTO versions(review_id,version,snapshot,thread_id,author_kind) VALUES(?,?,?,?,?)").run(id, snapshot.version, JSON.stringify(snapshot), versionThread(snapshot), author.kind);
+		this.indexBoardLinks(id, snapshot.document);
+	}
+	/** Deletes a board and its history, if it is still at the version read
+	* and passes `guard`: Delete… from Trash, Trash's purge and a discarded
+	* empty board all end here. An agent can't delete a board while a person
+	* holds a block in it. */
+	deleteBoard({ reviewId, version }, author, { guard, fromTrash = false } = {}) {
+		const result = {
+			reviewId,
+			version,
+			deleted: true
+		};
+		const rules = () => {
+			guard?.();
+			if (fromTrash && !this.trashTime(reviewId)) throw new ReviewInputError("Move this whiteboard to Trash before deleting it.", 409);
+			this.assertMutation(reviewId, version);
+			if (author.kind !== "person") this.assertUnheld(reviewId);
+		};
+		rules();
+		this.commitCommand(result, () => this.removePermanently(reviewId), rules);
+		this.leases.delete(reviewId);
+		return result;
+	}
+	/** Writes what a board is outside its versions: its parent or what it
+	* depends on, Trash or back, or that it was viewed. No version is saved,
+	* but the rules are a version's: a board in Trash takes nothing but a
+	* restore, and an agent can't put a board a person is in to Trash. */
+	commitBoardFacts(reviewId, author, fact) {
+		const lifecycle = "state" in fact;
+		const rules = () => {
+			this.assertExists(reviewId);
+			if (!lifecycle) this.assertOutOfTrash(reviewId);
+			else if (fact.state === "trash" && author.kind !== "person") this.assertUnheld(reviewId);
+		};
+		rules();
+		const result = {
+			reviewId,
+			version: this.read(reviewId).version
+		};
+		if (lifecycle || "viewed" in fact) result.attention = true;
+		if (lifecycle) result.lifecycle = true;
+		this.commitCommand(result, () => {
+			if ("parentId" in fact) this.setParent(reviewId, fact.parentId);
+			else if ("dependsOn" in fact) this.setDependencies(reviewId, fact.dependsOn);
+			else {
+				this.db.prepare("INSERT OR IGNORE INTO review_attention(review_id) VALUES(?)").run(reviewId);
+				if ("viewed" in fact) this.db.prepare("UPDATE review_attention SET viewed_at=? WHERE review_id=?").run((/* @__PURE__ */ new Date()).toISOString(), reviewId);
+				else {
+					const timestamp = fact.state === "trash" ? (/* @__PURE__ */ new Date()).toISOString() : null;
+					this.db.prepare("UPDATE review_attention SET deleted_at=CASE WHEN ? IS NULL THEN NULL ELSE COALESCE(deleted_at, ?) END WHERE review_id=?").run(timestamp, timestamp, reviewId);
+				}
+			}
+			if ("parentId" in fact || "dependsOn" in fact) result.relations = this.relations(reviewId);
+		}, rules);
+		return result;
+	}
+	/** Deletes a board the person made and left as it was: with no title
+	* (it reads "Untitled"), no blocks and no child boards. A title typed as
+	* "Untitled" is a title. A board still open on a canvas, or
+	* one an agent is working on, is kept. A closing canvas saves, then lets
+	* go of the board, so the discard waits for that first. */
+	async discard(reviewId) {
+		const deadline = Date.now() + FOCUS_LEASE_TTL_MS;
+		while (this.leased(reviewId) && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, DISCARD_POLL_MS));
+		return this.enqueue(async () => {
+			if (!this.has(reviewId)) return { deleted: false };
+			const snapshot = this.read(reviewId);
+			if (this.leased(reviewId) || this.activity.isWorking(reviewId) || snapshot.title !== "" || snapshot.document.length || this.relationGraph(true).children.get(reviewId)?.length) return { deleted: false };
+			this.deleteBoard(snapshot, { kind: "person" });
+			return { deleted: true };
+		});
+	}
+	/** Each board's canvas leases by client: the board is open there, and
+	* `blockId` is the block the person is in, if any. In memory: a lease
+	* outlives neither its renewals nor the host. */
+	leases = /* @__PURE__ */ new Map();
+	/** Whether a canvas still holds the board open. */
+	leased(reviewId) {
+		const now = Date.now();
+		return [...this.leases.get(reviewId)?.values() ?? []].some((lease) => lease.expiresAt > now);
+	}
+	/** Records the block a person's canvas has focus in (null for none), or
+	* with `open: false` that the canvas closed the board. */
+	focus(reviewId, input) {
+		const { clientId, blockId, open } = focusLeaseSchema.parse(input);
+		this.assertExists(reviewId);
+		const leases = this.leases.get(reviewId) ?? /* @__PURE__ */ new Map();
+		if (open === false) leases.delete(clientId);
+		else leases.set(clientId, {
+			blockId,
+			expiresAt: Date.now() + FOCUS_LEASE_TTL_MS
+		});
+		if (leases.size) this.leases.set(reviewId, leases);
+		else this.leases.delete(reviewId);
+		return { ok: true };
+	}
+	/** Refuses an agent's change to a board while a person holds any block
+	* in it. */
+	assertUnheld(reviewId) {
+		const now = Date.now();
+		for (const lease of this.leases.get(reviewId)?.values() ?? []) if (lease.expiresAt > now && lease.blockId) throw new ReviewInputError(`The user is editing this block (${lease.blockId}). Edit another block, or try again after they move on.`, 409);
+	}
+	/** Refuses an agent's edit to a block a person is editing. */
+	assertUnleased(reviewId, changed) {
+		const leases = this.leases.get(reviewId);
+		if (!leases || !changed.length) return;
+		const now = Date.now();
+		for (const [clientId, lease] of leases) if (lease.expiresAt <= now) leases.delete(clientId);
+		else if (lease.blockId && changed.includes(lease.blockId)) throw new ReviewInputError(`The user is editing this block (${lease.blockId}). Edit another block, or try again after they move on.`, 409);
+	}
+	/** Saves a person's whole board as their own version, against the version
+	* they started from. Blocks without ids get fresh ones. */
+	personEdit(reviewId, input) {
+		const body = personEditSchema.parse(input);
+		return this.enqueue(async () => {
+			const previous = this.read(reviewId);
+			assertBaseVersion(body.baseVersion, previous.version);
+			const { document, nextId, ids } = personDocument(body.document, Number(this.db.prepare("SELECT next_id FROM reviews WHERE id=?").get(reviewId).next_id));
+			const snapshot = structuredClone(previous);
+			delete snapshot.sourceUnavailable;
+			delete snapshot.lastEdit;
+			snapshot.title = body.title;
+			snapshot.document = document;
+			const { version } = await this.commitVersion({
+				snapshot,
+				previous,
+				nextId,
+				author: { kind: "person" },
+				projectLive: true,
+				personIds: ids,
+				baseVersion: body.baseVersion,
+				unchangedSavesNothing: true
+			});
+			return {
+				reviewId,
+				version,
+				ids
+			};
+		});
+	}
+	/** Where a board sits: its parent, and the parent's children in order,
+	* each with what its header shows. */
+	place(id) {
+		const graph = this.relationGraph(true);
+		const parentId = graph.parents.get(id);
+		const placed = (reviewId) => {
+			const row = this.db.prepare(`SELECT json_extract(versions.snapshot,'$.title') AS title,
+            json_extract(versions.snapshot,'$.target') AS target,
+            json_extract(versions.snapshot,'$.origin') AS origin
+          FROM reviews JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+          WHERE reviews.id=?`).get(reviewId);
+			return {
+				reviewId,
+				title: String(row.title),
+				...row.target && { target: JSON.parse(String(row.target)) },
+				...row.origin && { origin: JSON.parse(String(row.origin)) }
+			};
+		};
+		return {
+			board: placed(id),
+			...parentId && { parent: placed(parentId) },
+			siblings: parentId ? this.orderChildren(this.listedSiblings(graph.children.get(parentId), id), graph).map(placed) : [],
+			...!parentId && { children: this.orderChildren(this.listedSiblings(graph.children.get(id) ?? [], id), graph).map(placed) }
+		};
+	}
+	/** The siblings Home and the sidebar list, which a board's place counts
+	* among: all but those in Trash, and the board itself. */
+	listedSiblings(ids, self) {
+		const trashed = new Set(this.trashedIds());
+		return ids.filter((id) => id === self || !trashed.has(id));
+	}
+	/** A board's parent, its children in sibling order, and what it depends on. */
+	relations(id) {
+		const graph = this.relationGraph();
+		return {
+			parentId: graph.parents.get(id) ?? null,
+			children: this.orderChildren(graph.children.get(id) ?? [], graph),
+			dependsOn: graph.dependsOn.get(id) ?? []
+		};
+	}
+	/** Parents, children and dependencies. A board in Trash is out of them
+	* until it is restored, its rows kept; only its own place sees it. */
+	relationGraph(withTrash = false) {
+		const parents = /* @__PURE__ */ new Map();
+		const children = /* @__PURE__ */ new Map();
+		const dependsOn = /* @__PURE__ */ new Map();
+		const trashed = new Set(withTrash ? [] : this.trashedIds());
+		for (const row of this.db.prepare("SELECT id, parent_id FROM reviews WHERE parent_id IS NOT NULL ORDER BY rowid").all()) {
+			const board = String(row.id);
+			const parent = String(row.parent_id);
+			if (trashed.has(board) || trashed.has(parent)) continue;
+			parents.set(board, parent);
+			children.set(parent, [...children.get(parent) ?? [], board]);
+		}
+		for (const row of this.db.prepare("SELECT review_id, depends_on FROM board_dependencies ORDER BY rowid").all()) {
+			const board = String(row.review_id);
+			const dependency = String(row.depends_on);
+			if (trashed.has(board) || trashed.has(dependency)) continue;
+			dependsOn.set(board, [...dependsOn.get(board) ?? [], dependency]);
+		}
+		return {
+			parents,
+			children,
+			dependsOn
+		};
+	}
+	/** Drops a board's parent, children and dependencies in other projects,
+	* after it moved to `projectId`. Whether it dropped any. */
+	dropRelationsOutside(id, projectId) {
+		const outside = "SELECT id FROM reviews WHERE project_id!=?";
+		const parents = this.db.prepare(`UPDATE reviews SET parent_id=NULL WHERE (id=? AND parent_id IN (${outside})) OR (parent_id=? AND project_id!=?)`).run(id, projectId, id, projectId).changes;
+		const dependencies = this.db.prepare(`DELETE FROM board_dependencies WHERE (review_id=? AND depends_on IN (${outside})) OR (depends_on=? AND review_id IN (${outside}))`).run(id, projectId, id, projectId).changes;
+		return Number(parents) + Number(dependencies) > 0;
+	}
+	orderChildren(children, graph) {
+		if (children.length < 2) return [...children];
+		return orderSiblings(this.siblingFacts(children), (id) => graph.dependsOn.get(id) ?? [], (repositoryId, ancestor, of) => this.isAncestor(repositoryId, ancestor, of));
+	}
+	siblingFacts(ids) {
+		return this.db.prepare(`SELECT reviews.id,
+          (SELECT json_extract(first.snapshot,'$.createdAt') FROM versions AS first
+            WHERE first.review_id=reviews.id ORDER BY first.version LIMIT 1) AS created_at,
+          json_extract(versions.snapshot,'$.pins') AS pins,
+          json_extract(versions.snapshot,'$.origin.branch') AS branch,
+          json_extract(versions.snapshot,'$.origin.pullRequestUrl') AS url
+        FROM reviews JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+        WHERE reviews.id IN (${ids.map(() => "?").join(",")})`).all(...ids).map((row) => {
+			const id = String(row.id);
+			const saved = row.pins ? JSON.parse(String(row.pins)) : void 0;
+			const pins = this.liveSources.get(id)?.pins ?? saved;
+			const url = row.url ? String(row.url) : void 0;
+			const baseBranch = url && this.providers.pullRequestBaseBranch?.(url);
+			return {
+				id,
+				createdAt: String(row.created_at),
+				...pins && {
+					repositoryId: pins.repositoryId,
+					base: pins.base,
+					head: pins.head
+				},
+				...url && row.branch && { headBranch: String(row.branch) },
+				...baseBranch && { baseBranch }
+			};
+		});
+	}
+	/** Commits never change, so a definite answer is kept. */
+	ancestry = /* @__PURE__ */ new Map();
+	/** When git was last asked, for questions with no answer yet. */
+	ancestryAsked = /* @__PURE__ */ new Map();
+	/** Whether `ancestor` is an ancestor of `of`, as far as is known. git is
+	* asked in the background, never on the server thread: until it answers,
+	* or when it fails, the answer is no, and a yes re-sorts the catalog. */
+	isAncestor(repositoryId, ancestor, of) {
+		const key = `${repositoryId}:${ancestor}:${of}`;
+		const known = this.ancestry.get(key);
+		if (known !== void 0) return known;
+		const asked = this.ancestryAsked.get(key);
+		if (asked !== void 0 && Date.now() - asked < 6e4) return false;
+		this.ancestryAsked.set(key, Date.now());
+		let root;
+		try {
+			root = this.repositoryPath(repositoryId);
+		} catch {
+			return false;
+		}
+		this.ancestryQueue.push(() => runVcs("git", [
+			"-C",
+			root,
+			"merge-base",
+			"--is-ancestor",
+			{ rev: ancestor },
+			{ rev: of }
+		], { timeout: 1e4 }).then(() => this.knowAncestry(key, true), (error) => {
+			if (error.code === 1) this.knowAncestry(key, false);
+		}));
+		this.askNextAncestry();
+		return false;
+	}
+	ancestryQueue = [];
+	ancestryRunning = 0;
+	askNextAncestry() {
+		while (this.ancestryRunning < ANCESTRY_CONCURRENCY && this.ancestryQueue.length) {
+			this.ancestryRunning++;
+			this.ancestryQueue.shift()().finally(() => {
+				this.ancestryRunning--;
+				this.askNextAncestry();
+			});
+		}
+	}
+	knowAncestry(key, ancestor) {
+		this.ancestry.set(key, ancestor);
+		this.ancestryAsked.delete(key);
+		if (ancestor && !this.closing) this.catalogChanged();
+	}
+	catalogChanged() {
+		for (const listener of this.catalogListeners) try {
+			listener();
+		} catch {}
+	}
+	boardName(id) {
+		return `"${boardTitle(this.read(id).title)}" (${id})`;
+	}
+	/** Exists, out of Trash, same project. */
+	checkRelated(id, other) {
+		if (!this.has(other)) throw new ReviewInputError(`Whiteboard ${other} does not exist. Name a whiteboard by its sessionId from session_list.`);
+		this.assertOutOfTrash(other);
+		if (this.projectOf(id) !== this.projectOf(other)) throw new ReviewInputError(`${this.boardName(other)} is in another project than ${this.boardName(id)}. A whiteboard's parent and dependencies are in its own project.`);
+	}
+	/** One parent, one level: a parent is top-level and a child has no
+	* children, Trash included. Null makes the board top-level. */
+	setParent(id, parentId) {
+		if (parentId !== null) {
+			if (parentId === id) throw new ReviewInputError("A whiteboard can't be its own parent.");
+			this.checkRelated(id, parentId);
+			const { parents, children } = this.relationGraph(true);
+			const grandparent = parents.get(parentId);
+			if (grandparent) throw new ReviewInputError(`${this.boardName(parentId)} is a child of ${this.boardName(grandparent)}, and whiteboards nest one level deep. Use ${grandparent} as the parent instead.`);
+			const own = children.get(id) ?? [];
+			if (own.length) throw new ReviewInputError(`${this.boardName(id)} has children (${own.map((child) => this.boardName(child)).join(", ")}), and whiteboards nest one level deep, so it can't become a child. Move its children first with session_set_parent.`);
+		}
+		this.db.prepare("UPDATE reviews SET parent_id=? WHERE id=?").run(parentId, id);
+	}
+	setDependencies(id, dependsOn) {
+		const unique = [...new Set(dependsOn)];
+		const graph = this.relationGraph(true);
+		for (const dependency of unique) {
+			if (dependency === id) throw new ReviewInputError("A whiteboard can't depend on itself.");
+			const cycle = dependencyCycle(id, dependency, (board) => graph.dependsOn.get(board) ?? []);
+			if (cycle) throw new ReviewInputError(`Depending on ${this.boardName(dependency)} would close a cycle: ${cycle.map((board) => this.boardName(board)).join(" → ")}. Drop one of those dependencies first.`);
+			this.checkRelated(id, dependency);
+		}
+		this.db.prepare("DELETE FROM board_dependencies WHERE review_id=?").run(id);
+		const insert = this.db.prepare("INSERT INTO board_dependencies(review_id,depends_on) VALUES(?,?)");
+		for (const dependency of unique) insert.run(id, dependency);
+	}
+	/** New links must point at a board and block that exist. Saved links are
+	* not rechecked, since their target may have been deleted. */
+	checkBoardLinks(snapshot, previous, person = false) {
+		const key = ({ to }) => `${to.board}#${to.block ?? ""}`;
+		const kept = new Set(boardLinks(snapshot.reviewId, previous?.document ?? []).map(key));
+		for (const link of boardLinks(snapshot.reviewId, snapshot.document)) {
+			if (kept.has(key(link))) continue;
+			const { from, to } = link;
+			const document = to.board === snapshot.reviewId ? snapshot.document : this.has(to.board) ? this.read(to.board).document : void 0;
+			if (!document && person && this.wasDeleted(to.board)) continue;
+			if (!document) throw new ReviewInputError(`Block ${from.block} links to board ${to.board}, which does not exist. Link a board by its sessionId from session_list.`);
+			if (!person && to.block !== void 0 && !elements(document).some((element) => element.id === to.block)) throw new ReviewInputError(`Block ${from.block} links to block ${to.block}, which is not on board ${to.board}. Read the board with session_get for its block ids.`);
+		}
+	}
+	wasDeleted(id) {
+		return this.db.prepare("SELECT 1 FROM deleted_boards WHERE id=?").get(id) !== void 0;
+	}
+	/** The boards that link to a board or its blocks. */
+	linkingBoards(id) {
+		return this.db.prepare("SELECT DISTINCT from_review FROM board_links WHERE to_review=?").all(id).map((row) => String(row.from_review));
+	}
+	/** Rebuilds the board_links rows for one board. */
+	indexBoardLinks(id, document) {
+		this.db.prepare("DELETE FROM board_links WHERE from_review=?").run(id);
+		const insert = this.db.prepare("INSERT INTO board_links(from_review,from_block,to_review,to_block) VALUES(?,?,?,?)");
+		for (const { from, to } of boardLinks(id, document)) insert.run(from.board, from.block, to.board, to.block ?? null);
+	}
+	/** Link previews by board, version and block; a version never changes. */
+	linkPreviews = /* @__PURE__ */ new Map();
+	linkPreview(target, block) {
+		const key = `${target.reviewId}@${target.version}#${block ?? ""}`;
+		let preview = this.linkPreviews.get(key);
+		if (!preview) {
+			preview = boardLinkPreview(target.document, block);
+			if (this.linkPreviews.size >= 500) this.linkPreviews.delete(this.linkPreviews.keys().next().value);
+			this.linkPreviews.set(key, preview);
+		}
+		return preview;
+	}
+	/** What a link's hover card shows of the board or block it links to,
+	* read when the card opens rather than with every link. Only for a link
+	* the version has. */
+	linkPeek(id, to, version) {
+		if (!boardLinks(id, this.read(id, version).document).some((link) => link.to.board === to.board && link.to.block === to.block) || !this.has(to.board)) throw new ReviewInputError("The board has no such link.", 404);
+		return this.linkPreview(this.read(to.board), to.block);
+	}
+	/** "owner / repo" for a board whose origin names one, else its folder. */
+	repositoryLabel(board) {
+		const repositoryId = board.target?.repositoryId;
+		if (!repositoryId) return void 0;
+		try {
+			return this.repositoryGroup(this.repositoryPath(repositoryId))?.label.split("/").join(" / ");
+		} catch {
+			return;
+		}
+	}
+	/** A version's outgoing links and the board's current backlinks. Links to a
+	* deleted board or block are marked missing. */
+	links(id, version) {
+		const titles = /* @__PURE__ */ new Map();
+		const board = (reviewId) => {
+			if (!titles.has(reviewId)) titles.set(reviewId, this.has(reviewId) ? this.read(reviewId) : void 0);
+			return titles.get(reviewId);
+		};
+		return {
+			outgoing: boardLinks(id, this.read(id, version).document).map(({ from, to }) => {
+				const target = board(to.board);
+				const missing = !target || to.block !== void 0 && !elements(target.document).some((element) => element.id === to.block);
+				const deleted = target ? void 0 : this.db.prepare("SELECT title,deleted_at FROM deleted_boards WHERE id=?").get(to.board);
+				return {
+					from,
+					to,
+					...target && {
+						title: target.title,
+						icon: boardIconKind(target.target),
+						...this.repositoryLabel(target) && { repository: this.repositoryLabel(target) },
+						...target.origin?.pullRequestNumber && {
+							pullRequestNumber: target.origin.pullRequestNumber,
+							pullRequestUrl: target.origin.pullRequestUrl
+						},
+						updatedAt: target.createdAt
+					},
+					missing,
+					...deleted && {
+						title: String(deleted.title),
+						deletedAt: String(deleted.deleted_at)
+					}
+				};
+			}),
+			backlinks: this.db.prepare("SELECT DISTINCT from_review,from_block,to_block FROM board_links WHERE to_review=? AND from_review<>? ORDER BY from_review").all(id, id).map((row) => {
+				const from = board(String(row.from_review));
+				return {
+					from: {
+						board: String(row.from_review),
+						block: String(row.from_block)
+					},
+					to: row.to_block === null ? { board: id } : {
+						board: id,
+						block: String(row.to_block)
+					},
+					title: from?.title ?? "",
+					...from && { icon: boardIconKind(from.target) },
+					...from?.origin?.pullRequestNumber && {
+						pullRequestNumber: from.origin.pullRequestNumber,
+						pullRequestUrl: from.origin.pullRequestUrl
+					}
+				};
+			})
+		};
+	}
+	/** Boards edited by an Ask thread, most recent first. */
+	boardsChangedBy(threadId) {
+		return this.db.prepare(`SELECT edits.review_id, MAX(edits.version) AS last
+        FROM versions edits
+        JOIN reviews ON reviews.id=edits.review_id
+        WHERE edits.thread_id=?
+        GROUP BY edits.review_id ORDER BY MAX(json_extract(edits.snapshot,'$.createdAt')) DESC`).all(threadId).map((row) => {
+			const board = this.read(String(row.review_id));
+			const blockId = this.read(board.reviewId, Number(row.last)).lastEdit?.blockId;
+			return {
+				reviewId: board.reviewId,
+				title: board.title,
+				icon: boardIconKind(board.target),
+				...blockId && elements(board.document).some((element) => element.id === blockId) && { blockId }
+			};
+		});
+	}
+	/** The boards each thread changed, newest first, for many threads in one
+	* query. */
+	/** A board's title and icon, read without its document. */
+	/** Where a board lives, as Recent names it: its checkout's folder, else
+	* its project's name. */
+	boardPlace(reviewId) {
+		const row = this.db.prepare(`SELECT repositories.path, projects.name FROM reviews
+        JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+        LEFT JOIN repositories ON repositories.id=${BOARD_REPOSITORY_ID_SQL}
+        LEFT JOIN projects ON projects.id=reviews.project_id
+        WHERE reviews.id=?`).get(reviewId);
+		return row?.path && path.basename(String(row.path)) || (row?.name ? String(row.name) : "");
+	}
+	boardFace(reviewId) {
+		const row = this.db.prepare(`SELECT json_extract(versions.snapshot,'$.title') AS title, json_extract(versions.snapshot,'$.target') AS target
+        FROM reviews JOIN versions ON versions.review_id=reviews.id AND versions.version=reviews.version
+        WHERE reviews.id=?`).get(reviewId);
+		return {
+			reviewId,
+			title: String(row.title),
+			icon: boardIconKind(row.target ? JSON.parse(String(row.target)) : void 0)
+		};
+	}
+	boardsChangedByThreads(threadIds) {
+		const changed = /* @__PURE__ */ new Map();
+		if (!threadIds.length) return changed;
+		const rows = this.db.prepare(`SELECT thread_id AS thread, review_id
+        FROM versions
+        WHERE thread_id IN (${threadIds.map(() => "?").join(",")})
+        GROUP BY thread, review_id ORDER BY MAX(rowid) DESC`).all(...threadIds);
+		const boards = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const reviewId = String(row.review_id);
+			if (!boards.has(reviewId)) boards.set(reviewId, this.has(reviewId) ? this.boardFace(reviewId) : void 0);
+			const board = boards.get(reviewId);
+			if (!board) continue;
+			const thread = String(row.thread);
+			changed.set(thread, [...changed.get(thread) ?? [], board]);
+		}
+		return changed;
+	}
 	/** 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 (op.type !== "create" || op.target || !op.pullRequestUrl) return void 0;
 		if (!this.providers.resolvePullRequest) return Promise.reject(new ReviewInputError("Pull request targets are unavailable."));
+		if (!op.repositoryId) return Promise.reject(new ReviewInputError("Name the checkout to fetch the PR into: target {kind:\"pullRequest\", repositoryPath, pullRequest}."));
 		const [existing] = op.reuseExisting === false ? [] : this.reviewsForPullRequest(op.pullRequestUrl);
 		if (existing) try {
 			this.assertReusableReview(existing);
 		} catch (error) {
 			return Promise.reject(error);
 		}
-		return this.providers.resolvePullRequest(op.pullRequestUrl, {
-			id: op.repositoryId,
-			preferred: existing && this.read(existing).pins?.repositoryId
-		});
+		return this.providers.resolvePullRequest(op.pullRequestUrl, { id: op.repositoryId });
 	}
 	startPullRequestTitle(command) {
 		const op = command.operation;
@@ -2785,7 +4622,7 @@ var ReviewStore = class {
 	existingReview(reviewId, others, requested) {
 		const snapshot = this.read(reviewId);
 		this.assertReusableReview(reviewId);
-		const headMoved = snapshot.pins?.repositoryId !== requested.repositoryId || snapshot.pins?.head !== requested.head;
+		const headMoved = snapshot.pins?.head !== requested.head;
 		const working = this.activity.read(reviewId).activities ?? [];
 		return {
 			created: false,
@@ -2803,7 +4640,7 @@ var ReviewStore = class {
 			...others.length > 0 && { otherReviewIds: others }
 		};
 	}
-	commitCommand(result, apply, guard, attribution) {
+	commitCommand(result, apply, guard, attribution, shown) {
 		this.db.exec("BEGIN IMMEDIATE");
 		let owner;
 		try {
@@ -2821,7 +4658,10 @@ var ReviewStore = class {
 		}
 		if (result.deleted) this.activity.deleted(result.reviewId);
 		else if (owner) this.activity.extended(result.reviewId);
-		this.notify(result);
+		this.notify({
+			...result,
+			...shown
+		});
 	}
 	assertMutation(reviewId, version) {
 		const current = this.db.prepare("SELECT version FROM reviews WHERE id=?").get(reviewId);
@@ -2830,7 +4670,7 @@ var ReviewStore = class {
 	notify(result) {
 		if (result.deleted) this.observedVersions.delete(result.reviewId);
 		else if (!result.attention) this.observedVersions.set(result.reviewId, result.version);
-		if (!result.attention || result.lifecycle) for (const listener of this.listeners) try {
+		if ((!result.attention || result.lifecycle) && !result.relations) for (const listener of this.listeners) try {
 			listener(result);
 		} catch {}
 		for (const listener of this.catalogListeners) try {
@@ -2844,9 +4684,26 @@ var ReviewStore = class {
 	has(reviewId) {
 		return this.db.prepare("SELECT 1 FROM reviews WHERE id=?").get(reviewId) !== void 0;
 	}
+	/** Saves each new commit link's commit in full, resolved in the board's
+	* repository; one it does not have rejects the edit, as pins do. A link the
+	* board already had stays as it was saved, even if its commit is gone. */
+	async resolveCommitLinks(document, board, previous) {
+		const saved = new Set(previous ? commitLinkCommits(previous) : []);
+		const commits = commitLinkCommits(document).filter((commit) => !saved.has(commit));
+		const repositoryId = boardRepositoryId(board);
+		if (!commits.length || !repositoryId || !this.providers.resolveCommit) return document;
+		const resolved = /* @__PURE__ */ new Map();
+		await Promise.all(commits.map(async (commit) => {
+			const full = await this.providers.resolveCommit(repositoryId, commit);
+			if (!full) throw new ReviewInputError(`Commit ${commit} is not in the board's repository. Fetch it first, or link a commit the repository has.`);
+			resolved.set(commit, full);
+		}));
+		return respellCommitLinks(document, resolved);
+	}
 	async validateExternal(snapshot, previous, repin = false) {
 		const warnings = [];
-		const references = (document, tolerant = false, lenses = []) => {
+		const references = (board, tolerant = false) => {
+			const { document, lenses = [] } = board;
 			const sources = /* @__PURE__ */ new Map();
 			const resources = /* @__PURE__ */ new Map();
 			const add = (source, peek) => {
@@ -2857,7 +4714,10 @@ var ReviewStore = class {
 					peek: peek || (kept?.peek ?? false)
 				});
 			};
-			for (const { source, peek } of sourceReferences(document, { tolerant })) add(source, peek === true);
+			for (const { source, peek } of sourceReferences(document, {
+				tolerant,
+				repositoryId: boardRepositoryId(board)
+			})) 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 {
@@ -2865,18 +4725,18 @@ var ReviewStore = class {
 				resources
 			};
 		};
-		const current = references(snapshot.document, repin, snapshot.lenses);
+		const current = references(snapshot, repin);
 		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 retained = references(previous ?? { document: [] }, true);
 		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.`);
+				if (repin && !readsWhereItDid(source, previous?.pins) && (!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}`);
@@ -2890,6 +4750,106 @@ var ReviewStore = class {
 		return warnings.sort();
 	}
 };
+/** The highest number in a document's `prefix-N` ids, units included. */
+function highestIdNumber(document) {
+	let highest = 0;
+	for (const [, number] of JSON.stringify(document).matchAll(/"id":"[^"]*?-(\d+)"/g)) highest = Math.max(highest, Number(number));
+	return highest;
+}
+/** The title of a board a person made and has not named. */
+/** A person's save must start from the board's current version. */
+function assertBaseVersion(base, current) {
+	if (base !== current) throw new ReviewInputError(`The board changed since version ${base}; it is now at version ${current}. Merge the latest version and save again.`, 409);
+}
+/**
+* A person's whole document as the store saves it: each new block's
+* clientKey taken, the blocks parsed, a flow's units adopted and every block
+* without an id given the next one after `nextId`. Every save then respells
+* its links (respellDocumentLinks) and resolves commit links it has not
+* saved before. Mutates `input`.
+*/
+function personDocument(input, nextId) {
+	const keys = takeClientKeys(input);
+	const document = documentSchema.parse(input);
+	const allocate = (prefix) => `${prefix}-${++nextId}`;
+	adoptFlowUnits(document, allocate);
+	for (const block of document) assignMissingIds(block, allocate);
+	assertUniqueIds(document);
+	return {
+		document,
+		nextId: Math.max(nextId, highestIdNumber(document)),
+		ids: Object.fromEntries([...keys.byPath].map(([path, key]) => [key, blockAt(document, path).id]))
+	};
+}
+const clientKeySchema = z.string().min(1).optional();
+/** Removes each block's clientKey from a person's raw document, keeping it
+* by the block's path when the block has no id. Counts the bare blocks. */
+function takeClientKeys(document) {
+	const byPath = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	let bare = 0;
+	const visit = (list, prefix) => list.forEach((block, index) => {
+		if (!isJsonObject(block)) return;
+		const path = `${prefix}${index}`;
+		const clientKey = clientKeySchema.parse(block.clientKey);
+		delete block.clientKey;
+		if (block.id === void 0) {
+			bare++;
+			if (clientKey !== void 0) {
+				if (seen.has(clientKey)) throw new ReviewInputError(`clientKey ${clientKey} names more than one block. Give each new block its own clientKey.`);
+				seen.add(clientKey);
+				byPath.set(path, clientKey);
+			}
+		}
+		if (Array.isArray(block.children)) visit(block.children, `${path}/`);
+	});
+	visit(document, "");
+	return {
+		byPath,
+		bare
+	};
+}
+/** The block at a path takeClientKeys recorded. */
+function blockAt(document, path) {
+	const [first, ...rest] = path.split("/").map(Number);
+	let block = document[first];
+	for (const index of rest) if ("children" in block) block = block.children[index];
+	return block;
+}
+/** Ids name one component each across the whole document. */
+function assertUniqueIds(document) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const { id } of elements(document)) {
+		if (id === void 0) continue;
+		if (seen.has(id)) throw new ReviewInputError(`Id ${id} names more than one component. Give each block its own id, or leave a new block's id out.`);
+		seen.add(id);
+	}
+}
+/** Each block's own content by id, nested blocks included. A section or
+* callout is kept without its children, so a change to a child is only the
+* child's. */
+function ownBlocks(document, into = /* @__PURE__ */ new Map()) {
+	for (const block of document) if ("children" in block) {
+		const { children, ...own } = block;
+		if (block.id !== void 0) into.set(block.id, own);
+		ownBlocks(children, into);
+	} else if (block.id !== void 0) into.set(block.id, block);
+	return into;
+}
+/** The blocks added, removed or changed from one document to the next. A
+* block moved with its content unchanged did not change. */
+function changedBlocks(before, after) {
+	const old = ownBlocks(before);
+	const now = ownBlocks(after);
+	return [.../* @__PURE__ */ new Set([...old.keys(), ...now.keys()])].filter((id) => !isDeepStrictEqual(old.get(id), now.get(id)));
+}
+/** Whether a reference's own pins read the commit the board's previous
+* pins did. */
+function readsWhereItDid(source, previous) {
+	if (!source.pins || !previous) return false;
+	const commit = source.side === "base" ? source.pins.base ?? source.pins.head : source.pins.head;
+	return source.pins.repositoryId === previous.repositoryId && (commit === previous.head || commit === previous.base);
+}
 /** Without a resolver, a commits target that names both commits pins them as
 * given; validatePins still checks they exist. */
 function namedCommits(target) {
@@ -2906,26 +4866,19 @@ function namedCommits(target) {
 }
 /** 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 {
+function createdSnapshot(id, op, resolved, defaultTitle, untitled = false) {
+	const title = op.title || defaultTitle || (untitled ? "" : void 0);
+	if (title === void 0) throw new ReviewInputError("Supply a title.");
+	const snapshot = {
 		reviewId: id,
 		version: 0,
 		title,
-		pins: resolved.pins,
 		target: resolved.target,
 		document: [],
 		createdAt: ""
 	};
+	if (resolved.pins) snapshot.pins = resolved.pins;
+	return snapshot;
 }
 function inspectSnapshot(snapshot, targetId) {
 	if (targetId !== void 0) {
@@ -2939,6 +4892,8 @@ function inspectSnapshot(snapshot, targetId) {
 		label: "title" in element ? element.title : "label" in element ? element.label : element.type === "markdown" ? element.markdown.slice(0, 120) : void 0
 	}));
 }
+/** How many ancestry questions git answers at once. */
+const ANCESTRY_CONCURRENCY = 8;
 //#endregion
 //#region src/review-api/version-cache.ts
 /** A stored version never changes, so work derived from it runs once. Keeps
@@ -3371,7 +5326,6 @@ var ReviewWorkspaces = class {
 };
 //#endregion
 //#region src/review-api/worktree-events.ts
-const exec$1 = promisify(execFile);
 const normalize = (name) => name.replaceAll("\\", "/").normalize("NFC");
 const parent = (file) => file.slice(0, Math.max(0, file.lastIndexOf("/")));
 /** Directories that hold tracked files, the root as "". */
@@ -3394,7 +5348,7 @@ function atTrackedEdge(name, tracked) {
 /** Wholly ignored directories, so watchers can skip them. */
 async function ignoredDirectories(rootPath, gitDirectory) {
 	try {
-		const { stdout } = await exec$1("git", [
+		const { stdout } = await runVcs("git", [
 			"-C",
 			rootPath,
 			...gitDirectory ? [
@@ -3433,7 +5387,7 @@ function gitEventMatters(name, prefix) {
 /** Where this checkout's git directory sits in the common one: "" for the main checkout. */
 async function gitDirectoryPrefix(rootPath, common) {
 	try {
-		const { stdout } = await exec$1("git", [
+		const { stdout } = await runVcs("git", [
 			"-C",
 			rootPath,
 			"rev-parse",
@@ -3449,7 +5403,6 @@ async function gitDirectoryPrefix(rootPath, common) {
 //#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) {
@@ -3464,7 +5417,7 @@ async function localSourcePath(root, file) {
 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", [
+	const { stdout } = await runVcs("git", [
 		"-C",
 		vcs.rootPath,
 		...gitDirectory ? [
@@ -3500,7 +5453,7 @@ async function workingFiles(vcs) {
 async function untrackedFileCount(vcs) {
 	if (vcs.kind !== "git") return void 0;
 	try {
-		const { stdout } = await exec("git", [
+		const { stdout } = await runVcs("git", [
 			"-C",
 			vcs.rootPath,
 			"ls-files",
@@ -3580,6 +5533,10 @@ function sliceRange(file, source) {
 		text: inputError(() => sliceSourceRange(file.text, source))
 	};
 }
+/** How long a PR's state is shown before it is read again. */
+const PULL_REQUEST_STATE_TTL_MS = 3e5;
+/** How many PR states are read from GitHub at once. */
+const PULL_REQUEST_STATE_READS = 2;
 /** Local source/resource boundary, including Desktop-only local language context. */
 var LocalReviewData = class {
 	store;
@@ -3657,7 +5614,7 @@ var LocalReviewData = class {
 			};
 		}
 		if (commit && !anchor) await this.comparison(await this.documentPins(snapshot), commit);
-		const repositoryId = anchor?.repositoryId ?? snapshot.pins?.repositoryId;
+		const repositoryId = anchor?.repositoryId ?? snapshot.pins?.repositoryId ?? (snapshot.target?.kind === "project" ? snapshot.target.repositoryId : void 0);
 		if (!repositoryId) throw new ReviewInputError("This document has no source pins of its own.", 409);
 		const unavailable = {
 			rootPath: null,
@@ -3712,7 +5669,7 @@ var LocalReviewData = class {
 		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", [
+			const { stdout } = await runVcs("git", [
 				"-C",
 				rootPath,
 				"status",
@@ -3727,7 +5684,7 @@ var LocalReviewData = class {
 		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 title = `${boardTitle(snapshot.title)} — ${live ? "Live source" : side === "base" ? "Base source" : "Source"} — Whiteboard`;
 			const workspace = previous ?? {
 				folders: [],
 				settings: { "files.readonlyInclude": { "**/*": true } }
@@ -3764,12 +5721,25 @@ var LocalReviewData = class {
 			rootPath
 		};
 	}
-	/** A document read that needs default pins; 409 when the document has none. */
+	/** A document read that needs default pins: its own, or for a plan its
+	* repository's live checkout with base at head; 409 when it has neither. */
 	async documentPins(snapshot) {
-		const pins = await this.sourcePins(snapshot);
+		const pins = await this.sourcePins(snapshot) ?? (snapshot.target?.kind === "project" ? await this.livePins(snapshot.target.repositoryId) : void 0);
 		if (!pins) throw new ReviewInputError("This document has no source pins of its own.", 409);
 		return pins;
 	}
+	/** A checkout's current state, base at head: what a plan reads. */
+	async livePins(repositoryId) {
+		const vcs = await this.vcs(repositoryId);
+		if (!vcs) throw unavailableCheckout();
+		const { revision, commit } = await this.worktreeState(repositoryId, vcs);
+		return {
+			repositoryId,
+			base: commit,
+			head: commit,
+			worktreeRevision: revision
+		};
+	}
 	/** Pins a reference names itself, checked against the registered checkout. */
 	async anchorSourcePins(anchor) {
 		if (!existsSync(this.store.repositoryPath(anchor.repositoryId))) throw unavailableCheckout();
@@ -3779,7 +5749,10 @@ var LocalReviewData = class {
 	* `snapshot` is a stored version. */
 	async unavailableAnchors(snapshot) {
 		const missing = /* @__PURE__ */ new Set();
-		for (const repositoryId of pinnedRepositoryIds(snapshot.document)) try {
+		const repositoryIds = pinnedRepositoryIds(snapshot.document);
+		const boardRepository = boardRepositoryId(snapshot);
+		if (boardRepository) repositoryIds.add(boardRepository);
+		for (const repositoryId of repositoryIds) try {
 			if (!existsSync(this.store.repositoryPath(repositoryId))) missing.add(repositoryId);
 		} catch (error) {
 			if (!(error instanceof ReviewInputError)) throw error;
@@ -3788,7 +5761,10 @@ var LocalReviewData = class {
 		if (!missing.size) return [];
 		return this.storedReferences.get(snapshot).filter((ref) => ref.source.pins && missing.has(ref.source.pins.repositoryId)).map((ref) => ref.id);
 	}
-	storedReferences = new VersionCache((snapshot) => sourceReferences(snapshot.document, { tolerant: true }), { capacity: 512 });
+	storedReferences = new VersionCache((snapshot) => sourceReferences(snapshot.document, {
+		tolerant: true,
+		repositoryId: boardRepositoryId(snapshot)
+	}), { capacity: 512 });
 	trackedFiles = /* @__PURE__ */ new Map();
 	repositories = /* @__PURE__ */ new Map();
 	readers = /* @__PURE__ */ new Map();
@@ -4010,7 +5986,10 @@ var LocalReviewData = class {
 			staleSources: []
 		};
 		delete projected.sourceUnavailable;
-		for (const reference of sourceReferences(snapshot.document, { tolerant: true })) try {
+		for (const reference of sourceReferences(snapshot.document, {
+			tolerant: true,
+			repositoryId: boardRepositoryId(snapshot)
+		})) try {
 			await this.quote(anchorPins(reference.source, pins), reference.source);
 		} catch (error) {
 			if (!(error instanceof ReviewInputError)) throw error;
@@ -4022,6 +6001,7 @@ var LocalReviewData = class {
 	* 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.target?.kind === "project" && !existsSync(this.store.repositoryPath(snapshot.target.repositoryId))) throw unavailableCheckout();
 		if (!snapshot.pins) return void 0;
 		if (!existsSync(this.store.repositoryPath(snapshot.pins.repositoryId))) throw unavailableCheckout();
 		return snapshot.pins;
@@ -4031,14 +6011,13 @@ var LocalReviewData = class {
 		const vcs = await this.vcs(pins.repositoryId);
 		if (!vcs || vcs.kind !== "git") return void 0;
 		try {
-			const { stdout } = await promisify(execFile)("git", [
+			const { stdout } = await runVcs("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
+				!headRef || /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(headRef) ? "HEAD" : { rev: headRef }
 			]);
 			const ref = stdout.trim();
 			if (!ref.startsWith("refs/heads/") && !ref.startsWith("refs/remotes/")) return void 0;
@@ -4051,6 +6030,7 @@ var LocalReviewData = class {
 	/** `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) {
+		if (target.kind === "project") throw new ReviewInputError("A project target has no commits.");
 		const vcs = await this.vcs(target.repositoryId);
 		if (!vcs) throw unavailableCheckout();
 		if (target.kind === "commits") {
@@ -4115,6 +6095,86 @@ var LocalReviewData = class {
 			commit: fork.commit
 		};
 	}
+	/** Each PR's state, by URL, as last read. */
+	pullRequestStates = /* @__PURE__ */ new Map();
+	pullRequestStateListeners = /* @__PURE__ */ new Set();
+	pullRequestStateTimer;
+	pullRequestStateQueue = [];
+	pullRequestStateReads = 0;
+	/** While GitHub rate-limits, no state is read. */
+	pullRequestStatesPausedUntil = 0;
+	/** Calls back when a PR's state changes. While anyone listens, every PR
+	* still shown is read again once its state is a few minutes old. */
+	subscribePullRequestStates(listener) {
+		this.pullRequestStateListeners.add(listener);
+		this.pullRequestStateTimer ??= setInterval(() => {
+			for (const [url, entry] of this.pullRequestStates) if (Date.now() - entry.seenAt > 2 * PULL_REQUEST_STATE_TTL_MS) this.pullRequestStates.delete(url);
+			else this.pullRequestState(url, { seen: false });
+			this.readPullRequestStates();
+		}, PULL_REQUEST_STATE_TTL_MS / 5);
+		this.pullRequestStateTimer.unref?.();
+		return () => {
+			this.pullRequestStateListeners.delete(listener);
+			if (!this.pullRequestStateListeners.size) {
+				clearInterval(this.pullRequestStateTimer);
+				this.pullRequestStateTimer = void 0;
+			}
+		};
+	}
+	/** A PR's state as last read from GitHub; a read older than a few minutes
+	* queues another in the background. Undefined until the first read lands,
+	* and a failed read keeps the last state. A merged or closed PR is not
+	* read again. */
+	pullRequestState(url, { seen = true } = {}) {
+		if (!url || !this.options.pullRequestStates) return void 0;
+		const entry = this.pullRequestStates.get(url) ?? {
+			readAt: 0,
+			seenAt: 0,
+			reading: false
+		};
+		this.pullRequestStates.set(url, entry);
+		if (seen) entry.seenAt = Date.now();
+		if (!entry.reading && entry.state !== "merged" && entry.state !== "closed" && Date.now() - entry.readAt > PULL_REQUEST_STATE_TTL_MS) {
+			entry.reading = true;
+			this.pullRequestStateQueue.push(url);
+			this.readPullRequestStates();
+		}
+		return entry.state;
+	}
+	/** Reads queued PR states a few at a time. */
+	readPullRequestStates() {
+		while (this.pullRequestStateReads < PULL_REQUEST_STATE_READS && this.pullRequestStateQueue.length && Date.now() >= this.pullRequestStatesPausedUntil) {
+			const url = this.pullRequestStateQueue.shift();
+			const entry = this.pullRequestStates.get(url);
+			if (!entry) continue;
+			this.pullRequestStateReads++;
+			Promise.resolve().then(() => {
+				const { provider, address } = resolvePullRequest(url);
+				return provider.readPullRequest(address, this.options.pullRequests ?? defaultPullRequestDeps);
+			}).then((pullRequest) => {
+				if ((!pullRequest.state || pullRequest.state === entry.state) && pullRequest.baseRefName === entry.baseBranch && pullRequest.headBranch === entry.headBranch) return;
+				entry.state = pullRequest.state ?? entry.state;
+				entry.baseBranch = pullRequest.baseRefName;
+				entry.headBranch = pullRequest.headBranch;
+				for (const listener of this.pullRequestStateListeners) listener();
+			}).catch((error) => {
+				if (error instanceof GitHubRefusedRead) this.pullRequestStatesPausedUntil = error.retryAt;
+			}).finally(() => {
+				entry.readAt = Date.now();
+				entry.reading = false;
+				this.pullRequestStateReads--;
+				this.readPullRequestStates();
+			});
+		}
+	}
+	/** The branch a PR merges into, as last read with its state. */
+	pullRequestBaseBranch(url) {
+		return this.pullRequestStates.get(url)?.baseBranch;
+	}
+	/** A PR's own branch, as last read with its state. */
+	pullRequestHeadBranch(url) {
+		return this.pullRequestStates.get(url)?.headBranch;
+	}
 	/** The PR's current comparison, fetched into a registered checkout of its repository. */
 	async resolvePullRequest(url, repository) {
 		const deps = this.options.pullRequests ?? defaultPullRequestDeps;
@@ -4155,9 +6215,8 @@ var LocalReviewData = class {
 	}
 	/** A registered checkout with a remote for host/owner/repo, and that remote. */
 	async pullRequestCheckout(provider, address, 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);
+		const candidates = this.store.repositories().filter((entry) => entry.id === repository.id);
+		if (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);
@@ -4174,7 +6233,7 @@ var LocalReviewData = class {
 		}
 		const { host, slug } = address;
 		const name = host === "github.com" ? slug : `${host}/${slug}`;
-		throw new ReviewInputError(repository.id ? `That checkout has no remote for ${name}. Add one, or omit repositoryId.` : `No registered checkout has a remote for ${name}. Register a checkout of ${name} with review_register_repository first, or pass a target.`, 404);
+		throw new ReviewInputError(`That checkout has no remote for ${name}. Name a checkout of ${name} as the target's repositoryPath.`, 404);
 	}
 	async resolvePins(repositoryId, base, head) {
 		const vcs = await this.vcs(repositoryId);
@@ -4206,6 +6265,45 @@ var LocalReviewData = class {
 			head
 		};
 	}
+	/** What a commit is, for a quote read at it: its subject, author and
+	* date, and how far behind the default branch's tip it is when both are
+	* known. */
+	async commitInfo(repositoryId, commit) {
+		const vcs = await this.vcs(repositoryId);
+		if (!vcs) throw unavailableCheckout();
+		const git = async (...args) => (await runVcs("git", [
+			"-C",
+			vcs.rootPath,
+			...args
+		])).stdout.trim();
+		let line;
+		try {
+			line = await git("log", "-1", "--format=%H%x00%s%x00%an%x00%aI", { rev: commit });
+		} catch {
+			throw new ReviewInputError("That commit is not in the repository.", 404);
+		}
+		const [full = commit, subject = "", author = "", authoredAt = ""] = line.split("\0");
+		const branch = await vcs.defaultBranch().catch(() => null);
+		const behind = branch ? await git("rev-list", "--count", { rev: `${full}..${branch.commit}` }).then((count) => ({
+			count: Number(count),
+			branch: branch.ref.replace(/^origin\//, "")
+		})).catch(() => void 0) : void 0;
+		return {
+			commit: full,
+			subject,
+			author,
+			authoredAt,
+			...behind && { behind }
+		};
+	}
+	/** The full commit a commit ID or its prefix names in the repository,
+	* or undefined when it names none. */
+	async resolveCommit(repositoryId, commit) {
+		const vcs = await this.vcs(repositoryId);
+		if (!vcs) throw unavailableCheckout();
+		const resolved = await vcs.resolveRevision(commit);
+		return resolved?.commit.startsWith(commit.toLowerCase()) ? resolved.commit : void 0;
+	}
 	async validatePins(pins) {
 		if (pins.worktreeRevision) {
 			if (!await this.vcs(pins.repositoryId)) throw unavailableCheckout();
@@ -4568,6 +6666,7 @@ async function unwatch(entry) {
 /** Linux fails to unwatch a directory that is already gone. */
 const release = (subscription) => subscription.unsubscribe().catch(() => {});
 function openLocalReviewStore(databasePath, options = {}) {
+	const { checkoutOwners, ...dataOptions } = options;
 	const store = new ReviewStore(databasePath, {
 		projectSource: (snapshot, pins) => data.projectSource(snapshot, pins),
 		resolveTarget: (target, pinned) => data.resolveTarget(target, pinned),
@@ -4577,14 +6676,16 @@ function openLocalReviewStore(databasePath, options = {}) {
 		sourcePins: (snapshot) => data.sourcePins(snapshot),
 		unavailableAnchors: (snapshot) => data.unavailableAnchors(snapshot),
 		validatePins: (pins) => data.validatePins(pins),
+		resolveCommit: (repositoryId, commit) => data.resolveCommit(repositoryId, commit),
 		filesChangedBetween: (from, to) => data.filesChangedBetween(from, to),
 		validateSource: (pins, source, options) => data.validateSource(pins, source, options),
-		validateResource: (pins, block) => data.validateResource(pins, block)
-	});
+		validateResource: (pins, block) => data.validateResource(pins, block),
+		pullRequestBaseBranch: (url) => data.pullRequestBaseBranch(url)
+	}, checkoutOwners);
 	let data;
 	try {
 		data = new LocalReviewData(store, {
-			...options,
+			...dataOptions,
 			workspaceDatabase: `${databasePath}.workspaces`
 		});
 	} catch (error) {
@@ -4617,4 +6718,4 @@ async function readWorkspace(file) {
 	}
 }
 //#endregion
-export { inspectSnapshot as a, activityEndSchema as c, invalidateStructuralComparisons as d, diffrExecutable as f, commandSchema as i, activityUpdateSchema as l, uploadSchema as n, initializeReviewStoreSchema as o, diffrMissingError as p, SCRATCHPAD_ID as r, activityBeginSchema as s, openLocalReviewStore as t, pullRequestProvider as u };
+export { projectOfCheckout as a, activityBeginSchema as c, pullRequestProvider as d, textualRows as f, CheckoutGroups as g, diffrMissingError as h, inspectSnapshot as i, activityEndSchema as l, diffrExecutable as m, uploadSchema as n, groupCheckoutsAhead as o, invalidateStructuralComparisons as p, commandSchema as r, initializeReviewStoreSchema as s, openLocalReviewStore as t, activityUpdateSchema as u };