prreviewbuddy 0.92.0 → 0.95.2

package/dist/{mcp_tools-BKPpd9dN.js → mcp_tools-DDbcXys2.js}

@@ -1,13 +1,425 @@
-import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { execFile, execFileSync, spawn } from "node:child_process";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { accessSync, appendFileSync, closeSync, constants, existsSync, linkSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { homedir, hostname, tmpdir } from "node:os";
-import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { execFile, execFileSync, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { fileURLToPath } from "node:url";
 import { platform } from "node:process";
 import { connect } from "node:net";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
+//#region ../../packages/review-harness/src/workspace/store_root.ts
+/**
+* Where everything this product keeps on a machine lives, and nothing else.
+*
+* A leaf on purpose. It was a line in `store.ts`, which is the right place for it right up until
+* something needs the path without needing reviews: the postinstall script asks one question of
+* this directory (has this machine used PR Review Buddy before) and must not pull a review model,
+* a diff parser and a pull request extractor into its bundle to ask it. `store.ts` re-exports this,
+* so every existing import is unchanged and there is still one definition.
+*
+* It is also the one path `uninstall.ts` is allowed to delete outright, which is a property worth
+* being able to point at a single file for.
+*/
+var STORE_ROOT = join(homedir(), ".prreviewbuddy");
+//#endregion
+//#region ../../packages/review-harness/src/workspace/write_lock.ts
+/**
+* One lock file per name, taken exclusively, so a read-change-write in one process cannot land in
+* the middle of another's.
+*
+* Lifted out of `store.ts` unchanged, so the review queue can use it too. `queue.ts` cannot import
+* the store (the store's prune imports the queue, and the reverse import would close the cycle), and
+* a second lock written for the queue alone would be a second set of rules about stale holders to
+* get right. This module depends on `store_root.ts` and on Node, nothing else, for the same reason.
+*
+* Names share one directory. A review is locked under its id, a UUID, so a fixed word such as
+* `queue` can never collide with one.
+*/
+/** Raised when another process has held a review's write lock for longer than any write takes. */
+var WorkspaceWriteBusyError = class extends Error {
+	constructor() {
+		super("This review is being written by another process. Try again in a moment.");
+		this.name = "WorkspaceWriteBusyError";
+	}
+};
+var WRITE_LOCKS_DIR = join(STORE_ROOT, "locks");
+/** Every write under the lock is one read and one rename, milliseconds. This is a hang, not a queue. */
+var WRITE_LOCK_WAIT_MS = 5e3;
+/**
+* A lock this old is broken whoever holds it.
+*
+* Every hold is synchronous and lasts one read and one rename, so no live writer is anywhere near
+* this. It is the fallback for what a pid cannot say: a holder on another machine, a lock not yet
+* written out, and a pid that died and was reused by some unrelated long-lived process, which a
+* liveness check alone would read as the holder still working, for ever.
+*/
+var WRITE_LOCK_STALE_MS = 3e4;
+var heldWriteLocks = /* @__PURE__ */ new Map();
+var sleeper = new Int32Array(new SharedArrayBuffer(4));
+/**
+* One review's writes, one at a time across every process on the machine.
+*
+* The CLI and the workspace server are separate processes over one store. Without this, each could
+* load the same review, change its own fields and rename its result into place, and whichever
+* renamed last would discard the other: an update finishing in the terminal would put back a
+* question the reviewer had just ticked on the page. A file created exclusively is the lock, so it
+* holds between processes and needs nothing running to arbitrate.
+*
+* Synchronous, including the wait, because every write it guards is. It is held for a read and a
+* rename, so a wait is milliseconds; one that runs to `WRITE_LOCK_WAIT_MS` means a holder has hung,
+* and that is raised rather than written through. Re-entrant within a process, so a change made
+* under it can save without deadlocking itself. A lock left by a process that died is broken: at
+* once when its holder is on this machine and gone, and after `WRITE_LOCK_STALE_MS` in every case,
+* because a pid can be reused and a live one proves nothing about who took the lock.
+*/
+function withWriteLock(id, fn) {
+	const depth = heldWriteLocks.get(id) ?? 0;
+	if (depth > 0) {
+		heldWriteLocks.set(id, depth + 1);
+		try {
+			return fn();
+		} finally {
+			heldWriteLocks.set(id, depth);
+		}
+	}
+	mkdirSync(WRITE_LOCKS_DIR, { recursive: true });
+	const path = join(WRITE_LOCKS_DIR, `${id}.lock`);
+	const mine = {
+		token: randomUUID(),
+		pid: process.pid,
+		host: hostname(),
+		at: Date.now()
+	};
+	const deadline = Date.now() + WRITE_LOCK_WAIT_MS;
+	for (;;) {
+		try {
+			const fd = openSync(path, "wx", 384);
+			try {
+				writeSync(fd, JSON.stringify(mine));
+			} finally {
+				closeSync(fd);
+			}
+			break;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+		if (breakIfAbandoned(path)) continue;
+		if (Date.now() >= deadline) throw new WorkspaceWriteBusyError();
+		Atomics.wait(sleeper, 0, 0, 2);
+	}
+	heldWriteLocks.set(id, 1);
+	try {
+		return fn();
+	} finally {
+		heldWriteLocks.delete(id);
+		if (readHolder(path)?.token === mine.token) try {
+			unlinkSync(path);
+		} catch {}
+	}
+}
+function readHolder(path) {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+}
+/** Removes a lock whose holder is gone, and says whether it did. */
+function breakIfAbandoned(path) {
+	const holder = readHolder(path);
+	let age = 0;
+	try {
+		age = Date.now() - Math.min(statSync(path).mtimeMs, holder?.at ?? Infinity);
+	} catch {
+		return true;
+	}
+	if (!(age > WRITE_LOCK_STALE_MS || holder !== null && holder.host === hostname() && !processAlive(holder.pid))) return false;
+	if (readHolder(path)?.token !== holder?.token) return true;
+	try {
+		unlinkSync(path);
+	} catch {}
+	return true;
+}
+function processAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/collections.ts
+/**
+* Collections: the reviewer's own groups of reviews, such as everything in one refactor.
+*
+* A collection says what belongs together and nothing else. Whether a member still needs attention
+* is its lifecycle, which this file never reads or writes: assigning, removing, renaming and
+* deleting all leave every review's state exactly where it was.
+*
+* **Members are lineage keys, not review ids.** A card is a branch, and analysing the branch again
+* makes a new record with a new id. The queue stores ids and has to forward them (`forwardQueue`);
+* a lineage key is already what the card stands for, so membership survives updates, re-analysis
+* and restarts with nothing to keep in step.
+*
+* **Its own file**, for the reasons `queue.ts` gives: a record is rewritten whole by whoever loaded
+* it last and carries its diff inline, and `ui.json` is best-effort. And because a write here never
+* touches a record, it never moves the record's mtime, which is the clock retention runs on.
+* Organising a review is not opening or marking it.
+*
+* `STORE_ROOT` from `store_root.ts` rather than `store.ts`, for the import cycle `queue.ts` explains:
+* the prune in `store.ts` reads this file.
+*/
+var COLLECTIONS_PATH = join(STORE_ROOT, "collections.json");
+/** The lock's name. Reviews are locked under UUIDs in the same directory, so a word cannot collide. */
+var COLLECTIONS_LOCK = "collections";
+var VERSION$2 = 1;
+var ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+/** Whether a value is shaped like a collection's id, which is what a fold key and a route accept. */
+function isCollectionId$1(value) {
+	return typeof value === "string" && ID_PATTERN.test(value);
+}
+/**
+* Every collection, in the order they were created.
+*
+* Best-effort like `readQueue`: missing, unreadable and corrupt all mean "no collections". An entry
+* this code did not write is dropped rather than guessed at, and so is a second entry claiming an id
+* or a name already taken, so the rules `createCollection` keeps hold for a hand-edited file too.
+*/
+function readCollections() {
+	try {
+		const parsed = JSON.parse(readFileSync(COLLECTIONS_PATH, "utf8"));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+		const collections = parsed.collections;
+		return Array.isArray(collections) ? normalise$1(collections) : [];
+	} catch {
+		return [];
+	}
+}
+function normalise$1(raw) {
+	const kept = [];
+	for (const entry of raw) {
+		if (kept.length >= 100) break;
+		if (!entry || typeof entry !== "object") continue;
+		const { id, name, colour, createdAt, members } = entry;
+		const clean = typeof name === "string" ? cleanName(name) : "";
+		if (!isCollectionId$1(id) || clean === "" || clean.length > 60) continue;
+		if (typeof createdAt !== "number" || !Number.isFinite(createdAt)) continue;
+		if (kept.some((other) => other.id === id || sameName(other.name, clean))) continue;
+		const keys = Array.isArray(members) ? members.filter((key) => typeof key === "string" && key !== "") : [];
+		kept.push({
+			id,
+			name: clean,
+			...typeof colour === "string" && colour !== "" ? { colour } : {},
+			createdAt,
+			members: [...new Set(keys)].slice(0, 500)
+		});
+	}
+	return kept;
+}
+/** Spaces trimmed and runs of them collapsed, so "  Release   0.82 " is "Release 0.82". */
+function cleanName(name) {
+	return name.trim().replace(/\s+/g, " ");
+}
+/** Two names are one collection's name regardless of case: "refactor" is not a second Refactor. */
+function sameName(a, b) {
+	return a.localeCompare(b, void 0, { sensitivity: "base" }) === 0;
+}
+/**
+* The collection a typed name means, by the same rule that keeps names unique, so at most one can
+* match. By name only: a name that happens to look like an id is still a name.
+*/
+function collectionNamed(name, collections) {
+	const clean = cleanName(name);
+	return collections.find((collection) => sameName(collection.name, clean));
+}
+function nameProblem(name, collections, except) {
+	const clean = cleanName(name);
+	if (clean === "") return "empty";
+	if (clean.length > 60) return "too-long";
+	if (collections.some((collection) => collection.id !== except && sameName(collection.name, clean))) return "duplicate";
+}
+/** What a refused change says, in the words the page shows. */
+function nameProblemText(problem) {
+	if (problem === "empty") return "Give the collection a name.";
+	if (problem === "too-long") return `Use at most 60 characters for the name.`;
+	return "A collection with that name already exists.";
+}
+/**
+* Change the collections as they are on disk now, under the lock: the only way they are written.
+* Same contract as `updateQueue`: `change` returns what to store or null for nothing, and null from
+* here means the write failed.
+*/
+function updateCollections(change) {
+	try {
+		return withWriteLock(COLLECTIONS_LOCK, () => {
+			const current = readCollections();
+			const next = change(current);
+			return next === null ? current : writeUnlocked(next);
+		});
+	} catch {
+		return null;
+	}
+}
+/** To a temporary file and renamed into place, for the reason `writeQueueUnlocked` gives. */
+function writeUnlocked(collections) {
+	const next = normalise$1(collections);
+	mkdirSync(STORE_ROOT, { recursive: true });
+	const stored = {
+		version: VERSION$2,
+		collections: next
+	};
+	const temporary = `${COLLECTIONS_PATH}.${process.pid}.tmp`;
+	try {
+		writeFileSync(temporary, `${JSON.stringify(stored, null, 2)}\n`);
+		renameSync(temporary, COLLECTIONS_PATH);
+	} catch (error) {
+		try {
+			unlinkSync(temporary);
+		} catch {}
+		throw error;
+	}
+	return next;
+}
+function run$3(change) {
+	const outcome = {};
+	const stored = updateCollections((current) => {
+		const result = change(current);
+		if ("refused" in result) {
+			outcome.refused = result.refused;
+			return null;
+		}
+		outcome.id = result.id;
+		return result.next;
+	});
+	if (outcome.refused !== void 0) return {
+		ok: false,
+		reason: outcome.refused
+	};
+	if (stored === null) return {
+		ok: false,
+		reason: "unsaved"
+	};
+	return {
+		ok: true,
+		collections: stored,
+		...outcome.id === void 0 ? {} : { id: outcome.id }
+	};
+}
+function createCollection(name, now = Date.now()) {
+	return run$3((current) => {
+		const problem = nameProblem(name, current);
+		if (problem) return { refused: problem };
+		if (current.length >= 100) return { refused: "full" };
+		const id = randomUUID();
+		return {
+			next: [...current, {
+				id,
+				name: cleanName(name),
+				createdAt: now,
+				members: []
+			}],
+			id
+		};
+	});
+}
+/**
+* A new collection holding these lineages from the start: one transaction, so it is made with all of
+* them or not at all. "Create Refactor and add these three" never leaves an empty Refactor behind a
+* failure, and a retry never meets a duplicate name of its own making.
+*/
+function createWithMembers(name, keys, now = Date.now()) {
+	const members = [...new Set(keys.filter((key) => key !== ""))];
+	return run$3((current) => {
+		const problem = nameProblem(name, current);
+		if (problem) return { refused: problem };
+		if (current.length >= 100 || members.length > 500) return { refused: "full" };
+		const id = randomUUID();
+		return {
+			next: [...current, {
+				id,
+				name: cleanName(name),
+				createdAt: now,
+				members
+			}],
+			id
+		};
+	});
+}
+/** A new name on the same collection: its id, its members and every fold kept against the id stay. */
+function renameCollection(id, name) {
+	return run$3((current) => {
+		if (!current.some((collection) => collection.id === id)) return { refused: "missing" };
+		const problem = nameProblem(name, current, id);
+		if (problem) return { refused: problem };
+		return {
+			next: current.map((collection) => collection.id === id ? {
+				...collection,
+				name: cleanName(name)
+			} : collection),
+			id
+		};
+	});
+}
+/** The collection and its memberships go. No review is touched: they were never inside it. */
+function deleteCollection(id) {
+	return run$3((current) => {
+		if (!current.some((collection) => collection.id === id)) return { refused: "missing" };
+		return { next: current.filter((collection) => collection.id !== id) };
+	});
+}
+/**
+* Add the given lineages to one collection, or take them out of it.
+*
+* **Only the named collection is touched.** Assigning a selection to Refactor leaves every other
+* membership those reviews have exactly as it was, which is what makes a bulk assignment additive.
+* Adding a member already there and removing one that is not are both nothing, not errors: a mixed
+* selection is the ordinary case.
+*/
+function setMembership(keys, id, action) {
+	return run$3((current) => {
+		const target = current.find((collection) => collection.id === id);
+		if (!target) return { refused: "missing" };
+		const members = action === "add" ? [...target.members, ...keys.filter((key, at) => key !== "" && !target.members.includes(key) && keys.indexOf(key) === at)] : target.members.filter((key) => !keys.includes(key));
+		if (members.length === target.members.length && members.every((key, at) => key === target.members[at])) return {
+			next: null,
+			id
+		};
+		if (members.length > 500) return { refused: "full" };
+		return {
+			next: current.map((collection) => collection.id === id ? {
+				...collection,
+				members
+			} : collection),
+			id
+		};
+	});
+}
+/**
+* Take lineages out of every collection, because their reviews are gone. Stores nothing when none
+* of them was a member, so a deletion of an uncollected review never writes this file.
+*/
+function dropMembers(keys) {
+	const gone = new Set(keys);
+	return updateCollections((current) => current.some((collection) => collection.members.some((key) => gone.has(key))) ? current.map((collection) => ({
+		...collection,
+		members: collection.members.filter((key) => !gone.has(key))
+	})) : null);
+}
+/** Every lineage in at least one collection. What retention asks: collected is kept. */
+function collectedKeys(collections = readCollections()) {
+	return new Set(collections.flatMap((collection) => collection.members));
+}
+/** A token for the index's revision, as `queueStamp` is: it changes only when a person changes it. */
+function collectionsStamp() {
+	try {
+		return String(statSync(COLLECTIONS_PATH).mtimeMs);
+	} catch {
+		return "";
+	}
+}
+//#endregion
 //#region ../../packages/review-harness/src/agents/agent.ts
 /**
 * The variable every spawned agent runs under, and the structural half of containment.
@@ -327,7 +739,7 @@ function defaultConfigEnv(base) {
 	return env;
 }
 /** `claude` with these arguments, never through a shell. Resolves with its output. */
-function run$3(args, env) {
+function run$2(args, env) {
 	return new Promise((resolvePromise, reject) => {
 		execFile("claude", [...args], configCommandOptions(env), (error, stdout, stderr) => {
 			const settled = settleConfigCommand("claude", error, stdout, stderr);
@@ -396,10 +808,10 @@ var claudeMcpRegistration = {
 	configPath: configPath$1,
 	read: read$1,
 	async add(entry, base = process.env) {
-		await run$3(addCommand$1(entry).slice(1), defaultConfigEnv(base));
+		await run$2(addCommand$1(entry).slice(1), defaultConfigEnv(base));
 	},
 	async remove(base = process.env) {
-		await run$3(removeCommand$1().slice(1), defaultConfigEnv(base));
+		await run$2(removeCommand$1().slice(1), defaultConfigEnv(base));
 	},
 	addCommand: addCommand$1,
 	removeCommand: removeCommand$1,
@@ -1140,7 +1552,7 @@ function configPath(base = process.env) {
 	return join(base.CODEX_HOME || join(base.HOME || homedir(), ".codex"), "config.toml");
 }
 /** `codex` with these arguments, never through a shell. Resolves with its output. */
-function run$2(args, env) {
+function run$1(args, env) {
 	return new Promise((resolvePromise, reject) => {
 		execFile("codex", [...args], configCommandOptions(env), (error, stdout, stderr) => {
 			const settled = settleConfigCommand("codex", error, stdout, stderr);
@@ -1153,7 +1565,7 @@ function run$2(args, env) {
 async function read(base = process.env) {
 	let stdout;
 	try {
-		stdout = await run$2([
+		stdout = await run$1([
 			"mcp",
 			"get",
 			MCP_SERVER_NAME,
@@ -1208,10 +1620,10 @@ var codexMcpRegistration = {
 	configPath,
 	read,
 	async add(entry, base = process.env) {
-		await run$2(addCommand(entry).slice(1), base);
+		await run$1(addCommand(entry).slice(1), base);
 	},
 	async remove(base = process.env) {
-		await run$2(removeCommand().slice(1), base);
+		await run$1(removeCommand().slice(1), base);
 	},
 	addCommand,
 	removeCommand,
@@ -1714,21 +2126,6 @@ async function detectAgents() {
 	return detectAgents$1(AGENT_IDS.map((id) => AGENTS[id]));
 }
 //#endregion
-//#region ../../packages/review-harness/src/workspace/store_root.ts
-/**
-* Where everything this product keeps on a machine lives, and nothing else.
-*
-* A leaf on purpose. It was a line in `store.ts`, which is the right place for it right up until
-* something needs the path without needing reviews: the postinstall script asks one question of
-* this directory (has this machine used PR Review Buddy before) and must not pull a review model,
-* a diff parser and a pull request extractor into its bundle to ask it. `store.ts` re-exports this,
-* so every existing import is unchanged and there is still one definition.
-*
-* It is also the one path `uninstall.ts` is allowed to delete outright, which is a property worth
-* being able to point at a single file for.
-*/
-var STORE_ROOT = join(homedir(), ".prreviewbuddy");
-//#endregion
 //#region ../../packages/review-harness/src/workspace/config_file.ts
 /**
 * `config.json`, read and written as a whole so that no module can lose another's setting.
@@ -5800,183 +6197,56 @@ function isIssueOutstanding(issue, dispositions) {
 /**
 * A question is done when the reviewer has ticked it, or when the new commits answered it.
 *
-* Either alone is enough. The reviewer's tick is the older of the two and the only one the first
-* analysis can produce; `reconciliationStatus === 'answered'` arrives with an update and carries
-* `reconciliationAnswer` beside it, which is the answer itself. Requiring the tick as well would
-* make the reviewer hand-close seven questions the page had already answered in front of them.
-*
-* No `affected` expiry here, unlike an issue's dismissal. An issue is a claim about the code and a
-* dismissal is a bet on that code; a question the reviewer has answered was answered out of their
-* own head, and a commit somewhere near it does not un-know what they now know.
-*/
-function isQuestionOutstanding(question, answered, closedByVerdict) {
-	return !answered.has(question.id) && question.reconciliationStatus !== "answered" && !closedByVerdict(question.id);
-}
-function tally(items, outstanding, byReviewer) {
-	let open = 0;
-	let reviewerClosed = 0;
-	for (const item of items) if (outstanding(item)) open += 1;
-	else if (byReviewer(item)) reviewerClosed += 1;
-	return {
-		total: items.length,
-		open,
-		done: items.length - open,
-		reviewerClosed
-	};
-}
-function issuesOutstanding(issues, dispositions) {
-	const counts = tally(issues, (issue) => isIssueOutstanding(issue, dispositions), (issue) => issue.reconciliationStatus !== "resolved" && (dispositions.isClosedByVerdict(issue) || dispositions.isDismissed(issue)));
-	const byConversation = issues.filter(resolvedByConversation).length;
-	const byVerdict = issues.filter((issue) => issue.reconciliationStatus !== "resolved" && dispositions.isClosedByVerdict(issue)).length;
-	return {
-		...counts,
-		...byConversation > 0 ? { byConversation } : {},
-		...byVerdict > 0 ? { byVerdict } : {}
-	};
-}
-/** A finding whose resolution, as it stands, rests on the pull request conversation rather than a commit. */
-function resolvedByConversation(issue) {
-	return issue.reconciliationStatus === "resolved" && issue.statusHistory?.at(-1)?.basis === "conversation";
-}
-function questionsOutstanding(questions, answered, closedByVerdict) {
-	return tally(questions, (question) => isQuestionOutstanding(question, answered, closedByVerdict), (question) => question.reconciliationStatus !== "answered" && (answered.has(question.id) || closedByVerdict(question.id)));
-}
-/**
-* What to call the pile of findings nobody has to act on any more.
-*
-* "Resolved" is a claim about the code and is only true while the commits did all the closing. One
-* dismissal in there and the honest word is the vaguer one, because the reviewer deciding a finding
-* is acceptable did not resolve anything.
-*/
-function doneVerb(counts) {
-	return counts.reviewerClosed > 0 ? "dealt with" : "resolved";
-}
-//#endregion
-//#region ../../packages/review-harness/src/workspace/write_lock.ts
-/**
-* One lock file per name, taken exclusively, so a read-change-write in one process cannot land in
-* the middle of another's.
-*
-* Lifted out of `store.ts` unchanged, so the review queue can use it too. `queue.ts` cannot import
-* the store (the store's prune imports the queue, and the reverse import would close the cycle), and
-* a second lock written for the queue alone would be a second set of rules about stale holders to
-* get right. This module depends on `store_root.ts` and on Node, nothing else, for the same reason.
-*
-* Names share one directory. A review is locked under its id, a UUID, so a fixed word such as
-* `queue` can never collide with one.
-*/
-/** Raised when another process has held a review's write lock for longer than any write takes. */
-var WorkspaceWriteBusyError = class extends Error {
-	constructor() {
-		super("This review is being written by another process. Try again in a moment.");
-		this.name = "WorkspaceWriteBusyError";
-	}
-};
-var WRITE_LOCKS_DIR = join(STORE_ROOT, "locks");
-/** Every write under the lock is one read and one rename, milliseconds. This is a hang, not a queue. */
-var WRITE_LOCK_WAIT_MS = 5e3;
-/**
-* A lock this old is broken whoever holds it.
-*
-* Every hold is synchronous and lasts one read and one rename, so no live writer is anywhere near
-* this. It is the fallback for what a pid cannot say: a holder on another machine, a lock not yet
-* written out, and a pid that died and was reused by some unrelated long-lived process, which a
-* liveness check alone would read as the holder still working, for ever.
-*/
-var WRITE_LOCK_STALE_MS = 3e4;
-var heldWriteLocks = /* @__PURE__ */ new Map();
-var sleeper = new Int32Array(new SharedArrayBuffer(4));
-/**
-* One review's writes, one at a time across every process on the machine.
-*
-* The CLI and the workspace server are separate processes over one store. Without this, each could
-* load the same review, change its own fields and rename its result into place, and whichever
-* renamed last would discard the other: an update finishing in the terminal would put back a
-* question the reviewer had just ticked on the page. A file created exclusively is the lock, so it
-* holds between processes and needs nothing running to arbitrate.
-*
-* Synchronous, including the wait, because every write it guards is. It is held for a read and a
-* rename, so a wait is milliseconds; one that runs to `WRITE_LOCK_WAIT_MS` means a holder has hung,
-* and that is raised rather than written through. Re-entrant within a process, so a change made
-* under it can save without deadlocking itself. A lock left by a process that died is broken: at
-* once when its holder is on this machine and gone, and after `WRITE_LOCK_STALE_MS` in every case,
-* because a pid can be reused and a live one proves nothing about who took the lock.
-*/
-function withWriteLock(id, fn) {
-	const depth = heldWriteLocks.get(id) ?? 0;
-	if (depth > 0) {
-		heldWriteLocks.set(id, depth + 1);
-		try {
-			return fn();
-		} finally {
-			heldWriteLocks.set(id, depth);
-		}
-	}
-	mkdirSync(WRITE_LOCKS_DIR, { recursive: true });
-	const path = join(WRITE_LOCKS_DIR, `${id}.lock`);
-	const mine = {
-		token: randomUUID(),
-		pid: process.pid,
-		host: hostname(),
-		at: Date.now()
+* Either alone is enough. The reviewer's tick is the older of the two and the only one the first
+* analysis can produce; `reconciliationStatus === 'answered'` arrives with an update and carries
+* `reconciliationAnswer` beside it, which is the answer itself. Requiring the tick as well would
+* make the reviewer hand-close seven questions the page had already answered in front of them.
+*
+* No `affected` expiry here, unlike an issue's dismissal. An issue is a claim about the code and a
+* dismissal is a bet on that code; a question the reviewer has answered was answered out of their
+* own head, and a commit somewhere near it does not un-know what they now know.
+*/
+function isQuestionOutstanding(question, answered, closedByVerdict) {
+	return !answered.has(question.id) && question.reconciliationStatus !== "answered" && !closedByVerdict(question.id);
+}
+function tally(items, outstanding, byReviewer) {
+	let open = 0;
+	let reviewerClosed = 0;
+	for (const item of items) if (outstanding(item)) open += 1;
+	else if (byReviewer(item)) reviewerClosed += 1;
+	return {
+		total: items.length,
+		open,
+		done: items.length - open,
+		reviewerClosed
 	};
-	const deadline = Date.now() + WRITE_LOCK_WAIT_MS;
-	for (;;) {
-		try {
-			const fd = openSync(path, "wx", 384);
-			try {
-				writeSync(fd, JSON.stringify(mine));
-			} finally {
-				closeSync(fd);
-			}
-			break;
-		} catch (error) {
-			if (error.code !== "EEXIST") throw error;
-		}
-		if (breakIfAbandoned(path)) continue;
-		if (Date.now() >= deadline) throw new WorkspaceWriteBusyError();
-		Atomics.wait(sleeper, 0, 0, 2);
-	}
-	heldWriteLocks.set(id, 1);
-	try {
-		return fn();
-	} finally {
-		heldWriteLocks.delete(id);
-		if (readHolder(path)?.token === mine.token) try {
-			unlinkSync(path);
-		} catch {}
-	}
 }
-function readHolder(path) {
-	try {
-		return JSON.parse(readFileSync(path, "utf8"));
-	} catch {
-		return null;
-	}
+function issuesOutstanding(issues, dispositions) {
+	const counts = tally(issues, (issue) => isIssueOutstanding(issue, dispositions), (issue) => issue.reconciliationStatus !== "resolved" && (dispositions.isClosedByVerdict(issue) || dispositions.isDismissed(issue)));
+	const byConversation = issues.filter(resolvedByConversation).length;
+	const byVerdict = issues.filter((issue) => issue.reconciliationStatus !== "resolved" && dispositions.isClosedByVerdict(issue)).length;
+	return {
+		...counts,
+		...byConversation > 0 ? { byConversation } : {},
+		...byVerdict > 0 ? { byVerdict } : {}
+	};
 }
-/** Removes a lock whose holder is gone, and says whether it did. */
-function breakIfAbandoned(path) {
-	const holder = readHolder(path);
-	let age = 0;
-	try {
-		age = Date.now() - Math.min(statSync(path).mtimeMs, holder?.at ?? Infinity);
-	} catch {
-		return true;
-	}
-	if (!(age > WRITE_LOCK_STALE_MS || holder !== null && holder.host === hostname() && !processAlive(holder.pid))) return false;
-	if (readHolder(path)?.token !== holder?.token) return true;
-	try {
-		unlinkSync(path);
-	} catch {}
-	return true;
+/** A finding whose resolution, as it stands, rests on the pull request conversation rather than a commit. */
+function resolvedByConversation(issue) {
+	return issue.reconciliationStatus === "resolved" && issue.statusHistory?.at(-1)?.basis === "conversation";
 }
-function processAlive(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return error.code === "EPERM";
-	}
+function questionsOutstanding(questions, answered, closedByVerdict) {
+	return tally(questions, (question) => isQuestionOutstanding(question, answered, closedByVerdict), (question) => question.reconciliationStatus !== "answered" && (answered.has(question.id) || closedByVerdict(question.id)));
+}
+/**
+* What to call the pile of findings nobody has to act on any more.
+*
+* "Resolved" is a claim about the code and is only true while the commits did all the closing. One
+* dismissal in there and the honest word is the vaguer one, because the reviewer deciding a finding
+* is acceptable did not resolve anything.
+*/
+function doneVerb(counts) {
+	return counts.reviewerClosed > 0 ? "dealt with" : "resolved";
 }
 //#endregion
 //#region ../../packages/review-harness/src/workspace/queue.ts
@@ -6011,260 +6281,76 @@ var QUEUE_LOCK = "queue";
 * `version` is not branched on today. It exists so that a later shape change is a decision rather
 * than a guess about what an old file meant.
 */
-var VERSION$2 = 1;
-/**
-* What is queued, in order.
-*
-* Best-effort in the same way as `readPreferences`, and for the same reason: missing, unreadable
-* and corrupt all mean "nothing queued", and none of them is worth an error standing between the
-* reviewer and the list. Position is the array index throughout -- never stored per entry, because
-* two representations of one order eventually disagree about it.
-*/
-function readQueue() {
-	try {
-		const parsed = JSON.parse(readFileSync(QUEUE_PATH, "utf8"));
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
-		const ids = parsed.ids;
-		return Array.isArray(ids) ? normalise$1(ids) : [];
-	} catch {
-		return [];
-	}
-}
-/**
-* Change the queue as it is on disk now: read, change, write, with nothing able to land in between.
-*
-* **The only way the queue is written.** The workspace server and the CLI are separate processes
-* over this one file, and a `--queue` from the terminal can arrive while somebody is adding or
-* removing on the page. Each of them reading the queue, changing its copy and writing it back would
-* keep whichever wrote last and drop the other's change -- while both reported success. So the
-* whole read-change-write runs under the queue's cross-process lock, the same lock a review's own
-* writes take (see `write_lock.ts`).
-*
-* One lock, taken once, here. Every mutation below is one call to this and nothing inside `change`
-* writes, so the transaction is visibly this function's body and nothing depends on the lock being
-* re-entrant. `change` may read other files -- `queue_live.ts` asks which reviews still exist --
-* but must not write the queue or take another lock.
-*
-* `change` returns the queue to store, or null to store nothing, in which case the queue as it was
-* read is the answer. Null from this function means the write failed, including a lock held past
-* any real write, which is the same thing to the caller: it did not happen.
-*/
-function updateQueue(change) {
-	try {
-		return withWriteLock(QUEUE_LOCK, () => {
-			const current = readQueue();
-			const next = change(current);
-			return next === null ? current : writeQueueUnlocked(next);
-		});
-	} catch {
-		return null;
-	}
-}
-/**
-* The write itself, for `updateQueue` only: the caller holds the lock.
-*
-* To a temporary file and renamed into place, because a rename is atomic and a write is not.
-* `writeFileSync` empties the file before it fills it, and `readQueue` reads a file it cannot parse
-* as "nothing queued" -- so a reader in another process that caught it half-written would take the
-* queue to be empty and, on its next write, make it so. Found doing exactly that: four processes
-* adding twelve reviews each left one in the queue. The temporary name carries the pid so two
-* processes never share one, although under the lock they never write at once anyway.
-*/
-function writeQueueUnlocked(ids) {
-	const next = normalise$1(ids);
-	mkdirSync(STORE_ROOT, { recursive: true });
-	const stored = {
-		version: VERSION$2,
-		ids: next
-	};
-	const temporary = `${QUEUE_PATH}.${process.pid}.tmp`;
-	try {
-		writeFileSync(temporary, `${JSON.stringify(stored, null, 2)}\n`);
-		renameSync(temporary, QUEUE_PATH);
-	} catch (error) {
-		try {
-			unlinkSync(temporary);
-		} catch {}
-		throw error;
-	}
-	return next;
-}
-/**
-* Append, and leave a review already queued exactly where it is.
-*
-* Adding something twice is a no-op rather than a move. Nothing in this UI reorders a queue, so a
-* second Add that silently promoted a review would be the only control in the product that did --
-* and it would do it without ever saying so.
-*/
-function queueAdd(id) {
-	return updateQueue((current) => current.includes(id) ? null : [...current, id]);
-}
-/**
-* Append several, in the order given, for the reviews index's bulk bar.
-*
-* The same rules as `queueAdd` for each one, in one write. The cap is where this differs: one Add
-* at a time never meets it in practice, but a selection can hold a hundred cards, and `normalise`
-* would drop everything past fifty without a word. So what does not fit is left out *here* and
-* named in `full`, and the caller has something true to say about it.
-*/
-function queueAddMany(ids) {
-	let full = [];
-	const queue = updateQueue((current) => {
-		const fresh = ids.filter((id, at) => !current.includes(id) && ids.indexOf(id) === at);
-		const room = Math.max(0, 50 - current.length);
-		full = fresh.slice(room);
-		return fresh.length <= full.length ? null : [...current, ...fresh.slice(0, room)];
-	});
-	return queue === null ? null : {
-		queue,
-		full
-	};
-}
-function queueRemove(id) {
-	return updateQueue((current) => current.includes(id) ? current.filter((queued) => queued !== id) : null);
-}
-/**
-* A token for the index's revision, equality only.
-*
-* The queue changes only when a person deliberately changes it, so unlike a running job's progress
-* this cannot make the page reload itself in a loop. Absent reads as a stable empty string rather
-* than as a change, for the reason `refreshAction` gives: a missing field that reads as "different"
-* is a reload that asks again and reloads again.
-*/
-function queueStamp() {
-	try {
-		return String(statSync(QUEUE_PATH).mtimeMs);
-	} catch {
-		return "";
-	}
-}
-/** Strings only, first position wins, and never more than the cap. */
-function normalise$1(ids) {
-	const seen = [];
-	for (const id of ids) {
-		if (typeof id !== "string" || id === "" || seen.includes(id)) continue;
-		seen.push(id);
-		if (seen.length === 50) break;
-	}
-	return seen;
-}
-//#endregion
-//#region ../../packages/review-harness/src/workspace/collections.ts
-/**
-* Collections: the reviewer's own groups of reviews, such as everything in one refactor.
-*
-* A collection says what belongs together and nothing else. Whether a member still needs attention
-* is its lifecycle, which this file never reads or writes: assigning, removing, renaming and
-* deleting all leave every review's state exactly where it was.
-*
-* **Members are lineage keys, not review ids.** A card is a branch, and analysing the branch again
-* makes a new record with a new id. The queue stores ids and has to forward them (`forwardQueue`);
-* a lineage key is already what the card stands for, so membership survives updates, re-analysis
-* and restarts with nothing to keep in step.
-*
-* **Its own file**, for the reasons `queue.ts` gives: a record is rewritten whole by whoever loaded
-* it last and carries its diff inline, and `ui.json` is best-effort. And because a write here never
-* touches a record, it never moves the record's mtime, which is the clock retention runs on.
-* Organising a review is not opening or marking it.
-*
-* `STORE_ROOT` from `store_root.ts` rather than `store.ts`, for the import cycle `queue.ts` explains:
-* the prune in `store.ts` reads this file.
-*/
-var COLLECTIONS_PATH = join(STORE_ROOT, "collections.json");
-/** The lock's name. Reviews are locked under UUIDs in the same directory, so a word cannot collide. */
-var COLLECTIONS_LOCK = "collections";
 var VERSION$1 = 1;
-var ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-/** Whether a value is shaped like a collection's id, which is what a fold key and a route accept. */
-function isCollectionId(value) {
-	return typeof value === "string" && ID_PATTERN.test(value);
-}
 /**
-* Every collection, in the order they were created.
+* What is queued, in order.
 *
-* Best-effort like `readQueue`: missing, unreadable and corrupt all mean "no collections". An entry
-* this code did not write is dropped rather than guessed at, and so is a second entry claiming an id
-* or a name already taken, so the rules `createCollection` keeps hold for a hand-edited file too.
+* Best-effort in the same way as `readPreferences`, and for the same reason: missing, unreadable
+* and corrupt all mean "nothing queued", and none of them is worth an error standing between the
+* reviewer and the list. Position is the array index throughout -- never stored per entry, because
+* two representations of one order eventually disagree about it.
 */
-function readCollections() {
+function readQueue() {
 	try {
-		const parsed = JSON.parse(readFileSync(COLLECTIONS_PATH, "utf8"));
+		const parsed = JSON.parse(readFileSync(QUEUE_PATH, "utf8"));
 		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
-		const collections = parsed.collections;
-		return Array.isArray(collections) ? normalise(collections) : [];
+		const ids = parsed.ids;
+		return Array.isArray(ids) ? normalise(ids) : [];
 	} catch {
 		return [];
 	}
 }
-function normalise(raw) {
-	const kept = [];
-	for (const entry of raw) {
-		if (kept.length >= 100) break;
-		if (!entry || typeof entry !== "object") continue;
-		const { id, name, colour, createdAt, members } = entry;
-		const clean = typeof name === "string" ? cleanName(name) : "";
-		if (!isCollectionId(id) || clean === "" || clean.length > 60) continue;
-		if (typeof createdAt !== "number" || !Number.isFinite(createdAt)) continue;
-		if (kept.some((other) => other.id === id || sameName(other.name, clean))) continue;
-		const keys = Array.isArray(members) ? members.filter((key) => typeof key === "string" && key !== "") : [];
-		kept.push({
-			id,
-			name: clean,
-			...typeof colour === "string" && colour !== "" ? { colour } : {},
-			createdAt,
-			members: [...new Set(keys)].slice(0, 500)
-		});
-	}
-	return kept;
-}
-/** Spaces trimmed and runs of them collapsed, so "  Release   0.82 " is "Release 0.82". */
-function cleanName(name) {
-	return name.trim().replace(/\s+/g, " ");
-}
-/** Two names are one collection's name regardless of case: "refactor" is not a second Refactor. */
-function sameName(a, b) {
-	return a.localeCompare(b, void 0, { sensitivity: "base" }) === 0;
-}
-function nameProblem(name, collections, except) {
-	const clean = cleanName(name);
-	if (clean === "") return "empty";
-	if (clean.length > 60) return "too-long";
-	if (collections.some((collection) => collection.id !== except && sameName(collection.name, clean))) return "duplicate";
-}
-/** What a refused change says, in the words the page shows. */
-function nameProblemText(problem) {
-	if (problem === "empty") return "Give the collection a name.";
-	if (problem === "too-long") return `Keep the name under 61 characters.`;
-	return "A collection with that name already exists.";
-}
 /**
-* Change the collections as they are on disk now, under the lock: the only way they are written.
-* Same contract as `updateQueue`: `change` returns what to store or null for nothing, and null from
-* here means the write failed.
+* Change the queue as it is on disk now: read, change, write, with nothing able to land in between.
+*
+* **The only way the queue is written.** The workspace server and the CLI are separate processes
+* over this one file, and a `--queue` from the terminal can arrive while somebody is adding or
+* removing on the page. Each of them reading the queue, changing its copy and writing it back would
+* keep whichever wrote last and drop the other's change -- while both reported success. So the
+* whole read-change-write runs under the queue's cross-process lock, the same lock a review's own
+* writes take (see `write_lock.ts`).
+*
+* One lock, taken once, here. Every mutation below is one call to this and nothing inside `change`
+* writes, so the transaction is visibly this function's body and nothing depends on the lock being
+* re-entrant. `change` may read other files -- `queue_live.ts` asks which reviews still exist --
+* but must not write the queue or take another lock.
+*
+* `change` returns the queue to store, or null to store nothing, in which case the queue as it was
+* read is the answer. Null from this function means the write failed, including a lock held past
+* any real write, which is the same thing to the caller: it did not happen.
 */
-function updateCollections(change) {
+function updateQueue(change) {
 	try {
-		return withWriteLock(COLLECTIONS_LOCK, () => {
-			const current = readCollections();
+		return withWriteLock(QUEUE_LOCK, () => {
+			const current = readQueue();
 			const next = change(current);
-			return next === null ? current : writeUnlocked(next);
+			return next === null ? current : writeQueueUnlocked(next);
 		});
 	} catch {
 		return null;
 	}
 }
-/** To a temporary file and renamed into place, for the reason `writeQueueUnlocked` gives. */
-function writeUnlocked(collections) {
-	const next = normalise(collections);
+/**
+* The write itself, for `updateQueue` only: the caller holds the lock.
+*
+* To a temporary file and renamed into place, because a rename is atomic and a write is not.
+* `writeFileSync` empties the file before it fills it, and `readQueue` reads a file it cannot parse
+* as "nothing queued" -- so a reader in another process that caught it half-written would take the
+* queue to be empty and, on its next write, make it so. Found doing exactly that: four processes
+* adding twelve reviews each left one in the queue. The temporary name carries the pid so two
+* processes never share one, although under the lock they never write at once anyway.
+*/
+function writeQueueUnlocked(ids) {
+	const next = normalise(ids);
 	mkdirSync(STORE_ROOT, { recursive: true });
 	const stored = {
 		version: VERSION$1,
-		collections: next
+		ids: next
 	};
-	const temporary = `${COLLECTIONS_PATH}.${process.pid}.tmp`;
+	const temporary = `${QUEUE_PATH}.${process.pid}.tmp`;
 	try {
 		writeFileSync(temporary, `${JSON.stringify(stored, null, 2)}\n`);
-		renameSync(temporary, COLLECTIONS_PATH);
+		renameSync(temporary, QUEUE_PATH);
 	} catch (error) {
 		try {
 			unlinkSync(temporary);
@@ -6273,143 +6359,65 @@ function writeUnlocked(collections) {
 	}
 	return next;
 }
-function run$1(change) {
-	const outcome = {};
-	const stored = updateCollections((current) => {
-		const result = change(current);
-		if ("refused" in result) {
-			outcome.refused = result.refused;
-			return null;
-		}
-		outcome.id = result.id;
-		return result.next;
-	});
-	if (outcome.refused !== void 0) return {
-		ok: false,
-		reason: outcome.refused
-	};
-	if (stored === null) return {
-		ok: false,
-		reason: "unsaved"
-	};
-	return {
-		ok: true,
-		collections: stored,
-		...outcome.id === void 0 ? {} : { id: outcome.id }
-	};
-}
-function createCollection(name, now = Date.now()) {
-	return run$1((current) => {
-		const problem = nameProblem(name, current);
-		if (problem) return { refused: problem };
-		if (current.length >= 100) return { refused: "full" };
-		const id = randomUUID();
-		return {
-			next: [...current, {
-				id,
-				name: cleanName(name),
-				createdAt: now,
-				members: []
-			}],
-			id
-		};
-	});
-}
 /**
-* A new collection holding these lineages from the start: one transaction, so it is made with all of
-* them or not at all. "Create Refactor and add these three" never leaves an empty Refactor behind a
-* failure, and a retry never meets a duplicate name of its own making.
+* Append, and leave a review already queued exactly where it is.
+*
+* Adding something twice is a no-op rather than a move. Nothing in this UI reorders a queue, so a
+* second Add that silently promoted a review would be the only control in the product that did --
+* and it would do it without ever saying so.
 */
-function createWithMembers(name, keys, now = Date.now()) {
-	const members = [...new Set(keys.filter((key) => key !== ""))];
-	return run$1((current) => {
-		const problem = nameProblem(name, current);
-		if (problem) return { refused: problem };
-		if (current.length >= 100 || members.length > 500) return { refused: "full" };
-		const id = randomUUID();
-		return {
-			next: [...current, {
-				id,
-				name: cleanName(name),
-				createdAt: now,
-				members
-			}],
-			id
-		};
-	});
-}
-/** A new name on the same collection: its id, its members and every fold kept against the id stay. */
-function renameCollection(id, name) {
-	return run$1((current) => {
-		if (!current.some((collection) => collection.id === id)) return { refused: "missing" };
-		const problem = nameProblem(name, current, id);
-		if (problem) return { refused: problem };
-		return {
-			next: current.map((collection) => collection.id === id ? {
-				...collection,
-				name: cleanName(name)
-			} : collection),
-			id
-		};
-	});
-}
-/** The collection and its memberships go. No review is touched: they were never inside it. */
-function deleteCollection(id) {
-	return run$1((current) => {
-		if (!current.some((collection) => collection.id === id)) return { refused: "missing" };
-		return { next: current.filter((collection) => collection.id !== id) };
-	});
+function queueAdd(id) {
+	return updateQueue((current) => current.includes(id) ? null : [...current, id]);
 }
 /**
-* Add the given lineages to one collection, or take them out of it.
+* Append several, in the order given, for the reviews index's bulk bar.
 *
-* **Only the named collection is touched.** Assigning a selection to Refactor leaves every other
-* membership those reviews have exactly as it was, which is what makes a bulk assignment additive.
-* Adding a member already there and removing one that is not are both nothing, not errors: a mixed
-* selection is the ordinary case.
+* The same rules as `queueAdd` for each one, in one write. The cap is where this differs: one Add
+* at a time never meets it in practice, but a selection can hold a hundred cards, and `normalise`
+* would drop everything past fifty without a word. So what does not fit is left out *here* and
+* named in `full`, and the caller has something true to say about it.
 */
-function setMembership(keys, id, action) {
-	return run$1((current) => {
-		const target = current.find((collection) => collection.id === id);
-		if (!target) return { refused: "missing" };
-		const members = action === "add" ? [...target.members, ...keys.filter((key, at) => key !== "" && !target.members.includes(key) && keys.indexOf(key) === at)] : target.members.filter((key) => !keys.includes(key));
-		if (members.length === target.members.length && members.every((key, at) => key === target.members[at])) return {
-			next: null,
-			id
-		};
-		if (members.length > 500) return { refused: "full" };
-		return {
-			next: current.map((collection) => collection.id === id ? {
-				...collection,
-				members
-			} : collection),
-			id
-		};
+function queueAddMany(ids) {
+	let full = [];
+	const queue = updateQueue((current) => {
+		const fresh = ids.filter((id, at) => !current.includes(id) && ids.indexOf(id) === at);
+		const room = Math.max(0, 50 - current.length);
+		full = fresh.slice(room);
+		return fresh.length <= full.length ? null : [...current, ...fresh.slice(0, room)];
 	});
+	return queue === null ? null : {
+		queue,
+		full
+	};
+}
+function queueRemove(id) {
+	return updateQueue((current) => current.includes(id) ? current.filter((queued) => queued !== id) : null);
 }
 /**
-* Take lineages out of every collection, because their reviews are gone. Stores nothing when none
-* of them was a member, so a deletion of an uncollected review never writes this file.
+* A token for the index's revision, equality only.
+*
+* The queue changes only when a person deliberately changes it, so unlike a running job's progress
+* this cannot make the page reload itself in a loop. Absent reads as a stable empty string rather
+* than as a change, for the reason `refreshAction` gives: a missing field that reads as "different"
+* is a reload that asks again and reloads again.
 */
-function dropMembers(keys) {
-	const gone = new Set(keys);
-	return updateCollections((current) => current.some((collection) => collection.members.some((key) => gone.has(key))) ? current.map((collection) => ({
-		...collection,
-		members: collection.members.filter((key) => !gone.has(key))
-	})) : null);
-}
-/** Every lineage in at least one collection. What retention asks: collected is kept. */
-function collectedKeys(collections = readCollections()) {
-	return new Set(collections.flatMap((collection) => collection.members));
-}
-/** A token for the index's revision, as `queueStamp` is: it changes only when a person changes it. */
-function collectionsStamp() {
+function queueStamp() {
 	try {
-		return String(statSync(COLLECTIONS_PATH).mtimeMs);
+		return String(statSync(QUEUE_PATH).mtimeMs);
 	} catch {
 		return "";
 	}
 }
+/** Strings only, first position wins, and never more than the cap. */
+function normalise(ids) {
+	const seen = [];
+	for (const id of ids) {
+		if (typeof id !== "string" || id === "" || seen.includes(id)) continue;
+		seen.push(id);
+		if (seen.length === 50) break;
+	}
+	return seen;
+}
 //#endregion
 //#region ../../packages/review-harness/src/workspace/lifecycle.ts
 /**
@@ -6458,7 +6466,7 @@ function lifecycleAction(lifecycle) {
 	return LIFECYCLES.find((entry) => entry.id === lifecycle).action;
 }
 /** A lifecycle's name, which is what its pill says on the card and on the review page. */
-function lifecycleName(lifecycle) {
+function lifecycleName$1(lifecycle) {
 	return LIFECYCLES.find((entry) => entry.id === (lifecycle?.state ?? "active")).name;
 }
 /**
@@ -6475,7 +6483,7 @@ function lifecyclePillAction(lifecycle) {
 /** The pill's accessible name: the state it shows, then what pressing it does. */
 function lifecyclePillLabel(lifecycle) {
 	const action = lifecyclePillAction(lifecycle);
-	return `${lifecycleName(lifecycle)}. ${action === "menu" ? "Choose what happens next" : lifecycleAction(action)}`;
+	return `${lifecycleName$1(lifecycle)}. ${action === "menu" ? "Choose what happens next" : lifecycleAction(action)}`;
 }
 var ACTIVITY_LABELS = {
 	created: "Created",
@@ -7741,9 +7749,34 @@ var UPDATE_ORDER = [
 	"context",
 	"analysing"
 ];
+/**
+* The same phases, as a Re-check of the pull request discussion runs them. Nothing is fetched, so
+* there is no `preparing` step to show, and the checkout is of the commit the review read.
+*/
+var RECHECK_PHASES = {
+	...UPDATE_PHASES,
+	conversation: {
+		doing: "Fetching the PR discussion",
+		done: "Fetched the PR discussion"
+	},
+	context: {
+		doing: "Preparing the reviewed code",
+		done: "Prepared the reviewed code"
+	},
+	analysing: {
+		doing: "Reassessing issues and questions",
+		done: "Reassessed issues and questions"
+	}
+};
+var RECHECK_ORDER = [
+	"conversation",
+	"context",
+	"analysing"
+];
 /** The names this job's phases go by. */
 function phasesFor(job) {
-	return purposeOf(job) === "update" ? UPDATE_PHASES : PHASES;
+	if (purposeOf(job) !== "update") return PHASES;
+	return job.scope === "conversation" ? RECHECK_PHASES : UPDATE_PHASES;
 }
 /**
 * Whether a phase is part of *this* review, rather than part of the pipeline in general.
@@ -7783,7 +7816,7 @@ function progressSteps(job) {
 	const failedAt = job.phase === "failed" ? job.failure?.phase : void 0;
 	const update = purposeOf(job) === "update";
 	const names = phasesFor(job);
-	const order = (update ? UPDATE_ORDER : WORK_PHASES).filter((phase) => appliesTo(job, phase));
+	const order = (update ? job.scope === "conversation" ? RECHECK_ORDER : UPDATE_ORDER : WORK_PHASES).filter((phase) => appliesTo(job, phase));
 	return (update && job.phase === "done" ? order.filter((phase) => job.completed.includes(phase)) : order).map((phase) => {
 		const complete = job.completed.includes(phase) || !update && job.phase === "done";
 		const failed = failedAt === phase;
@@ -7876,6 +7909,7 @@ function strippedForDeletedReview(job) {
 		},
 		...job.purpose ? { purpose: job.purpose } : {},
 		...job.reanalysis ? { reanalysis: true } : {},
+		...job.scope ? { scope: job.scope } : {},
 		...job.reviewType ? { reviewType: job.reviewType } : {},
 		phase: job.phase,
 		startedAt: job.startedAt,
@@ -17050,7 +17084,7 @@ function send(record) {
 * a yes it can trust, which is a 2xx and nothing else. Asks the same question `send` does before
 * anything goes over the wire.
 */
-async function deliver(record) {
+async function deliver$1(record) {
 	try {
 		if (!telemetryUploadEnabled()) return false;
 		const payload = project(record);
@@ -18774,6 +18808,13 @@ function countUpdateChanges(previous, result) {
 		...reopened ? { reopened } : {}
 	};
 }
+/**
+* Whether a reconciliation moved any finding or put anything to the reviewer. Still-open findings
+* are the ones it left alone, so they are the one count that is not a change.
+*/
+function findingsChanged(counts) {
+	return counts.resolved + counts.affected + counts.newIssues + counts.questionsAnswered + (counts.reopened ?? 0) + (counts.gradeChanges ?? 0) + (counts.decisionsChallenged ?? 0) > 0;
+}
 //#endregion
 //#region ../../packages/review-harness/src/domain/ai_review/update_reconciliation.ts
 function reconciledAgainstOf(basis) {
@@ -19099,8 +19140,93 @@ async function updateReview(workspace, runners = {}) {
 	if (workspace.changeSet.targetType === "commit") return refuse(reviewedSha, false, COMMIT_REVIEW_CANNOT_UPDATE);
 	const parked = parkedUpdateRefusal(workspace);
 	if (parked) return refuse(reviewedSha, false, parked);
+	let fetchStartedAt = 0;
+	return driveUpdateJob(workspace, runners, reviewedSha, {
+		startedAt,
+		now
+	}, void 0, async (held, step, signal, clock) => {
+		fetchStartedAt = Date.now();
+		const outcome = await bringForward(workspace, runners, reviewedSha, held, step, signal, clock);
+		if (!signal.aborted && outcome.ok && !outcome.fetchFailed && outcome.toSha) workspace.headSeenAt = fetchStartedAt;
+		return outcome;
+	});
+}
+/**
+* Reconcile the review's findings with its pull request discussion as it is now, at the commit the
+* review read: the Re-check button.
+*
+* The discussion half of an update and nothing else. The conversation is re-read exactly as an
+* update re-reads it, so every "already raised" line is corrected first; then, when something in it
+* is new to the analysis, the same reconciliation an update runs is asked of the same agent with no
+* code delta. It may answer a question, resolve or reopen an issue on the evidence the discussion
+* rules allow, suggest a grade, or raise a concern as a new issue once it has confirmed it in the
+* reviewed code. It never fetches and never moves the review to a newer commit: that is an update's,
+* and the review's commit stays where it was so the next update still sees those commits as new.
+*
+* Computes and mutates in memory, like `updateReview`; the route saves.
+*/
+async function recheckConversation(workspace, runners = {}) {
+	const now = runners.now ?? Date.now;
+	const startedAt = now();
+	const reviewedSha = workspace.session.metadata?.commitSha || null;
+	const recheck = (outcome) => ({
+		...outcome,
+		scope: "conversation"
+	});
+	if (!workspace.prContext) return recheck(refuse(reviewedSha, false, "This review has no pull request conversation attached, so there is nothing to re-read."));
+	const cannotReassess = parkedUpdateRefusal(workspace) ?? (!workspace.session.result || !reviewedSha ? "This review has no analysis to reassess." : null);
+	if (cannotReassess) {
+		adoptLegacyBaseline(workspace);
+		const conversationOk = await reReadConversation(workspace, runners.runRefresh);
+		return recheck(settled(reviewedSha, reviewedSha, false, conversationOk, "refused", conversationOk ? cannotReassess : rereadFailureOf(workspace)));
+	}
+	return driveUpdateJob(workspace, runners, reviewedSha, {
+		startedAt,
+		now
+	}, "conversation", async (held, step, signal, clock) => recheck(await reconcileConversation(workspace, runners, reviewedSha, held, step, signal, clock)));
+}
+/** What a failed re-read said, for an outcome that reports it. */
+function rereadFailureOf(workspace) {
+	return workspace.lastPrRefresh && !workspace.lastPrRefresh.ok ? workspace.lastPrRefresh.message : "The pull request conversation could not be re-read. Nothing here has changed.";
+}
+/** Said when the conversation holds nothing the findings have not already been weighed against. */
+var NOTHING_NEW_IN_DISCUSSION = "Nothing in the PR discussion is new since the findings were last assessed, so no findings changed.";
+async function reconcileConversation(workspace, runners, reviewedSha, held, step, signal, clock) {
+	adoptLegacyBaseline(workspace);
+	step("conversation");
+	const conversationOk = await reReadConversation(workspace, runners.runRefresh);
+	signal.throwIfAborted();
+	if (!conversationOk) return settled(reviewedSha, reviewedSha, false, false, "refused", rereadFailureOf(workspace));
+	const { prepared } = await prepareConversation(workspace, {
+		reread: false,
+		...workspace.lastPrRefresh ? { rereadOutcome: workspace.lastPrRefresh } : {}
+	});
+	if (!conversationMoved(prepared)) return settled(reviewedSha, reviewedSha, false, true, "already-current", NOTHING_NEW_IN_DISCUSSION);
+	if (!await commitPresent(workspace.repoPath, reviewedSha)) return settled(reviewedSha, reviewedSha, false, true, "baseline-gone", BASELINE_GONE_MESSAGE);
+	step("context");
+	let worktreePath;
+	try {
+		({path: worktreePath} = await pinCheckout(workspace, reviewedSha, held));
+	} catch (error) {
+		if (error instanceof ReviewBeingDeletedError) throw error;
+		return settled(reviewedSha, reviewedSha, false, true, "analysis-failed", "A checkout of the reviewed commit could not be prepared, so the findings were not reassessed.");
+	}
+	signal.throwIfAborted();
+	return reconcile(workspace, runners, reviewedSha, {
+		sha: reviewedSha,
+		fetchFailed: false
+	}, true, worktreePath, step, held.job, signal, clock, prepared, true, "conversation");
+}
+/**
+* The life of an update's job, whatever the update does inside it: the claim, the cancel, the steps,
+* how it ends and what it announces. Shared by Update and Re-check so the two cannot disagree about
+* how a run is watched, cancelled or reported.
+*/
+async function driveUpdateJob(workspace, runners, reviewedSha, clock, scope, work) {
+	const { startedAt, now } = clock;
 	const held = await claimCheckoutJob(workspace, reviewedSha ?? "", {
 		purpose: "update",
+		...scope ? { scope } : {},
 		...runners.source ? { source: runners.source } : {},
 		...workspace.prContext ? { conversation: {
 			kind: "attached",
@@ -19114,16 +19240,11 @@ async function updateReview(workspace, runners = {}) {
 	const current = () => loadJob(held.job.id) ?? held.job;
 	const step = (phase) => saveJob(advance(current(), phase));
 	try {
-		const fetchStartedAt = Date.now();
-		const outcome = await bringForward(workspace, runners, reviewedSha, held, step, signal, {
-			startedAt,
-			now
-		});
-		if (signal.aborted) return cancelled(held, reviewedSha);
-		if (outcome.ok && !outcome.fetchFailed && outcome.toSha) workspace.headSeenAt = fetchStartedAt;
-		const ended = outcome.stop === "analysis-failed" ? fail(current(), outcome.message) : advance(current(), "done", outcome.message);
+		const outcome = await work(held, step, signal, clock);
+		if (signal.aborted) return scoped(cancelled(held, reviewedSha), scope);
+		const ended = outcome.stop === "analysis-failed" || scope && outcome.conversationOk === false ? fail(current(), outcome.message) : advance(current(), "done", outcome.message);
 		saveJob(ended);
-		if (outcome.ok && outcome.stop === null) {
+		if (!scope && outcome.ok && outcome.stop === null) {
 			const completedAt = now();
 			recordRuntimeBestEffort({
 				operation: "update",
@@ -19139,7 +19260,7 @@ async function updateReview(workspace, runners = {}) {
 		announceJob(ended, updateFacts(outcome, workspace));
 		return outcome;
 	} catch (error) {
-		if (signal.aborted) return cancelled(held, reviewedSha);
+		if (signal.aborted) return scoped(cancelled(held, reviewedSha), scope);
 		const failed = fail(current(), error instanceof Error ? error.message : String(error));
 		saveJob(failed);
 		announceJob(failed);
@@ -19149,6 +19270,12 @@ async function updateReview(workspace, runners = {}) {
 		held.claim.release();
 	}
 }
+function scoped(outcome, scope) {
+	return scope ? {
+		...outcome,
+		scope
+	} : outcome;
+}
 /**
 * The reviewer cancelled. Recorded as a stop, not a failure, so nothing announces it or offers a
 * retry, and answered as an outcome the page reports on the review it left untouched.
@@ -19192,7 +19319,7 @@ async function bringForward(workspace, runners, reviewedSha, held, step, signal,
 	signal.throwIfAborted();
 	return reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, held.job, signal, clock, prepared, discussionMoved);
 }
-async function reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, job, signal, clock, prepared, discussionMoved) {
+async function reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, job, signal, clock, prepared, discussionMoved, scope) {
 	const { id: jobId, env } = job;
 	const newHead = remote.sha;
 	let delta = null;
@@ -19227,7 +19354,7 @@ async function reconcile(workspace, runners, reviewedSha, remote, conversationOk
 	const requestedModel = resolveModel({ review: { session: workspace.session } }) ?? void 0;
 	let raw;
 	try {
-		const prompt = buildUpdatePrompt(workspace, delta, prepared, reviewedSha, newHead, worktreePath);
+		const prompt = buildUpdatePrompt(workspace, delta, prepared, reviewedSha, newHead, worktreePath, scope);
 		raw = runners.run ? await runners.run(prompt, worktreePath, env, onProgress, onObservedModel, signal) : await runUpdate(workspace.id, prompt, worktreePath, workspace.repoPath, env, onProgress, requestedModel, onObservedModel, signal);
 	} catch (error) {
 		return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "analysis-failed", explainUpdateFailure(error, env, requestedModel));
@@ -19444,11 +19571,36 @@ function mergeUpdateInto(fresh, updated) {
 	for (const field of UPDATE_OWNED_FIELDS) if (field in updated) target[field] = source[field];
 	else delete target[field];
 	merged.session = keepReviewerFields(fresh, updated.session);
+	keepNewerConversation(merged, fresh, updated);
 	carryUpdateSuggestions(merged, updated);
 	dropStaleChangeMap(merged);
 	return merged;
 }
 /**
+* A conversation re-read that landed on disk while this ran, kept rather than put back.
+*
+* An Ask turn re-reads the conversation and saves it, and an update holds its copy for minutes. Laid
+* over whole, the update's older copy replaced the newer one and the "already raised" lines went
+* back with it. The newer copy stays, and the attributions are derived again from it: arithmetic,
+* the same pass the re-read itself runs. `analysedConversation` is untouched either way: it is the
+* snapshot this run actually reconciled against, so whatever arrived since is still new to the next.
+*/
+function keepNewerConversation(merged, fresh, updated) {
+	const theirs = fresh.prContext ? orderOf(fresh.prContext.discussion) : void 0;
+	const ours = updated.prContext ? orderOf(updated.prContext.discussion) : void 0;
+	if (theirs === void 0 || ours === void 0 || theirs <= ours || !fresh.prContext) return;
+	merged.prContext = fresh.prContext;
+	if (fresh.lastPrRefresh) merged.lastPrRefresh = fresh.lastPrRefresh;
+	const result = merged.session.result;
+	if (result) {
+		const { result: attributed } = attributeIssuesToDiscussion(result, processDiscussion(fresh.prContext.discussion));
+		merged.session = {
+			...merged.session,
+			result: attributed
+		};
+	}
+}
+/**
 * The grade changes this update suggested, onto the review as it is on disk.
 *
 * The ledger is the reviewer's and comes from the fresh read, so the update's proposals, written on
@@ -19725,20 +19877,20 @@ function stillPresent(counts) {
 * Everything after it is the shared builder, so the two clients cannot drift into asking for
 * different shapes.
 */
-function buildUpdatePrompt(workspace, delta, conversation, reviewedSha, newHead, worktreePath) {
+function buildUpdatePrompt(workspace, delta, conversation, reviewedSha, newHead, worktreePath, scope) {
 	const previous = workspace.session.result;
 	const discussionChanged = conversationMoved(conversation);
 	const conversationBlock = updateConversationBlock(conversation);
-	const opening = delta ? `An earlier review of this branch is being brought up to date with the commits pushed since it was written${discussionChanged ? ", and with what has changed in its pull request conversation since" : ""}.` : "An earlier review of this branch is being brought up to date with what has changed in its pull request conversation since it was written. No commits have been pushed since.";
+	const opening = delta ? `An earlier review of this branch is being brought up to date with the commits pushed since it was written${discussionChanged ? ", and with what has changed in its pull request conversation since" : ""}.` : scope === "conversation" ? "An earlier review of this branch is being reconciled with what has changed in its pull request conversation since it was written. Only the conversation is reassessed in this pass, against the commit the review read. Newer commits on the branch, if any, are not part of it: a comment saying a fix landed in one cannot be confirmed from this checkout, so that finding stays open for a later update to check against the code." : "An earlier review of this branch is being brought up to date with what has changed in its pull request conversation since it was written. No commits have been pushed since.";
 	const code = delta ? `The change below is what happened between ${reviewedSha} and ${newHead}. It is not the whole branch: the earlier review already covered everything up to ${reviewedSha}.
 
 ${renderChangeInventory(delta.changeSet.data.files, inlinePathsOf(delta))}
 
-${delta.diff}` : `The code is unchanged since the earlier review: ${newHead} is the commit it read.`;
+${delta.diff}` : scope === "conversation" ? `There is no code delta in this pass: ${newHead} is the commit the earlier review read.` : `The code is unchanged since the earlier review: ${newHead} is the commit it read.`;
 	const commits = delta ? (delta.changeSet.authors ?? []).reduce((total, author) => total + author.commits, 0) : 0;
 	return `${opening}
 
-The working tree at ${worktreePath} is checked out at ${newHead}, which is the code as it now stands. You may read any file in it, and you should: the point of doing this here rather than from a diff alone is that you can open the code and see whether a fix actually holds. Read only. Change nothing, commit nothing, and run no command that writes.
+The working tree at ${worktreePath} is checked out at ${newHead}, which is ${scope === "conversation" ? "the code the review read" : "the code as it now stands"}. You may read any file in it, and you should: the point of doing this here rather than from a diff alone is that you can open the code and see whether a fix actually holds. Read only. Change nothing, commit nothing, and run no command that writes.
 
 ${code}
 
@@ -20865,6 +21017,557 @@ function livePart(queue) {
 	return live.length === queue.length ? null : live;
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/collections_live.ts
+/**
+* Collections as they relate to reviews that actually exist.
+*
+* `collections.ts` stores lineage keys and must not learn to read the review store, for the cycle
+* `queue_live.ts` describes: the prune in `store.ts` imports it. Anything that asks both questions
+* lives here, which imports both and is imported by neither.
+*/
+/**
+* Drop members whose lineage has no review any more, deleted elsewhere or pruned by age, and store
+* the result if that changed anything. Read against every group, not the windowed list, so a branch
+* the recency window happens to hide keeps its place.
+*
+* Compacted again under the lock rather than written from what was read, so a member somebody added
+* since is kept. On a failed write the compacted copy still stands in, so the page draws what exists.
+*/
+function settleCollections(groups) {
+	const live = new Set(groups.map((group) => group.key));
+	const compact = (collections) => collections.some((collection) => collection.members.some((key) => !live.has(key))) ? collections.map((collection) => ({
+		...collection,
+		members: collection.members.filter((key) => live.has(key))
+	})) : null;
+	const read = readCollections();
+	const compacted = compact(read);
+	if (compacted === null) return read;
+	return updateCollections((current) => compact(current)) ?? compacted;
+}
+/**
+* The lineage each review id belongs to, for the routes: the page sends the ids on its cards, and
+* the lineage is the server's to derive. An id with no review, or one that cannot be summarised, is
+* left out, and the caller says so.
+*/
+function lineageKeysFor(ids) {
+	const keys = /* @__PURE__ */ new Map();
+	for (const id of new Set(ids)) {
+		const workspace = loadWorkspace(id);
+		if (!workspace) continue;
+		try {
+			keys.set(id, lineageKey(summarise(workspace)));
+		} catch {}
+	}
+	return keys;
+}
+/**
+* Add one review's lineage to one collection, and say how that went. The membership check and the
+* add are one transaction, so `already` and `added` are told apart under the lock rather than
+* guessed from a read made before it. Touches no other collection and no review's lifecycle.
+*/
+function collectForReview(reviewId, collectionId) {
+	const key = lineageKeysFor([reviewId]).get(reviewId);
+	if (key === void 0) return "gone";
+	let result = "added";
+	if (updateCollections((current) => {
+		const target = current.find((collection) => collection.id === collectionId);
+		if (!target) {
+			result = "missing";
+			return null;
+		}
+		if (target.members.includes(key)) {
+			result = "already";
+			return null;
+		}
+		if (target.members.length >= 500) {
+			result = "full";
+			return null;
+		}
+		return current.map((collection) => collection.id === collectionId ? {
+			...collection,
+			members: [...collection.members, key]
+		} : collection);
+	}) === null) return "unsaved";
+	return result;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/batch_destination.ts
+/**
+* Settle where the batch goes, before any review is started. An existing collection is found, and a
+* new one is made now, empty, through `createCollection` and so through the one name rule. Made up
+* front so a bad or taken name stops the batch before anything has been reviewed, and so a batch
+* that then partly fails has a collection to point its retry at.
+*/
+function openDestination(request) {
+	const queue = request.queue;
+	if ("collectionId" in request) {
+		const collections = readCollections();
+		const found = collections.find((collection) => collection.id === request.collectionId);
+		if (!found) return {
+			ok: false,
+			reason: "missing",
+			requested: request.collectionId,
+			by: "id",
+			candidates: collections.map((one) => one.name)
+		};
+		return {
+			ok: true,
+			destination: {
+				queue,
+				collection: {
+					id: found.id,
+					name: found.name,
+					created: false
+				}
+			}
+		};
+	}
+	if ("collectionName" in request) {
+		const collections = readCollections();
+		const found = collectionNamed(request.collectionName, collections);
+		if (!found) return {
+			ok: false,
+			reason: "missing",
+			requested: request.collectionName,
+			by: "name",
+			candidates: collections.map((one) => one.name)
+		};
+		return {
+			ok: true,
+			destination: {
+				queue,
+				collection: {
+					id: found.id,
+					name: found.name,
+					created: false
+				}
+			}
+		};
+	}
+	if ("newCollection" in request) {
+		const made = createCollection(request.newCollection);
+		if (!made.ok) return {
+			ok: false,
+			reason: made.reason === "missing" ? "unsaved" : made.reason,
+			requested: request.newCollection
+		};
+		const created = made.collections.find((collection) => collection.id === made.id);
+		if (!created) return {
+			ok: false,
+			reason: "unsaved",
+			requested: request.newCollection
+		};
+		return {
+			ok: true,
+			destination: {
+				queue,
+				collection: {
+					id: created.id,
+					name: created.name,
+					created: true
+				}
+			}
+		};
+	}
+	return {
+		ok: true,
+		destination: { queue }
+	};
+}
+/**
+* Put one review where the batch goes, as soon as it exists. Idempotent: a membership or a queue
+* entry already there is `already`, which counts as delivered, and anything missing is added, so a
+* retry of a partly delivered batch fills in exactly what is missing. Synchronous, like
+* `queueForReview`, so two lanes of one batch cannot interleave a read and a write.
+*/
+function deliver(reviewId, destination) {
+	return {
+		...destination.collection ? { collection: collectForReview(reviewId, destination.collection.id) } : {},
+		...destination.queue ? { queue: queueForReview(reviewId) } : {}
+	};
+}
+/** Whether a destination has the review: it went in now, or it was there already. */
+function isDelivered(result) {
+	return result === "added" || result === "already";
+}
+/**
+* A miss that trying again could fix: the destination is still there, and it was full or its write
+* failed. A deleted collection (`missing`) or a deleted review (`gone`) fails the same way every time.
+*/
+function canTryAgain(result) {
+	return result === "full" || result === "unsaved";
+}
+/**
+* The part of a destination that is worth trying again for one review, or null when none is. Only
+* what missed, and only what can still succeed: a retry never re-adds what is already there, and
+* never asks a deleted collection again.
+*/
+function retryableMiss(delivered, destination) {
+	const collection = destination.collection && canTryAgain(delivered?.collection) ? destination.collection : void 0;
+	const queue = destination.queue && canTryAgain(delivered?.queue);
+	if (!collection && !queue) return null;
+	return {
+		queue,
+		...collection ? { collection } : {}
+	};
+}
+/** Whether a destination that was asked for does not have the review. */
+function missedDelivery(delivered, destination) {
+	if (destination.collection && !isDelivered(delivered?.collection)) return true;
+	return destination.queue && !isDelivered(delivered?.queue);
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/reviews_index.ts
+/**
+* The sections of the list, top to bottom.
+*
+* Pinned is not a lifecycle state. It is where a card is drawn, on top of a lifecycle it keeps: a
+* pinned review can be Active, Waiting or Done, and unpinning it puts it back in the section that
+* says. That is why it lives here, beside the other placement rules, and not in `LIFECYCLES`.
+*/
+var INDEX_SECTIONS = [
+	"pinned",
+	"active",
+	"waiting",
+	"done"
+];
+/**
+* Every section the list draws, top to bottom: In progress, then the card sections.
+*
+* In progress is not in `INDEX_SECTIONS` because no card is ever placed there. It lists work, one
+* entry per running job or waiting row (`deriveOperations`), and a review being updated stays a
+* card in its own section while its update is listed here. Windows, Load more, the selection and
+* the counts are all about cards, so they keep reading `INDEX_SECTIONS`; folding, its memory and its
+* keyboard commands are about headings, so they read this.
+*/
+var LIST_SECTIONS = ["in-progress", ...INDEX_SECTIONS];
+/**
+* Each section's name, as its heading says it, and the key that folds it from the keyboard
+* (⌘K L and this key). The commands are made from this table, so a section added here is a section
+* the keyboard can fold, with no second list to remember.
+*/
+var lifecycleName = (id) => LIFECYCLES.find((lifecycle) => lifecycle.id === id).name;
+var INDEX_SECTION_NAMES = {
+	"in-progress": {
+		title: "In progress",
+		key: "i"
+	},
+	pinned: {
+		title: "Pinned",
+		key: "p"
+	},
+	active: {
+		title: lifecycleName("active"),
+		key: "a"
+	},
+	waiting: {
+		title: lifecycleName("waiting"),
+		key: "w"
+	},
+	done: {
+		title: lifecycleName("done"),
+		key: "d"
+	}
+};
+/**
+* Whether a section starts open. The reviewer's choice wins, and otherwise everything is open but
+* the archives: Done, and each collection's completed reviews. A new collection starts open. The
+* one place that default is written.
+*/
+function sectionOpen(section, collapsed) {
+	return !(collapsed?.[section] ?? (section === "done" || section.startsWith("collection-done:")));
+}
+/** A section the list draws a heading for, and so one whose fold can be stored. */
+function isListSection(value) {
+	return typeof value === "string" && LIST_SECTIONS.includes(value);
+}
+/** A fold the store accepts: a list section, or a collection's, by an id shaped like one. */
+function isFoldKey(value) {
+	if (isListSection(value)) return true;
+	if (typeof value !== "string") return false;
+	const match = /^collection(?:-done)?:(.*)$/.exec(value);
+	return match !== null && isCollectionId(match[1]);
+}
+function collectionFold(id) {
+	return `collection:${id}`;
+}
+function completedFold(id) {
+	return `collection-done:${id}`;
+}
+var COLLECTION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+/**
+* Whether a value is shaped like a collection's id. Here, in the module both halves share, because
+* the hash and the fold store check it in the browser and on the server alike.
+*/
+function isCollectionId(value) {
+	return typeof value === "string" && COLLECTION_ID.test(value);
+}
+/**
+* Which section a card is drawn in: Pinned when pinned, and otherwise where its lifecycle says.
+*
+* Pinning controls prominence in the general list and never overrides an ordering the reviewer
+* asked for. Under such a filter a pinned card stays in its lifecycle section, in the order the
+* filter gives, and only its star says it is pinned.
+*/
+function indexSectionOf(pinned, lifecycle, activity, filter) {
+	return pinned && !ordersExplicitly(filter) ? "pinned" : sectionOf(lifecycle, activity);
+}
+/**
+* Where a review's own card is drawn, or absent when it is drawn only inside its collections.
+*
+* Pinned first and exclusive, as it always was: a pinned review is drawn in Pinned and nowhere else,
+* collected or not, and unpinning it puts it back where the rest of these rules say. A review in a
+* collection is drawn there instead of in Active, Waiting or Done, so those three list what nobody
+* has grouped. Under the Queue filter neither applies: the list is the queue in its order, each card
+* in its lifecycle section, the same reason `indexSectionOf` gives for Pinned.
+*/
+function homeSection(pinned, lifecycle, activity, collected, filter) {
+	if (collected && !pinned && !ordersExplicitly(filter)) return void 0;
+	return indexSectionOf(pinned, lifecycle, activity, filter);
+}
+/**
+* Where a review is drawn inside each collection it belongs to: with the collection's reviews still
+* needing attention, under its completed reviews, or not at all.
+*
+* Completed means Done, by the same derivation that places the card everywhere else, so Waiting is
+* still in play and the Reviewed mark has nothing to do with it. One state for every collection the
+* review is in: marking it Done moves it in all of them at once. Not drawn while pinned (Pinned is
+* exclusive) or under the Queue filter (see `homeSection`).
+*/
+function collectionPlacement(pinned, lifecycle, activity, filter) {
+	if (pinned || ordersExplicitly(filter)) return void 0;
+	return sectionOf(lifecycle, activity) === "done" ? "completed" : "active";
+}
+/** A collection heading's count: what still needs attention, and the members drawn in Pinned. */
+function collectionCountLabel(active, pinned) {
+	const label = `${active} active`;
+	return pinned === 0 ? label : `${label} · ${pinned} pinned`;
+}
+/**
+* The quiet line on a card naming its collections, or absent when it would say nothing new.
+*
+* Inside a collection the heading already names that one, so the line says only where else the
+* review is ("Also in Release 0.82"), and nothing for a review in one collection. Outside every
+* collection heading, which is Pinned and the Queue filter, it names them all.
+*/
+function collectionsLine(memberOf, collections, current) {
+	const names = collections.filter((collection) => collection.id !== current && memberOf.includes(collection.id)).map((collection) => collection.name);
+	if (names.length === 0) return void 0;
+	return `${current === void 0 ? "In" : "Also in"} ${names.join(", ")}`;
+}
+/**
+* What a collection says when its main list is empty, or absent when it is not. A collection is
+* never hidden for having nothing active: it is still somewhere its finished reviews live, and
+* somewhere to put the next one.
+*/
+function collectionEmptyText(counts, filtered) {
+	if (counts.active > 0) return void 0;
+	if (filtered) return "Nothing in this collection matches the filters.";
+	if (counts.members === 0) return "Nothing here yet. Add reviews from a card’s menu, or select several and choose Manage collections.";
+	if (counts.pinned > 0 && counts.completed === 0) return "Its reviews are pinned, so they are listed under Pinned.";
+	return "No active reviews";
+}
+/** Said under a collection whose oldest members are not drawn, so it never looks smaller than it is. */
+function omittedText(omitted) {
+	return omitted === 1 ? "1 older review in this collection is not listed." : `${omitted} older reviews in this collection are not listed.`;
+}
+/** The disclosure holding a collection's Done reviews. */
+function completedLabel(completed) {
+	return `Show completed (${completed})`;
+}
+/**
+* Whether a filter replaces the activity order with one the reviewer set. Queue is the only one:
+* the list is the queue, in its order.
+* `orderIndex` and `indexSectionOf` both ask this, so the ordering and the placement cannot disagree.
+*/
+function ordersExplicitly(filter) {
+	return filter === "queue";
+}
+/** Keys this page reads, and `page`, which it once wrote and now deliberately forgets. */
+var KNOWN_KEYS = [
+	"q",
+	"f",
+	"by",
+	"pr",
+	"col",
+	"page"
+];
+/**
+* "45 reviews · 13 branches", and "13 reviews" when those are the same thirteen things.
+*
+* The two numbers are different questions and only both worth asking once they differ. A page of
+* thirteen branches reviewed once each would read "13 reviews · 13 branches", which invites the
+* reader to work out what the distinction is on the one page where there isn't one.
+*
+* `of` is every review on the page, given while the search or a filter is narrowing the list:
+* "12 of 71 reviews" says the list is filtered and by how much, where "12 reviews" reads as all
+* there are.
+*/
+function countLabel(reviews, branches, of) {
+	const label = of === void 0 ? `${reviews} review${reviews === 1 ? "" : "s"}` : `${reviews} of ${of} review${of === 1 ? "" : "s"}`;
+	if (reviews === branches) return label;
+	return `${label} · ${branches} branch${branches === 1 ? "" : "es"}`;
+}
+/**
+* The URL for a state, and nothing at all for the state a visitor arrives in.
+*
+* An empty hash for the defaults keeps `http://localhost:7726/` the address of the index rather
+* than of one particular way of looking at it, and keeps a link somebody copies as short as what
+* they actually did.
+*/
+function formatIndexHash(state) {
+	const params = new URLSearchParams();
+	if (state.query !== "") params.set("q", state.query);
+	if (state.filter !== "all") params.set("f", state.filter);
+	if (state.author !== "") params.set("by", state.author);
+	if (state.pr !== "any") params.set("pr", state.pr);
+	if (state.collections.length > 0) params.set("col", state.collections.join(","));
+	for (const [key, value] of new URLSearchParams(state.extra ?? "")) if (!KNOWN_KEYS.includes(key)) params.append(key, value);
+	const encoded = params.toString();
+	return encoded === "" ? "" : `#${encoded}`;
+}
+/**
+* The Reviews page showing one collection: what a batch's Open collection link opens, from the
+* workspace and from the CLI's summary alike.
+*/
+function collectionHash(id) {
+	return formatIndexHash({
+		query: "",
+		filter: "all",
+		author: "",
+		pr: "any",
+		collections: [id]
+	});
+}
+/**
+* Every login the author dropdown offers, once each, in alphabetical order of what the reader sees:
+* the name where there is one, the login otherwise, regardless of case. Read from the cards the page
+* is showing, so it never lists somebody with nothing to show.
+*
+* A login's name is the one on its newest review that has a name, chosen here by `createdAt` rather
+* than by the order the caller happens to pass, so an account renamed upstream reads as it does now.
+*/
+function authorOptions(cards) {
+	const newest = /* @__PURE__ */ new Map();
+	for (const card of cards) {
+		if (!card.handle) continue;
+		const seen = newest.get(card.handle);
+		if (!seen) newest.set(card.handle, {
+			name: card.name || void 0,
+			createdAt: card.createdAt
+		});
+		else if (card.name && (!seen.name || card.createdAt > seen.createdAt)) newest.set(card.handle, {
+			name: card.name,
+			createdAt: card.createdAt
+		});
+	}
+	return [...newest].map(([handle, { name }]) => name && name !== handle ? {
+		handle,
+		name
+	} : { handle }).sort((a, b) => (a.name ?? a.handle).localeCompare(b.name ?? b.handle, void 0, { sensitivity: "base" }));
+}
+/** An author option as the dropdown spells it: the name and the login, or the login alone. */
+function authorOptionLabel(option) {
+	return option.name ? `${option.name} · @${option.handle}` : `@${option.handle}`;
+}
+/**
+* A card menu's status item, which sets the state it names. The bulk bar's words for the same two
+* actions, so a card and a selection never disagree. Here rather than in the page renderer because
+* the browser relabels the item after a change, and that renderer reaches the store.
+*/
+function markItemLabel(mark) {
+	return mark === "complete" ? "Mark reviewed" : "Mark not reviewed";
+}
+/**
+* The review page's Pin item, which says what pressing it will do. The words of the index's star,
+* so pinning from either place reads as the same act. Here because the browser relabels the item
+* after the change, for the reason `markItemLabel` is here.
+*/
+function pinItemLabel(pinned) {
+	return pinned ? "Unpin review" : "Pin review";
+}
+/**
+* The queue item, on a card and on the review's own page. "review queue" rather than "queue",
+* because a menu is where somebody meets the idea for the first time. Here because the browser
+* relabels it after a change, on both pages.
+*/
+function queueItemLabel(queued) {
+	return queued ? "Remove from review queue" : "Add to review queue";
+}
+/**
+* The Queue pill, which carries a number only once there is one.
+*
+* "Queue 0" is a count of something that is not there, and reads as a fault. Bare "Queue" reads as
+* the place it is -- empty, and still the thing you would click to put something in it.
+*/
+function queueOptionLabel(queued) {
+	return queued === 0 ? "Queue" : `Queue (${queued})`;
+}
+/**
+* The words on the status chip.
+*
+* Here rather than in the renderer because the browser now writes this chip too: marking a
+* selection reviewed repaints it without asking the server for the page again, and two copies of
+* these three words is how a page ends up saying "Reviewed" in one place and "Complete" in the
+* other about the same review.
+*/
+function statusLabel(status) {
+	if (status === "complete") return "Reviewed";
+	return status === "in-progress" ? "Not reviewed" : "New";
+}
+/**
+* The status pill's accessible name: where the reviewer is, then what pressing it does. The visible
+* words are the state, so a screen reader hears both rather than only a state it cannot act on.
+*/
+function statusPillLabel(status) {
+	return `${statusLabel(status)}. Mark as ${status === "complete" ? "not reviewed" : "reviewed"}`;
+}
+/**
+* The bulk bar's way to tick everything the filters show, across pages.
+*
+* Counted ("Select all 7") only while the headline is not already saying "of 7", so the number is
+* on the bar once. With PR set to Merged this is how a reviewer clears the merged reviews in one go,
+* by way of the existing Mark reviewed.
+*/
+function selectAllLabel(inView, scopeShown = false) {
+	return inView === 0 || scopeShown ? "Select all" : `Select all ${inView}`;
+}
+/** The PR filter's options, in order, as the select shows them. */
+var PR_FILTER_OPTIONS = [
+	{
+		value: "any",
+		label: "Any"
+	},
+	{
+		value: "open",
+		label: "Open"
+	},
+	{
+		value: "merged",
+		label: "Merged"
+	},
+	{
+		value: "closed",
+		label: "Closed"
+	}
+];
+/**
+* Whether any of that is work still going on, which is what sets the polling cadence.
+*
+* Here rather than beside `analysisStates` because this module is the DOM-free, filesystem-free
+* arithmetic both halves of the index share, and the renderer needs this one answer without
+* needing an import that reads the jobs directory to get it.
+*
+* A stopped analysis is a state, not an activity. Counting it as live would leave the index asking
+* once a second about a review that finished failing an hour ago, for as long as the tab stayed
+* open.
+*/
+function anythingRunning(states, operations = []) {
+	if (operations.length > 0) return true;
+	for (const state of states.values()) if (state.phase !== "failed") return true;
+	return false;
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/relative_time.ts
 /**
 * Relative time, in the one wording this product uses.
@@ -21472,4 +22175,4 @@ var MCP_TOOL_NAMES = [
 	"ask_buddy"
 ];
 //#endregion
-export { readAskRequest as $, runnableAgents as $a, explanationOf as $i, authorPreview as $n, kissDecisionsOf as $r, recordRuntimeBestEffort as $t, settleQueue as A, TargetError as Aa, createWithMembers as Ai, moveIds as An, attemptIdOf as Ar, UpdateAlreadyRunningError as At, humanizeModelId as B, agentIdOf as Ba, queueStamp as Bi, existingPaths as Bn, phasesFor as Br, append as Bt, parsePullRequestLink as C, objectWithAnyOf as Ca, lifecyclePillAction as Ci, createPrState as Cn, followedBranch as Cr, RefreshUnavailableError as Ct, activateQueued as D, resolveTarget as Da, sectionOf as Di, markAllRead as Dn, fillFileUrlTemplate as Dr, parkedUpdateRefusal as Dt, relativeTime as E, kissOutcome as Ea, parseLifecycle as Ei, listNotifications as En, forgeResolver as Er, mergeUpdateInto as Et, spawnRunner as F, shorthandOf as Fa, setMembership as Fi, retireNotification as Fn, pruneJobResidue as Fr, prepareReview as Ft, reviewTag as G, STORE_ROOT as Ga, issuesOutstanding as Gi, storedConversation as Gn, isClaimed as Gr, recordTelemetryUploadConsent as Gt, findingRef as H, readAgentPreference as Ha, doneVerb as Hi, adoptLegacyBaseline as Hn, purposeOf as Hr, record as Ht, applyUpdate as I, git as Ia, updateCollections as Ii, toneOf as In, saveJob as Ir, settleReview as It, forgetAskRequest as J, agentFor as Ja, reviewerDispositions as Ji, isUnchanged as Jn, followedRefName as Jr, BUILD_VERSION as Jt, reviewTagsIn as K, AGENT_IDS as Ka, questionsOutstanding as Ki, unforeseenFailure as Kn, CLAIM_LEASE_MS as Kr, telemetryUploadConsent as Kt, modelProvenanceOf as L, refExists as La, queueAdd as Li, unreadAround as Ln, PHASES as Lr, reanalyseReview as Lt, RUNNER_MARKER as M, resolveBase as Ma, nameProblemText as Mi, readNotification as Mn, fail as Mr, runningJobs as Mt, cliEntry as N, AmbiguousRefError as Na, readCollections as Ni, readStateOf as Nn, isTerminal as Nr, failureOf as Nt, compactQueue as O, originRemote as Oa, collectionsStamp as Oi, markRead as On, RUN_RECORD_RETENTION_MS as Or, updateReview as Ot, runDetached as P, shortNameOf as Pa, renameCollection as Pi, removeNotification as Pn, loadJob as Pr, observeReview as Pt, markAskRunning as Q, parkedReason as Qa, explanationActionOf as Qi, UNESTABLISHED_MOTIVATION as Qn, kissDecisionRefusal as Qr, mapRuntimes as Qt, provenanceDetailLines as R, resolveAgent as Ra, queueAddMany as Ri, unreadCount as Rn, isLiveJob as Rr, runJob as Rt, extractPullRequestLinks as S, extractJsonText as Sa, lifecycleName as Si, createArchitectureNotification as Sn, checkReview as Sr, FETCH_TIMEOUT_MS as St, runBatch as T, WITHHELD_REASON as Ta, offersLifecycle as Ti, eventName as Tn, fetchHead as Tr, cancellableHere as Tt, findingRefs as U, writeAgentPreference as Ua, isIssueOutstanding as Ui, prepareConversationWithin as Un, clearClaim as Ur, stamp as Ut, findingAtRef as V, clearAgentPreference as Va, readQueue as Vi, ASK_REREAD_CEILING_MS as Vn, progressSteps as Vr, readEvents as Vt, refOf as W, CONFIG_PATH as Wa, isQuestionOutstanding as Wi, saveRefresh as Wn, driverGone as Wr, deliver as Wt, isRequestId as X, detectAgents as Xa, processDiscussion as Xi, EXPLAIN_SIMPLY_PROMPT as Xn, indexKeptIds as Xr, feedbackUrl as Xt, interruption as Y, agentIdentityOf as Ya, verdictClosure as Yi, agentEnvOf as Yn, groupByLineage as Yr, PACKAGE_NAME as Yt, isTerminalAsk as Z, isAgentId as Za, recommendationsOf as Zi, chatConversationSection as Zn, indexReviewGroups as Zr, waitingHistory as Zt, endRun as _, statusLookup as _a, activityAttributes as _i, writeJsonAtomically as _n, requestJobStop as _r, parseWorkspacePort as _t, lineageIds as a, assessmentLookup as aa, mutateWorkspace as ai, loadArchitecture as an, escapeHtml as ar, healthyPort as at, stopRun as b, SEVERITIES as ba, lifecycleChip as bi, subjectOf as bn, findExistingReview as br, writePortPreference as bt, discardJob as c, findingAssessment as ca, previousKissResult as ci, repositoryKey as cn, ReviewBeingDeletedError as cr, serverEntryExists as ct, startKissJob as d, gradeScale as da, reviewedRepositories as di, trackedFiles as dn, MANAGED_ROOT as dr, stopServer as dt, isExplanationAction as ea, latestKissRun as ei, RUNTIME_WORDS as en, versionFrom as eo, hasAuthorContent as er, recordAskAccepted as et, isDriving as f, isGradeFor as fa, summarise as fi, ownersOf as fn, createWorktree as fr, workspaceUrl as ft, completeRun as g, sourcePhrase as ga, LIFECYCLES as gi, isArchitectureId as gn, removeWorktree as gr, MIN_WORKSPACE_PORT as gt, beginRun as h, reassessIn as ha, workspaceStamps as hi, ancestorsOf as hn, readMarker as hr, MAX_WORKSPACE_PORT as ht, deleteReview as i, analysisRefOf as ia, matchingWorkspaceIds as ii, checkArchitecture as in, CODE_COPY_CLASS as ir, ensureServer as it, RUNNER_KINDS as j, isCommitReview as ja, deleteCollection as ji, pruneNotifications as jn, endedAt as jr, liveUpdateFor as jt, queueForReview as k, DetachedHeadError as ka, createCollection as ki, markReadForReview as kn, allJobs as kr, askCheckout as kt, kissAgentId as l, findingIn as la, recentWorkspaces as li, storeArchitecture as ln, isBusy as lr, spawnServer as lt, RUN_KINDS as m, promptGrade as ma, workspaceRevision as mi, REPOSITORY_SCOPE as mn, isWorktreeHeld as mr, DEFAULT_WORKSPACE_PORT as mt, MCP_TOOL_NAMES as n, ANALYSIS_ONLY as na, lineagePosition as ni, formatDuration as nn, AgentCancelledError as no, renderMarkdown as nr, bootstrapUrl as nt, liveJobsFor as o, closesFinding as oa, positionInLineage as oi, partFiles as on, renderInlineText as or, readServerRecord as ot, track as p, isOffered as pa, touchWorkspace as pi, QUOTE_LIMITS as pn, holdWorktree as pr, writeServerRecord as pt, endAskRequest as q, agentById as qa, resolvedByConversation as qi, refreshPrContext as qn, decideKissRecommendation as qr, telemetryUploadEnabled as qt, deleteLineage as r, NO_STATUS as ra, loadWorkspace as ri, ARCHITECTURE_DIR as rn, AgentUnavailableError as ro, CODE_BLOCK_CLASS as rr, clearServerRecordOwnedBy as rt, wasBlocked as s, currentGradeIn as sa, presentedKissRunOf as si, readArchitecture as sn, modelHelpLines as sr, reviewsUrl as st, MCP_SERVER_INFO_NAME as t, withExplanation as ta, lineageKey as ti, describeRuntimes as tn, AGENT_RUN_MARKER as to, GITHUB_MARKDOWN as tr, readIndexToken as tt, recordKissRun as u, findingStatus as ua, reviewedCommit as ui, storedScopes as un, withReviewLock as ur, stopChild as ut, heldRuns as v, wasReassessed as va, activityLabel as vi, announceJob as vn, describeMovement as vr, resolveWorkspacePort as vt, unsupportedReason as w, describeAuthorship as wa, lifecyclePillLabel as wi, createPrUpdate as wn, reviewedShaOf as wr, cancelUpdate as wt, batchIdentity as x, asString$1 as xa, lifecycleItemLabel as xi, categoryOf as xn, checkCodeFreshness as xr, COMMIT_REVIEW_CANNOT_UPDATE as xt, reportRun as y, followUpFindingId as ya, isLifecycle as yi, branchOf as yn, describeSubject as yr, statedWorkspacePort as yt, agentDisplayName as z, resolveModel as za, queueRemove as zi, withUsageRecorded as zn, isTerminalJobPhase as zr, startJob as zt };
+export { statusPillLabel as $, TargetError as $a, lifecycleItemLabel as $i, writeJsonAtomically as $n, findExistingReview as $r, statedWorkspacePort as $t, anythingRunning as A, currentGradeIn as Aa, indexReviewGroups as Ai, BUILD_VERSION as An, deleteCollection as Ao, chatConversationSection as Ar, isRequestId as At, completedLabel as B, statusLookup as Ba, previousKissResult as Bi, checkArchitecture as Bn, modelHelpLines as Br, readServerRecord as Bt, parsePullRequestLink as C, isExplanationAction as Ca, driverGone as Ci, readEvents as Cn, AGENT_RUN_MARKER as Co, ASK_REREAD_CEILING_MS as Cr, findingRefs as Ct, INDEX_SECTIONS as D, analysisRefOf as Da, followedRefName as Di, recordTelemetryUploadConsent as Dn, collectionsStamp as Do, isUnchanged as Dr, endAskRequest as Dt, relativeTime as E, NO_STATUS as Ea, decideKissRecommendation as Ei, deliver$1 as En, cleanName as Eo, storedConversation as Er, reviewTagsIn as Et, collectionFold as F, isGradeFor as Fa, loadWorkspace as Fi, recordRuntimeBestEffort as Fn, STORE_ROOT as Fo, renderMarkdown as Fr, readIndexToken as Ft, markItemLabel as G, extractJsonText as Ga, touchWorkspace as Gi, storeArchitecture as Gn, createWorktree as Gr, stopServer as Gt, homeSection as H, followUpFindingId as Ha, reviewedCommit as Hi, partFiles as Hn, isBusy as Hr, serverEntryExists as Ht, collectionHash as I, isOffered as Ia, matchingWorkspaceIds as Ii, RUNTIME_WORDS as In, CODE_BLOCK_CLASS as Ir, bootstrapUrl as It, queueItemLabel as J, WITHHELD_REASON as Ja, LIFECYCLES as Ji, ownersOf as Jn, readMarker as Jr, DEFAULT_WORKSPACE_PORT as Jt, omittedText as K, objectWithAnyOf as Ka, workspaceRevision as Ki, storedScopes as Kn, holdWorktree as Kr, workspaceUrl as Kt, collectionPlacement as L, promptGrade as La, mutateWorkspace as Li, describeRuntimes as Ln, CODE_COPY_CLASS as Lr, clearServerRecordOwnedBy as Lt, authorOptions as M, findingIn as Ma, kissDecisionsOf as Mi, feedbackUrl as Mn, readCollections as Mo, authorPreview as Mr, markAskRunning as Mt, collectionCountLabel as N, findingStatus as Na, latestKissRun as Ni, waitingHistory as Nn, renameCollection as No, hasAuthorContent as Nr, readAskRequest as Nt, INDEX_SECTION_NAMES as O, assessmentLookup as Oa, groupByLineage as Oi, telemetryUploadConsent as On, createCollection as Oo, agentEnvOf as Or, forgetAskRequest as Ot, collectionEmptyText as P, gradeScale as Pa, lineagePosition as Pi, mapRuntimes as Pn, setMembership as Po, GITHUB_MARKDOWN as Pr, recordAskAccepted as Pt, statusLabel as Q, DetachedHeadError as Qa, lifecycleChip as Qi, isArchitectureId as Qn, describeSubject as Qr, resolveWorkspacePort as Qt, collectionsLine as R, reassessIn as Ra, positionInLineage as Ri, formatDuration as Rn, escapeHtml as Rr, ensureServer as Rt, extractPullRequestLinks as S, explanationOf as Sa, clearClaim as Si, append as Sn, versionFrom as So, existingPaths as Sr, findingRef as St, runBatch as T, ANALYSIS_ONLY as Ta, CLAIM_LEASE_MS as Ti, stamp as Tn, AgentUnavailableError as To, saveRefresh as Tr, reviewTag as Tt, isCollectionId as U, SEVERITIES as Ua, reviewedRepositories as Ui, readArchitecture as Un, withReviewLock as Ur, spawnServer as Ut, countLabel as V, wasReassessed as Va, recentWorkspaces as Vi, loadArchitecture as Vn, ReviewBeingDeletedError as Vr, reviewsUrl as Vt, isFoldKey as W, asString$1 as Wa, summarise as Wi, repositoryKey as Wn, MANAGED_ROOT as Wr, stopChild as Wt, sectionOpen as X, resolveTarget as Xa, activityLabel as Xi, REPOSITORY_SCOPE as Xn, requestJobStop as Xr, MIN_WORKSPACE_PORT as Xt, queueOptionLabel as Y, kissOutcome as Ya, activityAttributes as Yi, QUOTE_LIMITS as Yn, removeWorktree as Yr, MAX_WORKSPACE_PORT as Yt, selectAllLabel as Z, originRemote as Za, isLifecycle as Zi, ancestorsOf as Zn, describeMovement as Zr, parseWorkspacePort as Zt, endRun as _, reviewerDispositions as _a, isLiveJob as _i, prepareReview as _n, agentIdentityOf as _o, retireNotification as _r, modelProvenanceOf as _t, lineageIds as a, sectionOf as aa, forgeResolver as ai, cancellableHere as an, git as ao, createPrState as ar, lineageKeysFor as at, stopRun as b, recommendationsOf as ba, progressSteps as bi, runJob as bn, parkedReason as bo, unreadCount as br, humanizeModelId as bt, discardJob as c, queueRemove as ca, allJobs as ci, recheckConversation as cn, resolveModel as co, listNotifications as cr, compactQueue as ct, startKissJob as d, doneVerb as da, fail as di, findingsChanged as dn, readAgentPreference as do, markReadForReview as dr, RUNNER_KINDS as dt, lifecycleName$1 as ea, checkCodeFreshness as ei, writePortPreference as en, isCommitReview as eo, announceJob as er, deliver as et, isDriving as f, isIssueOutstanding as fa, isTerminal as fi, UpdateAlreadyRunningError as fn, writeAgentPreference as fo, moveIds as fr, RUNNER_MARKER as ft, completeRun as g, resolvedByConversation as ga, PHASES as gi, observeReview as gn, agentFor as go, removeNotification as gr, applyUpdate as gt, beginRun as h, questionsOutstanding as ha, saveJob as hi, failureOf as hn, agentById as ho, readStateOf as hr, spawnRunner as ht, deleteReview as i, parseLifecycle as ia, fetchHead as ii, cancelUpdate as in, shorthandOf as io, createArchitectureNotification as ir, retryableMiss as it, authorOptionLabel as j, findingAssessment as ja, kissDecisionRefusal as ji, PACKAGE_NAME as jn, nameProblemText as jo, UNESTABLISHED_MOTIVATION as jr, isTerminalAsk as jt, PR_FILTER_OPTIONS as k, closesFinding as ka, indexKeptIds as ki, telemetryUploadEnabled as kn, createWithMembers as ko, EXPLAIN_SIMPLY_PROMPT as kr, interruption as kt, kissAgentId as l, queueStamp as la, attemptIdOf as li, updateReview as ln, agentIdOf as lo, markAllRead as lr, queueForReview as lt, RUN_KINDS as m, issuesOutstanding as ma, pruneJobResidue as mi, runningJobs as mn, AGENT_IDS as mo, readNotification as mr, runDetached as mt, MCP_TOOL_NAMES as n, lifecyclePillLabel as na, followedBranch as ni, FETCH_TIMEOUT_MS as nn, AmbiguousRefError as no, subjectOf as nr, missedDelivery as nt, liveJobsFor as o, queueAdd as oa, fillFileUrlTemplate as oi, mergeUpdateInto as on, refExists as oo, createPrUpdate as or, settleCollections as ot, track as p, isQuestionOutstanding as pa, loadJob as pi, liveUpdateFor as pn, CONFIG_PATH as po, pruneNotifications as pr, cliEntry as pt, pinItemLabel as q, describeAuthorship as qa, workspaceStamps as qi, trackedFiles as qn, isWorktreeHeld as qr, writeServerRecord as qt, deleteLineage as r, offersLifecycle as ra, reviewedShaOf as ri, RefreshUnavailableError as rn, shortNameOf as ro, categoryOf as rr, openDestination as rt, wasBlocked as s, queueAddMany as sa, RUN_RECORD_RETENTION_MS as si, parkedUpdateRefusal as sn, resolveAgent as so, eventName as sr, activateQueued as st, MCP_SERVER_INFO_NAME as t, lifecyclePillAction as ta, checkReview as ti, COMMIT_REVIEW_CANNOT_UPDATE as tn, resolveBase as to, branchOf as tr, isDelivered as tt, recordKissRun as u, readQueue as ua, endedAt as ui, askCheckout as un, clearAgentPreference as uo, markRead as ur, settleQueue as ut, heldRuns as v, verdictClosure as va, isTerminalJobPhase as vi, settleReview as vn, detectAgents as vo, toneOf as vr, provenanceDetailLines as vt, unsupportedReason as w, withExplanation as wa, isClaimed as wi, record as wn, AgentCancelledError as wo, prepareConversationWithin as wr, refOf as wt, batchIdentity as x, explanationActionOf as xa, purposeOf as xi, startJob as xn, runnableAgents as xo, withUsageRecorded as xr, findingAtRef as xt, reportRun as y, processDiscussion as ya, phasesFor as yi, reanalyseReview as yn, isAgentId as yo, unreadAround as yr, agentDisplayName as yt, completedFold as z, sourcePhrase as za, presentedKissRunOf as zi, ARCHITECTURE_DIR as zn, renderInlineText as zr, healthyPort as zt };