prreviewbuddy 0.93.0 → 0.96.0

package/dist/{mcp_tools-DbFR9Z90.js → mcp_tools-DEx9NxAc.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.
@@ -5829,154 +6226,27 @@ function issuesOutstanding(issues, dispositions) {
 	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()
-	};
-	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 {}
-	}
+		...counts,
+		...byConversation > 0 ? { byConversation } : {},
+		...byVerdict > 0 ? { byVerdict } : {}
+	};
 }
-function readHolder(path) {
-	try {
-		return JSON.parse(readFileSync(path, "utf8"));
-	} catch {
-		return null;
-	}
+/** 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";
 }
-/** 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 questionsOutstanding(questions, answered, closedByVerdict) {
+	return tally(questions, (question) => isQuestionOutstanding(question, answered, closedByVerdict), (question) => question.reconciliationStatus !== "answered" && (answered.has(question.id) || closedByVerdict(question.id)));
 }
-function processAlive(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return error.code === "EPERM";
-	}
+/**
+* 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,7 +6281,7 @@ 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;
+var VERSION$1 = 1;
 /**
 * What is queued, in order.
 *
@@ -6021,250 +6291,66 @@ var VERSION$2 = 1;
 * 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.
-*
-* 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(collections) : [];
-	} 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.";
+	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(ids) : [];
+	} catch {
+		return [];
+	}
 }
 /**
-* 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",
@@ -6523,29 +6531,182 @@ function lifecycleChip(lifecycle, activity) {
 	const movedAt = activity.movedAt ?? (activity.kind === "updated" ? activity.at : void 0);
 	return movedAt !== void 0 && movedAt > lifecycle.at ? "Changed since done" : void 0;
 }
-function changedSince(lifecycle, activity) {
-	return activity !== void 0 && activity.kind !== "created" && activity.at > lifecycle.at;
+function changedSince(lifecycle, activity) {
+	return activity !== void 0 && activity.kind !== "created" && activity.at > lifecycle.at;
+}
+/**
+* Which lifecycle items a card's menu offers.
+*
+* Every state but the one the card is already in, which would be an item that does nothing. A card
+* carrying a chip is the exception and offers all three: re-marking it is how the reviewer says
+* they have seen the change, so "Mark waiting" on a Waiting review that changed is the settle
+* action, not a no-op.
+*/
+function offersLifecycle(target, lifecycle, activity) {
+	if (lifecycleChip(lifecycle, activity) !== void 0) return true;
+	return target !== (lifecycle?.state ?? "active");
+}
+/**
+* A lifecycle item's words. The settle item on a changed Done review is "Keep done": "Mark done" on
+* something already Done reads as a no-op. Waiting keeps "Mark waiting", because a changed Waiting
+* review is drawn in Active, where parking it again is what the words already say.
+*/
+function lifecycleItemLabel(target, lifecycle, activity) {
+	if (target === "done" && lifecycle?.state === "done" && lifecycleChip(lifecycle, activity) !== void 0) return "Keep done";
+	return lifecycleAction(target);
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/reviewer_outcome.ts
+var REVIEWER_OUTCOMES = [
+	{
+		id: "no-concerns",
+		name: "Reviewed: no concerns",
+		baseline: true
+	},
+	{
+		id: "needs-changes",
+		name: "Needs changes",
+		baseline: true
+	},
+	{
+		id: "needs-decision",
+		name: "Needs a decision / answer",
+		baseline: true
+	},
+	{
+		id: "deeper-review",
+		name: "Needs deeper review",
+		baseline: false
+	},
+	{
+		id: "later",
+		name: "Later",
+		baseline: false
+	}
+];
+function parseOutcomeSnapshot(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const raw = value;
+	if (typeof raw.sessionId !== "string" || typeof raw.commitSha !== "string" || typeof raw.analysisRevision !== "string") return null;
+	return {
+		sessionId: raw.sessionId,
+		commitSha: raw.commitSha,
+		analysisRevision: raw.analysisRevision
+	};
+}
+function outcomeDefinition(kind) {
+	return REVIEWER_OUTCOMES.find((outcome) => outcome.id === kind);
+}
+function isBaselineKind(kind) {
+	return outcomeDefinition(kind)?.baseline === true;
+}
+function parseStoredOutcome(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const raw = value;
+	if (typeof raw.kind !== "string" || !outcomeDefinition(raw.kind)) return void 0;
+	if (typeof raw.at !== "number" || !Number.isFinite(raw.at)) return void 0;
+	if (typeof raw.commitSha !== "string" || typeof raw.sessionId !== "string") return void 0;
+	return {
+		kind: raw.kind,
+		at: raw.at,
+		commitSha: raw.commitSha,
+		sessionId: raw.sessionId,
+		analysisRevision: typeof raw.analysisRevision === "string" ? raw.analysisRevision : "",
+		...typeof raw.recordId === "string" ? { recordId: raw.recordId } : {},
+		...typeof raw.analysisJobId === "string" ? { analysisJobId: raw.analysisJobId } : {},
+		...Array.isArray(raw.answeredQuestions) ? { answeredQuestions: raw.answeredQuestions.filter((q) => typeof q === "string") } : {}
+	};
+}
+function parseOutcomes(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map(parseStoredOutcome).filter((outcome) => outcome !== void 0);
+}
+/** Newest last, capped. The baseline lives in its own field, so nothing here has to survive pruning. */
+function appendOutcome(history, outcome) {
+	return [...history, outcome].slice(-20);
+}
+/** The newer of two baselines; a non-baseline outcome never replaces one. */
+function nextBaseline(current, outcome) {
+	if (!isBaselineKind(outcome.kind)) return current;
+	return !current || outcome.at >= current.at ? outcome : current;
+}
+/** The newest baseline across a lineage's records, so a re-analysis that made a new record keeps it. */
+function lastBaseline(baselines) {
+	let newest;
+	for (const baseline of baselines) if (baseline && (!newest || baseline.at > newest.at)) newest = baseline;
+	return newest;
+}
+function sameSha(a, b) {
+	if (!a || !b) return false;
+	const length = Math.min(a.length, b.length);
+	return length >= 7 && a.slice(0, length) === b.slice(0, length);
+}
+/** How an outcome relates to the analysis on screen. */
+function outcomeStanding(outcome, snapshot) {
+	if (!sameSha(outcome.commitSha, snapshot.commitSha)) return "earlier-snapshot";
+	if (outcome.sessionId !== snapshot.sessionId || outcome.analysisRevision !== snapshot.analysisRevision) return "earlier-analysis";
+	return "current";
+}
+/**
+* Verdicts come from the history and from the stored baseline, which is never pruned: twenty
+* deferrals after a verdict push it out of the history, but not out of the reading.
+*/
+function readOutcomes(history, snapshot, baseline) {
+	const verdicts = history.filter((outcome) => isBaselineKind(outcome.kind));
+	if (baseline && isBaselineKind(baseline.kind) && !verdicts.some((outcome) => outcome.at === baseline.at && outcome.kind === baseline.kind)) verdicts.push(baseline);
+	verdicts.sort((a, b) => a.at - b.at);
+	const newestVerdict = verdicts.at(-1);
+	if (!snapshot) return newestVerdict ? { previous: {
+		outcome: newestVerdict,
+		standing: "earlier-snapshot"
+	} } : {};
+	const verdict = verdicts.filter((outcome) => outcomeStanding(outcome, snapshot) === "current").at(-1);
+	const deferral = history.filter((outcome) => !isBaselineKind(outcome.kind) && outcomeStanding(outcome, snapshot) === "current" && (!verdict || outcome.at > verdict.at)).at(-1);
+	const reading = {};
+	if (verdict) reading.verdict = verdict;
+	else if (newestVerdict) reading.previous = {
+		outcome: newestVerdict,
+		standing: outcomeStanding(newestVerdict, snapshot)
+	};
+	if (deferral) reading.deferral = deferral;
+	return reading;
+}
+/** "Needs changes", or how an older one reads beside a newer analysis. */
+function outcomeLabel(outcome, standing) {
+	const name = outcomeDefinition(outcome.kind)?.name ?? outcome.kind;
+	if (standing === "current") return name;
+	if (standing === "earlier-analysis") return `Outcome on an earlier analysis: ${name}`;
+	return `${name} on ${outcome.commitSha.slice(0, 7)} (earlier snapshot)`;
 }
+//#endregion
+//#region ../../packages/review-harness/src/workspace/analysis_revision.ts
 /**
-* Which lifecycle items a card's menu offers.
+* A short fingerprint of the analysis a reviewer is reading: its findings, statuses, notes and text.
 *
-* Every state but the one the card is already in, which would be an item that does nothing. A card
-* carrying a chip is the exception and offers all three: re-marking it is how the reviewer says
-* they have seen the change, so "Mark waiting" on a Waiting review that changed is the settle
-* action, not a no-op.
+* The session id and the commit do not move when a Re-check reconciles findings at the same commit,
+* so a verdict checked against those two alone would be accepted for findings the reviewer never saw.
+* The reviewer's own ticks are not part of it: those are the reviewer's acts, not the analysis.
 */
-function offersLifecycle(target, lifecycle, activity) {
-	if (lifecycleChip(lifecycle, activity) !== void 0) return true;
-	return target !== (lifecycle?.state ?? "active");
+function analysisRevision(workspace) {
+	const result = workspace.session.result;
+	if (!result) return "";
+	return createHash("sha256").update(JSON.stringify(result)).digest("hex").slice(0, 16);
 }
-/**
-* A lifecycle item's words. The settle item on a changed Done review is "Keep done": "Mark done" on
-* something already Done reads as a no-op. Waiting keeps "Mark waiting", because a changed Waiting
-* review is drawn in Active, where parking it again is what the words already say.
-*/
-function lifecycleItemLabel(target, lifecycle, activity) {
-	if (target === "done" && lifecycle?.state === "done" && lifecycleChip(lifecycle, activity) !== void 0) return "Keep done";
-	return lifecycleAction(target);
+/** The analysed commit, falling back the way `reviewedCommit` does. */
+function analysedCommit(workspace) {
+	return workspace.session.metadata?.commitSha || workspace.changeSet.data.pullRequest.head.sha || "";
+}
+function analysisSnapshot(workspace) {
+	if (!workspace.session.result) return null;
+	return {
+		sessionId: workspace.session.id,
+		commitSha: analysedCommit(workspace),
+		analysisRevision: analysisRevision(workspace)
+	};
+}
+/** When the analysis on screen was last produced or reconciled: the upper time bound for its history. */
+function analysedAt(workspace) {
+	return Math.max(workspace.session.metadata?.generatedAt ?? 0, workspace.lastUpdate?.at ?? 0, workspace.lastRecheck?.at ?? 0, workspace.createdAt);
 }
 //#endregion
 //#region ../../packages/review-harness/src/workspace/store.ts
@@ -6742,6 +6903,18 @@ function workspaceRevision(workspace) {
 	}
 }
 /**
+* Moves whenever any review is written or deleted, by this process or another: every write stages a
+* file in the directory and renames it into place, and a delete unlinks one. One stat, where
+* `workspaceStamps` is one per review, for a cache to ask whether anything changed at all.
+*/
+function workspacesRevision() {
+	try {
+		return statSync(WORKSPACES_DIR).mtimeMs;
+	} catch {
+		return 0;
+	}
+}
+/**
 * Every stored review as an id and a revision token, without reading one of them.
 *
 * Here rather than in `reviews_revision.ts` because this module owns the layout of `workspaces/`,
@@ -7023,6 +7196,14 @@ function groupByLineage(reviews) {
 	}
 	return [...groups].map(([key, members]) => {
 		const history = [...members].sort((a, b) => b.createdAt - a.createdAt);
+		const [newest] = history;
+		if (newest.outcomeInputs && history.length > 1) {
+			const { outcome: _outcome, deferral: _deferral, ...rest } = newest;
+			history[0] = {
+				...rest,
+				...lineageOutcome(newest.outcomeInputs, history.map((review) => review.outcomeInputs))
+			};
+		}
 		return {
 			key,
 			latest: history[0],
@@ -7153,6 +7334,8 @@ function summarise(workspace) {
 		})(),
 		lastViewedAt: workspace.lastViewedAt,
 		completedAt: workspace.completedAt,
+		outcomeInputs: outcomeInputsOf(workspace),
+		...outcomeSummary(outcomeInputsOf(workspace)),
 		pinned: workspace.pinned === true,
 		lifecycle: parseLifecycle(workspace.lifecycle),
 		paths: files.slice(0, MAX_INDEXED_PATHS).map((file) => file.name),
@@ -7163,6 +7346,42 @@ function summarise(workspace) {
 		authorName: workspace.prContext?.pullRequest.author?.name || void 0
 	};
 }
+function outcomeInputsOf(workspace) {
+	const baseline = parseStoredOutcome(workspace.reviewedBaseline);
+	return {
+		history: parseOutcomes(workspace.reviewerOutcomes),
+		snapshot: analysisSnapshot(workspace),
+		...baseline ? { baseline } : {}
+	};
+}
+/**
+* The newest record's outcomes read with the newest baseline of its whole lineage, as Quick Review
+* reads them. A fresh analysis makes a record with no baseline of its own, and the verdict on the
+* one before must still show on the card, as an earlier one, instead of vanishing from it.
+*/
+function lineageOutcome(newest, lineage) {
+	return outcomeSummary(newest, lastBaseline([newest.baseline, ...lineage.map((inputs) => inputs?.baseline)]));
+}
+function outcomeSummary(inputs, baseline = inputs.baseline) {
+	const reading = readOutcomes(inputs.history, inputs.snapshot, baseline);
+	const verdict = reading.verdict ? {
+		outcome: reading.verdict,
+		standing: "current"
+	} : reading.previous;
+	return {
+		...verdict ? { outcome: {
+			kind: verdict.outcome.kind,
+			standing: verdict.standing,
+			label: outcomeLabel(verdict.outcome, verdict.standing),
+			at: verdict.outcome.at
+		} } : {},
+		...reading.deferral ? { deferral: {
+			kind: reading.deferral.kind,
+			label: outcomeLabel(reading.deferral, "current"),
+			at: reading.deferral.at
+		} } : {}
+	};
+}
 /**
 * The commit a review was made from, however the record spells it. Null when it recorded none.
 *
@@ -8378,6 +8597,14 @@ function sanitisePullRequest(value) {
 	if (template) pr.fileUrlTemplate = template;
 	const author = pullRequestAuthor(value.author);
 	if (author) pr.author = author;
+	if (isRecord$1(value.headRepository)) {
+		const owner = label(value.headRepository.owner);
+		const repo = label(value.headRepository.repo);
+		if (owner && repo) pr.headRepository = {
+			owner,
+			repo
+		};
+	}
 	return pr;
 }
 /**
@@ -9085,7 +9312,7 @@ function slug(repo) {
 * `baseRefOid` is a diff taken against the wrong *commit*, which is worse because the branch name
 * is right and everything reads as normal. A list nobody asserts is a list somebody tidies.
 */
-var PR_FIELDS = "number,url,title,body,headRefName,headRefOid,baseRefName,baseRefOid,changedFiles,author";
+var PR_FIELDS = "number,url,title,body,headRefName,headRefOid,baseRefName,baseRefOid,changedFiles,author,headRepository,headRepositoryOwner";
 async function viewRequest(repo, reference, cwd, env) {
 	return await ghJson([
 		"pr",
@@ -9134,7 +9361,11 @@ function identity(raw) {
 		author: author ? {
 			name: text$2(author.name),
 			handle: text$2(author.login)
-		} : null
+		} : null,
+		...text$2(raw.headRepositoryOwner?.login) && text$2(raw.headRepository?.name) ? { headRepository: {
+			owner: text$2(raw.headRepositoryOwner?.login),
+			repo: text$2(raw.headRepository?.name)
+		} } : {}
 	};
 }
 /**
@@ -11329,6 +11560,32 @@ ${diff}`;
 	};
 }
 //#endregion
+//#region ../../packages/review-harness/src/domain/ai_review/behaviour_change.ts
+/** Both sides present and non-empty, or nothing: half an explanation is not one. */
+function parseBehaviourChange(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const raw = value;
+	const before = typeof raw.before === "string" ? raw.before.trim() : "";
+	const after = typeof raw.after === "string" ? raw.after.trim() : "";
+	return before && after ? {
+		before,
+		after
+	} : void 0;
+}
+function withBehaviourChange(change) {
+	return change ? { behaviourChange: change } : {};
+}
+/**
+* The behaviourChange an update keeps.
+*
+* Restated: the new one. New code and none restated: dropped, because the old one describes a head
+* that no longer exists. A conversation-only pass read no new code, so the previous one still holds.
+*/
+function mergeBehaviourChange(previous, restated, codeChanged) {
+	if (restated) return restated;
+	return codeChanged ? void 0 : previous;
+}
+//#endregion
 //#region ../../packages/review-harness/src/domain/utils/html.ts
 function escapeHtml(value) {
 	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
@@ -12644,6 +12901,10 @@ var CONSEQUENCE_GUIDANCE = `"consequence" on an issue: the same issue told as wh
   - An issue names a concrete consequence. A request for missing requirements with no concrete consequence is a question for the author, not an issue, and is never raised as both.`;
 /** What "orientation" is for, as the first analysis and an update ask for it. */
 var ORIENTATION_GUIDANCE = `"orientation": one sentence, at most about 25 words, naming the behaviour or product area this change touches, for a reviewer about to decide on its issues (e.g. "This change affects receipt extraction and how duplicate receipt details are combined."). Say what it touches, not whether it is safe, and do not summarise the issues.`;
+/** The behaviourChange shape, written out whole for every prompt that asks for it. */
+var BEHAVIOUR_CHANGE_FIELD = "\"behaviourChange\"?: { \"before\": string, \"after\": string }";
+/** What "behaviourChange" is for, as the first analysis and an update ask for it. */
+var BEHAVIOUR_CHANGE_GUIDANCE = `"behaviourChange": how the behaviour this pull request touches works today and how it works with the whole pull request applied, for a reviewer who knows the product. "before" is the behaviour at the base the pull request targets; "after" is the behaviour at the head you analysed. One to three plain sentences each, leading with what a user or the system experiences, not with the implementation (e.g. before: "A failed payment is shown as an error and the order is cancelled.", after: "A failed payment is retried twice before the order is cancelled, and the customer is emailed after the last attempt."). Describe the whole pull request, not one commit. Omit the field entirely when the code you read does not establish how it works today: never guess "before".`;
 /**
 * How an update keeps a prior finding's consequence and resolution true, beside its status.
 *
@@ -13450,6 +13711,7 @@ var STRUCTURED_OUTPUT_INSTRUCTIONS = `In addition to the review principles above
   },
   "overallRisk": "low" | "medium" | "high",
   "orientation": string,
+  ${BEHAVIOUR_CHANGE_FIELD},
   "sections": [{
     "id": string,
     "order": number,
@@ -13487,6 +13749,7 @@ Field guidance:
 - ${CONSEQUENCE_GUIDANCE}
 - ${QUESTION_FRAMING_GUIDANCE}
 - ${ORIENTATION_GUIDANCE}
+- ${BEHAVIOUR_CHANGE_GUIDANCE}
 - "existingDiscussion" on an issue: set this only when a thread in the PR DISCUSSION CONTEXT block already raises this same concern, and you have independently confirmed from the diff that it still applies. "threadId" must be copied verbatim from that thread's [T_...] marker — never invent an id, never guess, and omit the field entirely if no thread matches. Set "relation" to "same" when the thread already makes this exact point, or "related" when it discusses this area without covering the finding — a reviewer acts differently on "someone said this already" than on "someone was looking near here". Still write the issue normally; this field only records that the point was raised before, so the reviewer is not shown it as a fresh discovery. Do not use it to pad the review with issues you would otherwise have left out.
 - "confidence" on an issue: how sure you are the issue is real, on the same high/medium/low scale as a question's "importance". This is a separate axis from "severity", which is how much it would matter if real — a critical issue you are unsure about and a nit you are certain of are different things to act on, so do not let one field stand in for the other. Use LOW when you are reasoning from a diff excerpt without the surrounding code, and say what would confirm it in the description. Omit the field rather than guessing a middle value.
 - "questions": each one is a genuine open item the reviewer needs answered before they can sign off, not a rhetorical prompt. "importance" is how much attention it deserves, on the same high/medium/low scale as a section's "reviewAttention" (e.g. a question about a possibly-exposed secret is "high"; a naming preference is "low"). "whyThisMatters" is 1-2 sentences explaining the concrete consequence of the question going unanswered — not a restatement of the question itself.
@@ -13545,6 +13808,7 @@ function parseUnchecked(raw) {
 			summary,
 			overallRisk: RISKS.includes(obj.overallRisk) ? obj.overallRisk : "medium",
 			...asString$1(obj.orientation).trim() ? { orientation: asString$1(obj.orientation).trim() } : {},
+			...withBehaviourChange(parseBehaviourChange(obj.behaviourChange)),
 			sections: normalizeSections(obj.sections),
 			issues: normalizeIssues(obj.issues),
 			questions: normalizeQuestions(obj.questions),
@@ -17076,7 +17340,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);
@@ -18218,6 +18482,7 @@ var RECONCILIATION_SHAPE = `{
   }],
   "summary": string,
   "orientation": string,
+  ${BEHAVIOUR_CHANGE_FIELD},
   "overallRisk": "low" | "medium" | "high",
   "recommendation": string,
   "nextSteps": string[]
@@ -18325,6 +18590,12 @@ var GRADE_TASK = {
 * written to fix a finding is precisely where a regression gets introduced. A run that only
 * reassessed the list has done half the work, and it is the half that looks complete.
 */
+/** The earlier before-and-after, quoted so the model can restate it rather than start over. */
+function previousBehaviourChange(previous) {
+	const change = previous.behaviourChange;
+	if (!change) return "";
+	return ` (the earlier analysis said: before: ${JSON.stringify(change.before)}; after: ${JSON.stringify(change.after)}. Keep what still holds, correct what the new changes alter)`;
+}
 function buildReconciliationInstructions(input, options = {}) {
 	const { previous, totalCommits, changedFiles, possiblyTruncated } = input;
 	const reassess = input.reassess ?? /* @__PURE__ */ new Map();
@@ -18358,7 +18629,7 @@ ${REASSESS_TASK}` : ""}
    ${GRADE_TASK.question}`] : [],
 		conversationOnly ? `No commits were pushed, so there is no new code to review. Report a problem in "newIssues" only where the conversation points at something in the code the earlier analysis missed and you have confirmed it by reading the code. Do NOT repeat a previous finding here: if it still stands, that is what "still-open" is for.` : `Read the changed code above as a reviewer, not only as an auditor of the numbered list. These commits have not been reviewed by anyone. Report every genuinely NEW problem you find in them in "newIssues", whether or not it relates to anything on the list — code written to fix a finding is exactly where a regression gets introduced, and reassessing the list and stopping there is half the job. Do NOT repeat a previous finding here: if it still stands, that is what "still-open" is for.`,
 		`If the new changes introduce an area the earlier analysis had no section for, add it to "newSections". Otherwise return an empty array. Do not restate or restructure the earlier analysis's existing sections.`,
-		`Give a fresh "summary", "overallRisk", "recommendation" and "nextSteps" for the pull request AS IT NOW STANDS, taking both the earlier findings that survive and the new changes into account. Unlike a partial review, you have been shown the earlier analysis in full and are expected to revise its verdict where the new changes justify it. ${SUMMARY_GUIDANCE} ${ORIENTATION_GUIDANCE}`
+		`Give a fresh "summary", "overallRisk", "recommendation" and "nextSteps" for the pull request AS IT NOW STANDS, taking both the earlier findings that survive and the new changes into account. Unlike a partial review, you have been shown the earlier analysis in full and are expected to revise its verdict where the new changes justify it. ${SUMMARY_GUIDANCE} ${ORIENTATION_GUIDANCE} ${BEHAVIOUR_CHANGE_GUIDANCE} Restate "behaviourChange" for the whole pull request as it now stands${previousBehaviourChange(previous)}, or omit it when the evidence does not establish it.`
 	].map((task, index) => `${index + 1}. ${task}`).join("\n");
 	return `${conversationOnly ? `You are RECONCILING an earlier analysis of this pull request against what has changed in its conversation since that analysis was made.
 
@@ -18532,6 +18803,7 @@ function parseReconciliationResult(raw, priorCount, options = {}) {
 		})),
 		summary: asString$1(obj.summary).trim(),
 		orientation: asString$1(obj.orientation).trim(),
+		...withBehaviourChange(parseBehaviourChange(obj.behaviourChange)),
 		overallRisk: RISKS.includes(obj.overallRisk) ? obj.overallRisk : null,
 		recommendation: asString$1(obj.recommendation).trim(),
 		nextSteps: asStringArray(obj.nextSteps)
@@ -18809,6 +19081,15 @@ function findingsChanged(counts) {
 }
 //#endregion
 //#region ../../packages/review-harness/src/domain/ai_review/update_reconciliation.ts
+/**
+* Folding an update's answer onto the analysis it brings up to date.
+*
+* One function for every client that updates a review, so the workspace and the extension cannot
+* come to read the same evidence differently: what a cited comment may settle, when a resolution is
+* marked for reassessment instead, which findings a changed comment reopens, what each status is
+* recorded against, and which threads a new finding may claim. A client differs only in how it
+* fetched the changes and ran the model.
+*/
 function reconciledAgainstOf(basis) {
 	return basis.code ? basis.discussion ? "commits-and-conversation" : "commits" : "conversation";
 }
@@ -18841,6 +19122,7 @@ function applyReconciliation(previous, parsed, context) {
 		schemaVersion: 1,
 		summary: parsed.summary || previous.summary,
 		...parsed.orientation || previous.orientation ? { orientation: parsed.orientation || previous.orientation } : {},
+		...withBehaviourChange(mergeBehaviourChange(previous.behaviourChange, parsed.behaviourChange, context.codeChanged)),
 		...motivation ? { motivation } : {},
 		overallRisk: parsed.overallRisk ?? previous.overallRisk,
 		recommendation: parsed.recommendation || previous.recommendation,
@@ -21009,6 +21291,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.
@@ -21616,4 +22449,4 @@ var MCP_TOOL_NAMES = [
 	"ask_buddy"
 ];
 //#endregion
-export { readAskRequest as $, versionFrom as $a, isExplanationAction as $i, hasAuthorContent as $n, latestKissRun as $r, waitingHistory as $t, settleQueue as A, isCommitReview as Aa, deleteCollection as Ai, markRead as An, endedAt as Ar, askCheckout as At, humanizeModelId as B, clearAgentPreference as Ba, readQueue as Bi, unreadCount as Bn, progressSteps as Br, runJob as Bt, parsePullRequestLink as C, describeAuthorship as Ca, lifecyclePillLabel as Ci, categoryOf as Cn, reviewedShaOf as Cr, RefreshUnavailableError as Ct, activateQueued as D, originRemote as Da, collectionsStamp as Di, eventName as Dn, RUN_RECORD_RETENTION_MS as Dr, parkedUpdateRefusal as Dt, relativeTime as E, resolveTarget as Ea, sectionOf as Ei, createPrUpdate as En, fillFileUrlTemplate as Er, mergeUpdateInto as Et, spawnRunner as F, git as Fa, updateCollections as Fi, readStateOf as Fn, saveJob as Fr, failureOf as Ft, reviewTag as G, AGENT_IDS as Ga, questionsOutstanding as Gi, saveRefresh as Gn, CLAIM_LEASE_MS as Gr, stamp as Gt, findingRef as H, writeAgentPreference as Ha, isIssueOutstanding as Hi, existingPaths as Hn, clearClaim as Hr, append as Ht, applyUpdate as I, refExists as Ia, queueAdd as Ii, removeNotification as In, PHASES as Ir, observeReview as It, forgetAskRequest as J, agentIdentityOf as Ja, verdictClosure as Ji, agentEnvOf as Jn, groupByLineage as Jr, telemetryUploadConsent as Jt, reviewTagsIn as K, agentById as Ka, resolvedByConversation as Ki, storedConversation as Kn, decideKissRecommendation as Kr, deliver as Kt, modelProvenanceOf as L, resolveAgent as La, queueAddMany as Li, retireNotification as Ln, isLiveJob as Lr, prepareReview as Lt, RUNNER_MARKER as M, AmbiguousRefError as Ma, readCollections as Mi, moveIds as Mn, isTerminal as Mr, UpdateAlreadyRunningError as Mt, cliEntry as N, shortNameOf as Na, renameCollection as Ni, pruneNotifications as Nn, loadJob as Nr, liveUpdateFor as Nt, compactQueue as O, DetachedHeadError as Oa, createCollection as Oi, listNotifications as On, allJobs as Or, recheckConversation as Ot, runDetached as P, shorthandOf as Pa, setMembership as Pi, readNotification as Pn, pruneJobResidue as Pr, runningJobs as Pt, markAskRunning as Q, runnableAgents as Qa, explanationOf as Qi, authorPreview as Qn, kissDecisionsOf as Qr, feedbackUrl as Qt, provenanceDetailLines as R, resolveModel as Ra, queueRemove as Ri, toneOf as Rn, isTerminalJobPhase as Rr, settleReview as Rt, extractPullRequestLinks as S, objectWithAnyOf as Sa, lifecyclePillAction as Si, subjectOf as Sn, followedBranch as Sr, FETCH_TIMEOUT_MS as St, runBatch as T, kissOutcome as Ta, parseLifecycle as Ti, createPrState as Tn, forgeResolver as Tr, cancellableHere as Tt, findingRefs as U, CONFIG_PATH as Ua, isQuestionOutstanding as Ui, ASK_REREAD_CEILING_MS as Un, driverGone as Ur, readEvents as Ut, findingAtRef as V, readAgentPreference as Va, doneVerb as Vi, withUsageRecorded as Vn, purposeOf as Vr, startJob as Vt, refOf as W, STORE_ROOT as Wa, issuesOutstanding as Wi, prepareConversationWithin as Wn, isClaimed as Wr, record as Wt, isRequestId as X, isAgentId as Xa, recommendationsOf as Xi, chatConversationSection as Xn, indexReviewGroups as Xr, BUILD_VERSION as Xt, interruption as Y, detectAgents as Ya, processDiscussion as Yi, EXPLAIN_SIMPLY_PROMPT as Yn, indexKeptIds as Yr, telemetryUploadEnabled as Yt, isTerminalAsk as Z, parkedReason as Za, explanationActionOf as Zi, UNESTABLISHED_MOTIVATION as Zn, kissDecisionRefusal as Zr, PACKAGE_NAME as Zt, endRun as _, wasReassessed as _a, activityLabel as _i, ancestorsOf as _n, describeMovement as _r, parseWorkspacePort as _t, lineageIds as a, closesFinding as aa, positionInLineage as ai, ARCHITECTURE_DIR as an, renderInlineText as ar, healthyPort as at, stopRun as b, asString$1 as ba, lifecycleItemLabel as bi, announceJob as bn, checkCodeFreshness as br, writePortPreference as bt, discardJob as c, findingIn as ca, recentWorkspaces as ci, partFiles as cn, isBusy as cr, serverEntryExists as ct, startKissJob as d, isGradeFor as da, summarise as di, storeArchitecture as dn, createWorktree as dr, stopServer as dt, withExplanation as ea, lineageKey as ei, mapRuntimes as en, AGENT_RUN_MARKER as eo, GITHUB_MARKDOWN as er, recordAskAccepted as et, isDriving as f, isOffered as fa, touchWorkspace as fi, storedScopes as fn, holdWorktree as fr, workspaceUrl as ft, completeRun as g, statusLookup as ga, activityAttributes as gi, REPOSITORY_SCOPE as gn, requestJobStop as gr, MIN_WORKSPACE_PORT as gt, beginRun as h, sourcePhrase as ha, LIFECYCLES as hi, QUOTE_LIMITS as hn, removeWorktree as hr, MAX_WORKSPACE_PORT as ht, deleteReview as i, assessmentLookup as ia, mutateWorkspace as ii, formatDuration as in, escapeHtml as ir, ensureServer as it, RUNNER_KINDS as j, resolveBase as ja, nameProblemText as ji, markReadForReview as jn, fail as jr, findingsChanged as jt, queueForReview as k, TargetError as ka, createWithMembers as ki, markAllRead as kn, attemptIdOf as kr, updateReview as kt, kissAgentId as l, findingStatus as la, reviewedCommit as li, readArchitecture as ln, withReviewLock as lr, spawnServer as lt, RUN_KINDS as m, reassessIn as ma, workspaceStamps as mi, ownersOf as mn, readMarker as mr, DEFAULT_WORKSPACE_PORT as mt, MCP_TOOL_NAMES as n, NO_STATUS as na, loadWorkspace as ni, RUNTIME_WORDS as nn, AgentUnavailableError as no, CODE_BLOCK_CLASS as nr, bootstrapUrl as nt, liveJobsFor as o, currentGradeIn as oa, presentedKissRunOf as oi, checkArchitecture as on, modelHelpLines as or, readServerRecord as ot, track as p, promptGrade as pa, workspaceRevision as pi, trackedFiles as pn, isWorktreeHeld as pr, writeServerRecord as pt, endAskRequest as q, agentFor as qa, reviewerDispositions as qi, isUnchanged as qn, followedRefName as qr, recordTelemetryUploadConsent as qt, deleteLineage as r, analysisRefOf as ra, matchingWorkspaceIds as ri, describeRuntimes as rn, CODE_COPY_CLASS as rr, clearServerRecordOwnedBy as rt, wasBlocked as s, findingAssessment as sa, previousKissResult as si, loadArchitecture as sn, ReviewBeingDeletedError as sr, reviewsUrl as st, MCP_SERVER_INFO_NAME as t, ANALYSIS_ONLY as ta, lineagePosition as ti, recordRuntimeBestEffort as tn, AgentCancelledError as to, renderMarkdown as tr, readIndexToken as tt, recordKissRun as u, gradeScale as ua, reviewedRepositories as ui, repositoryKey as un, MANAGED_ROOT as ur, stopChild as ut, heldRuns as v, followUpFindingId as va, isLifecycle as vi, isArchitectureId as vn, describeSubject as vr, resolveWorkspacePort as vt, unsupportedReason as w, WITHHELD_REASON as wa, offersLifecycle as wi, createArchitectureNotification as wn, fetchHead as wr, cancelUpdate as wt, batchIdentity as x, extractJsonText as xa, lifecycleName as xi, branchOf as xn, checkReview as xr, COMMIT_REVIEW_CANNOT_UPDATE as xt, reportRun as y, SEVERITIES as ya, lifecycleChip as yi, writeJsonAtomically as yn, findExistingReview as yr, statedWorkspacePort as yt, agentDisplayName as z, agentIdOf as za, queueStamp as zi, unreadAround as zn, phasesFor as zr, reanalyseReview as zt };
+export { statusLabel as $, gradeScale as $a, workspacesRevision as $i, isArchitectureId as $n, setMembership as $o, describeSubject as $r, resolveWorkspacePort as $t, PR_FILTER_OPTIONS as A, doneVerb as Aa, indexKeptIds as Ai, telemetryUploadEnabled as An, readAgentPreference as Ao, EXPLAIN_SIMPLY_PROMPT as Ar, interruption as At, completedFold as B, explanationActionOf as Ba, matchingWorkspaceIds as Bi, ARCHITECTURE_DIR as Bn, runnableAgents as Bo, renderInlineText as Br, healthyPort as Bt, parsePullRequestLink as C, parseLifecycle as Ca, clearClaim as Ci, append as Cn, shorthandOf as Co, existingPaths as Cr, findingRef as Ct, INDEX_SECTIONS as D, queueRemove as Da, decideKissRecommendation as Di, deliver$1 as Dn, resolveModel as Do, storedConversation as Dr, reviewTagsIn as Dt, relativeTime as E, queueAddMany as Ea, CLAIM_LEASE_MS as Ei, stamp as En, resolveAgent as Eo, saveRefresh as Er, reviewTag as Et, collectionEmptyText as F, resolvedByConversation as Fa, lineageKey as Fi, mapRuntimes as Fn, agentFor as Fo, GITHUB_MARKDOWN as Fr, recordAskAccepted as Ft, isFoldKey as G, NO_STATUS as Ga, previousKissResult as Gi, repositoryKey as Gn, cleanName as Go, MANAGED_ROOT as Gr, stopChild as Gt, countLabel as H, isExplanationAction as Ha, outcomeInputsOf as Hi, loadArchitecture as Hn, AGENT_RUN_MARKER as Ho, ReviewBeingDeletedError as Hr, reviewsUrl as Ht, collectionFold as I, reviewerDispositions as Ia, lineageKeyFor as Ii, recordRuntimeBestEffort as In, agentIdentityOf as Io, renderMarkdown as Ir, readIndexToken as It, pinItemLabel as J, closesFinding as Ja, reviewedRepositories as Ji, trackedFiles as Jn, createWithMembers as Jo, isWorktreeHeld as Jr, writeServerRecord as Jt, markItemLabel as K, analysisRefOf as Ka, recentWorkspaces as Ki, storeArchitecture as Kn, collectionsStamp as Ko, createWorktree as Kr, stopServer as Kt, collectionHash as L, verdictClosure as La, lineageOutcome as Li, RUNTIME_WORDS as Ln, detectAgents as Lo, CODE_BLOCK_CLASS as Lr, bootstrapUrl as Lt, authorOptionLabel as M, isQuestionOutstanding as Ma, kissDecisionRefusal as Mi, PACKAGE_NAME as Mn, CONFIG_PATH as Mo, UNESTABLISHED_MOTIVATION as Mr, isTerminalAsk as Mt, authorOptions as N, issuesOutstanding as Na, kissDecisionsOf as Ni, feedbackUrl as Nn, AGENT_IDS as No, authorPreview as Nr, markAskRunning as Nt, INDEX_SECTION_NAMES as O, queueStamp as Oa, followedRefName as Oi, recordTelemetryUploadConsent as On, agentIdOf as Oo, isUnchanged as Or, endAskRequest as Ot, collectionCountLabel as P, questionsOutstanding as Pa, latestKissRun as Pi, waitingHistory as Pn, agentById as Po, hasAuthorContent as Pr, readAskRequest as Pt, selectAllLabel as Q, findingStatus as Qa, workspaceStamps as Qi, ancestorsOf as Qn, renameCollection as Qo, describeMovement as Qr, parseWorkspacePort as Qt, collectionPlacement as R, processDiscussion as Ra, lineagePosition as Ri, describeRuntimes as Rn, isAgentId as Ro, CODE_COPY_CLASS as Rr, clearServerRecordOwnedBy as Rt, extractPullRequestLinks as S, offersLifecycle as Sa, purposeOf as Si, startJob as Sn, shortNameOf as So, withUsageRecorded as Sr, findingAtRef as St, runBatch as T, queueAdd as Ta, isClaimed as Ti, record as Tn, refExists as To, prepareConversationWithin as Tr, refOf as Tt, homeSection as U, withExplanation as Ua, positionInLineage as Ui, partFiles as Un, AgentCancelledError as Uo, isBusy as Ur, serverEntryExists as Ut, completedLabel as V, explanationOf as Va, mutateWorkspace as Vi, checkArchitecture as Vn, versionFrom as Vo, modelHelpLines as Vr, readServerRecord as Vt, isCollectionId as W, ANALYSIS_ONLY as Wa, presentedKissRunOf as Wi, readArchitecture as Wn, AgentUnavailableError as Wo, withReviewLock as Wr, spawnServer as Wt, queueOptionLabel as X, findingAssessment as Xa, touchWorkspace as Xi, QUOTE_LIMITS as Xn, nameProblemText as Xo, removeWorktree as Xr, MAX_WORKSPACE_PORT as Xt, queueItemLabel as Y, currentGradeIn as Ya, summarise as Yi, ownersOf as Yn, deleteCollection as Yo, readMarker as Yr, DEFAULT_WORKSPACE_PORT as Yt, sectionOpen as Z, findingIn as Za, workspaceRevision as Zi, REPOSITORY_SCOPE as Zn, readCollections as Zo, requestJobStop as Zr, MIN_WORKSPACE_PORT as Zt, endRun as _, lifecycleChip as _a, PHASES as _i, observeReview as _n, DetachedHeadError as _o, removeNotification as _r, applyUpdate as _t, lineageIds as a, nextBaseline as aa, fetchHead as ai, cancelUpdate as an, statusLookup as ao, createArchitectureNotification as ar, retryableMiss as at, stopRun as b, lifecyclePillAction as ba, phasesFor as bi, reanalyseReview as bn, resolveBase as bo, unreadAround as br, agentDisplayName as bt, discardJob as c, outcomeStanding as ca, RUN_RECORD_RETENTION_MS as ci, parkedUpdateRefusal as cn, SEVERITIES as co, eventName as cr, activateQueued as ct, startKissJob as d, readOutcomes as da, endedAt as di, askCheckout as dn, objectWithAnyOf as do, markRead as dr, settleQueue as dt, analysedAt as ea, findExistingReview as ei, statedWorkspacePort as en, isGradeFor as eo, writeJsonAtomically as er, withWriteLock as es, statusPillLabel as et, isDriving as f, sameSha as fa, fail as fi, findingsChanged as fn, describeAuthorship as fo, markReadForReview as fr, RUNNER_KINDS as ft, completeRun as g, isLifecycle as ga, saveJob as gi, failureOf as gn, originRemote as go, readStateOf as gr, spawnRunner as gt, beginRun as h, activityLabel as ha, pruneJobResidue as hi, runningJobs as hn, resolveTarget as ho, readNotification as hr, runDetached as ht, deleteReview as i, lastBaseline as ia, reviewedShaOf as ii, RefreshUnavailableError as in, sourcePhrase as io, categoryOf as ir, openDestination as it, anythingRunning as j, isIssueOutstanding as ja, indexReviewGroups as ji, BUILD_VERSION as jn, writeAgentPreference as jo, chatConversationSection as jr, isRequestId as jt, LIST_SECTIONS as k, readQueue as ka, groupByLineage as ki, telemetryUploadConsent as kn, clearAgentPreference as ko, agentEnvOf as kr, forgetAskRequest as kt, kissAgentId as l, parseOutcomeSnapshot as la, allJobs as li, recheckConversation as ln, asString$1 as lo, listNotifications as lr, compactQueue as lt, RUN_KINDS as m, activityAttributes as ma, loadJob as mi, liveUpdateFor as mn, kissOutcome as mo, pruneNotifications as mr, cliEntry as mt, MCP_TOOL_NAMES as n, REVIEWER_OUTCOMES as na, checkReview as ni, COMMIT_REVIEW_CANNOT_UPDATE as nn, promptGrade as no, branchOf as nr, isDelivered as nt, liveJobsFor as o, outcomeDefinition as oa, forgeResolver as oi, cancellableHere as on, wasReassessed as oo, createPrState as or, lineageKeysFor as ot, track as p, LIFECYCLES as pa, isTerminal as pi, UpdateAlreadyRunningError as pn, WITHHELD_REASON as po, moveIds as pr, RUNNER_MARKER as pt, omittedText as q, assessmentLookup as qa, reviewedCommit as qi, storedScopes as qn, createCollection as qo, holdWorktree as qr, workspaceUrl as qt, deleteLineage as r, appendOutcome as ra, followedBranch as ri, FETCH_TIMEOUT_MS as rn, reassessIn as ro, subjectOf as rr, missedDelivery as rt, wasBlocked as s, outcomeLabel as sa, fillFileUrlTemplate as si, mergeUpdateInto as sn, followUpFindingId as so, createPrUpdate as sr, settleCollections as st, MCP_SERVER_INFO_NAME as t, analysisSnapshot as ta, checkCodeFreshness as ti, writePortPreference as tn, isOffered as to, announceJob as tr, STORE_ROOT as ts, deliver as tt, recordKissRun as u, parseOutcomes as ua, attemptIdOf as ui, updateReview as un, extractJsonText as uo, markAllRead as ur, queueForReview as ut, heldRuns as v, lifecycleItemLabel as va, isLiveJob as vi, prepareReview as vn, TargetError as vo, retireNotification as vr, modelProvenanceOf as vt, unsupportedReason as w, sectionOf as wa, driverGone as wi, readEvents as wn, git as wo, ASK_REREAD_CEILING_MS as wr, findingRefs as wt, batchIdentity as x, lifecyclePillLabel as xa, progressSteps as xi, runJob as xn, AmbiguousRefError as xo, unreadCount as xr, humanizeModelId as xt, reportRun as y, lifecycleName$1 as ya, isTerminalJobPhase as yi, settleReview as yn, isCommitReview as yo, toneOf as yr, provenanceDetailLines as yt, collectionsLine as z, recommendationsOf as za, loadWorkspace as zi, formatDuration as zn, parkedReason as zo, escapeHtml as zr, ensureServer as zt };