prreviewbuddy 0.93.0 → 0.95.2

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

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