prreviewbuddy 0.43.0 → 0.44.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.44.0
+
+**`prreviewbuddy review --queue` puts the reviews it starts on your review queue.** Add `--queue`
+to any review command, such as `prreviewbuddy review --pr <url> <url> --queue`, and each pull request's
+review goes on your review queue as soon as the review exists, without waiting for the analysis to
+finish. The cards are already waiting under **Queue** on the Reviews page while they are still being
+analysed, and a Reviews page you have open picks them up by itself. It works for one pull request or
+several, for `--branch` and `--commit`, and beside `--fresh`, `--update` and `--reanalyse`. A review
+already in the queue keeps its place. A review you have marked as reviewed is left out and keeps its
+status: the command says so, and you can move it back to In progress on the page to queue it. When
+you review several pull requests at once, the summary at the end lists what is in your queue, and
+they are queued in the order their reviews were created, which isn't always the order you typed
+them. Without `--queue`, nothing changes.
+
+**The review queue no longer loses changes made at the same time.** With `--queue` there are two
+things writing your review queue, the terminal and the Reviews page, and a change made in one while
+the other was saving could be lost, or in the worst case empty the queue. Queue changes now happen
+one at a time across every process on your machine, and the queue file is never left half-written.
+
+**Copy has moved to the top of issue and question cards.** The button that copies a finding as
+Markdown, ready to paste into a GitHub comment, used to sit at the bottom of the card beside
+**Dismiss** and **Mark answered**. It is now a copy icon at the right of the card's title, because it
+copies the whole finding, and hovering it says **Copy finding** or **Copy question**. After you
+click it, it says **Copied** for a moment. The bottom of a card now holds only the actions that
+change your review: **Investigate**, **Dismiss** and **Mark answered**.
+
+**A clearer error when a pull request comes after another flag.** `prreviewbuddy review --pr <url>
+--queue <url>` used to answer with a message about the old command syntax. It now says which flag
+the second URL came after, and to put all the URLs together after `--pr`.
+
 ## 0.43.0
 
 **A review page shows when its pull request has merged or closed.** The **Merged** and **PR closed**

package/dist/{delete_review-DPRL5IPt.js → delete_review-BWMmO81Q.js}

@@ -3802,6 +3802,133 @@ 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;
+}
+function processAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/queue.ts
 /**
 * The review queue: the set the reviewer is working through now, in the order they chose.
@@ -3823,6 +3950,11 @@ function doneVerb(counts) {
 */
 var QUEUE_PATH = join(STORE_ROOT, "queue.json");
 /**
+* The name the queue is locked under. Reviews are locked under their UUIDs in the same directory,
+* so a plain word cannot collide with one.
+*/
+var QUEUE_LOCK = "queue";
+/**
 * An object rather than a bare array, because an array is the one JSON shape that cannot grow a
 * sibling field, and "when was this queued" is a plausible second column.
 *
@@ -3849,31 +3981,65 @@ function readQueue() {
 	}
 }
 /**
-* Store a queue, and say what was stored.
+* 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`).
 *
-* The return is what landed on disk, which is not necessarily what was handed in -- duplicates are
-* collapsed and the cap applies. Same contract as the prompt bank: the caller gets the list as
-* stored so a page can paint the truth rather than its own request.
+* 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.
 *
-* `null` on a write failure, and that is the point at which this stops resembling `preferences.ts`.
-* A pane width that fails to save costs one session and nothing depends on it. A queue entry that
-* fails to save is contradicted by a pill showing a count and by a button that navigates somewhere,
-* so the caller has to be able to tell the reviewer it did not happen.
+* `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 writeQueue(ids) {
-	const next = normalise(ids);
+function updateQueue(change) {
 	try {
-		mkdirSync(STORE_ROOT, { recursive: true });
-		writeFileSync(QUEUE_PATH, `${JSON.stringify({
-			version: VERSION,
-			ids: next
-		}, null, 2)}\n`);
-		return next;
+		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(ids);
+	mkdirSync(STORE_ROOT, { recursive: true });
+	const stored = {
+		version: VERSION,
+		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
@@ -3881,9 +4047,7 @@ function writeQueue(ids) {
 * and it would do it without ever saying so.
 */
 function queueAdd(id) {
-	const current = readQueue();
-	if (current.includes(id)) return current;
-	return writeQueue([...current, id]);
+	return updateQueue((current) => current.includes(id) ? null : [...current, id]);
 }
 /**
 * Append several, in the order given, for the reviews index's bulk bar.
@@ -3894,24 +4058,20 @@ function queueAdd(id) {
 * named in `full`, and the caller has something true to say about it.
 */
 function queueAddMany(ids) {
-	const current = readQueue();
-	const fresh = ids.filter((id, at) => !current.includes(id) && ids.indexOf(id) === at);
-	const room = Math.max(0, 50 - current.length);
-	const full = fresh.slice(room);
-	if (fresh.length <= full.length) return {
-		queue: current,
-		full
-	};
-	const queue = writeQueue([...current, ...fresh.slice(0, room)]);
+	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) {
-	const current = readQueue();
-	if (!current.includes(id)) return current;
-	return writeQueue(current.filter((queued) => queued !== id));
+	return updateQueue((current) => current.includes(id) ? current.filter((queued) => queued !== id) : null);
 }
 /**
 * The invariant, as one named thing: the queue holds unfinished work only.
@@ -4042,119 +4202,6 @@ function saveWorkspace(workspace) {
 		writeWorkspace(workspace);
 	});
 }
-/** 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";
-	}
-}
 /**
 * Change a review as it is on disk now: read, change, write, with nothing able to run in between.
 *
@@ -7429,6 +7476,71 @@ function readIndexToken() {
 	return replacement;
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/queue_live.ts
+/**
+* The review queue as it relates to reviews that actually exist.
+*
+* `queue.ts` stores ids and must not learn to read the review store: `store.ts` imports it for the
+* prune, and the reverse import would close the cycle. Anything that has to ask both questions --
+* is this id queued, and is it a review -- lives here instead, which imports both and is imported by
+* neither. That used to be one function private to `http.ts`; the CLI's `--queue` needs the same
+* answers, and two copies of "which queued ids are still live" would drift.
+*/
+/**
+* Drop queued ids whose review has been deleted or pruned, and store the result if that changed it.
+*
+* `stored` is what the caller last saw, and is only a shortcut: when every id in it is live there is
+* nothing to do. Otherwise the compaction is made against the queue as it is under the lock, not
+* against `stored`, so an id somebody queued since `stored` was read is not dropped by writing an
+* older list back.
+*
+* Falls back to what was handed in on a write failure: a stale id in the answer is a card the page
+* cannot draw, which it already tolerates, and is better than refusing an Add over it.
+*/
+function compactQueue(stored) {
+	if (stored.every(isLive)) return stored;
+	return updateQueue((current) => livePart(current)) ?? stored;
+}
+/**
+* Put one review on the queue, the way the index's Add does, and say how that went.
+*
+* **A completed review is left out**, not queued and not reopened. The queue holds unfinished work
+* only -- `dequeueOnComplete` is the other half of that rule -- and quietly moving somebody's review
+* back to In progress because a command mentioned it is a status change nobody asked for.
+*
+* Already queued is `already`, not a move: the same rule `queueAdd` keeps, for the same reason.
+*
+* Compacted before adding, for the reason `addMany` in `http.ts` gives: a review deleted since it
+* was queued would otherwise hold a place, and a live review could be refused as "full" by it.
+*/
+function queueForReview(id) {
+	const workspace = loadWorkspace(id);
+	if (!workspace) return "gone";
+	if (workspace.completedAt !== void 0) return "complete";
+	let result = "added";
+	return updateQueue((current) => {
+		const live = current.filter(isLive);
+		const unchanged = live.length === current.length ? null : live;
+		if (live.includes(id)) {
+			result = "already";
+			return unchanged;
+		}
+		if (live.length >= 50) {
+			result = "full";
+			return unchanged;
+		}
+		return [...live, id];
+	}) === null ? "unsaved" : result;
+}
+function isLive(id) {
+	return loadWorkspace(id) !== null;
+}
+/** The queue without its deleted reviews, or null when there are none to drop. */
+function livePart(queue) {
+	const live = queue.filter(isLive);
+	return live.length === queue.length ? null : live;
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/relative_time.ts
 /**
 * Relative time, in the one wording this product uses.
@@ -12515,4 +12627,4 @@ function lineageIds(id) {
 	return [.../* @__PURE__ */ new Set([id, ...lineage.map((review) => review.id)])];
 }
 //#endregion
-export { ensureServer as $, reviewedRepositories as $t, createPrState as A, AGENT_IDS as An, loadJob as At, toneOf as B, followedRefName as Bt, readEvents as C, resolveAgent as Cn, checkReview as Ct, announceJob as D, writeAgentPreference as Dn, endedAt as Dt, telemetryUploadConsent as E, readAgentPreference as En, allJobs as Et, markAllRead as F, AgentCancelledError as Fn, progressSteps as Ft, MANAGED_ROOT as G, lineagePosition as Gt, withUsageRecorded as H, indexReviewGroups as Ht, markRead as I, AgentUnavailableError as In, purposeOf as It, modelHelpLines as J, mutateWorkspace as Jt, readMarker as K, loadWorkspace as Kt, pruneNotifications as L, clearClaim as Lt, eventName as M, agentById as Mn, PHASES as Mt, headline as N, agentFor as Nn, isLiveJob as Nt, branchOf as O, CONFIG_PATH as On, fail as Ot, listNotifications as P, detectAgents as Pn, phasesFor as Pt, clearServerRecord as Q, reviewedCommit as Qt, readNotification as R, driverGone as Rt, startJob as S, git as Sn, checkCodeFreshness as St, recordTelemetryUploadConsent as T, clearAgentPreference as Tn, reviewedShaOf as Tt, EXPLAIN_SIMPLY_PROMPT as U, latestKissRun as Ut, unreadCount as V, groupByLineage as Vt, ReviewBeingDeletedError as W, lineageKeyFor as Wt, readIndexToken as X, previousKissResult as Xt, relativeTime as Y, positionInLineage as Yt, bootstrapUrl as Z, recentWorkspaces as Zt, agentEnvOf as _, processDiscussion as _n, claimRequestUrl as _t, wasBlocked as a, queueAdd as an, workspaceUrl as at, reanalyseReview as b, displayRef as bn, remoteHost as bt, RefreshUnavailableError as c, queueStamp as cn, PACKAGE_NAME as ct, refreshPrContext as d, doneVerb as dn, MAX_WORKSPACE_PORT as dt, summarise as en, readServerRecord as et, isUnchanged as f, isIssueOutstanding as fn, MIN_WORKSPACE_PORT as ft, runningJobs as g, reviewerDispositions as gn, writePortPreference as gt, liveUpdateFor as h, questionsOutstanding as hn, statedWorkspacePort as ht, liveJobsFor as i, dequeueOnComplete as in, stopServer as it, createPrUpdate as j, DEFAULT_AGENT_ID as jn, saveJob as jt, subjectOf as k, STORE_ROOT as kn, isTerminal as kt, mergeUpdateInto as l, readQueue as ln, feedbackUrl as lt, UpdateAlreadyRunningError as m, issuesOutstanding as mn, resolveWorkspacePort as mt, deleteReview as n, workspaceRevision as nn, serverEntryExists as nt, discardJob as o, queueAddMany as on, writeServerRecord as ot, askCheckout as p, isQuestionOutstanding as pn, parseWorkspacePort as pt, removeWorktree as q, matchingWorkspaceIds as qt, lineageIds as r, workspaceStamps as rn, spawnServer as rt, FETCH_TIMEOUT_MS as s, queueRemove as sn, BUILD_VERSION as st, deleteLineage as t, touchWorkspace as tn, reviewsUrl as tt, updateReview as u, writeQueue as un, DEFAULT_WORKSPACE_PORT as ut, recordKissRun as v, describeAuthorship as vn, forgeResolver as vt, record as w, resolveModel as wn, followedBranch as wt, runJob as x, isCommitReview as xn, fillFileUrlTemplate as xt, startKissJob as y, resolveTarget as yn, forgeFor as yt, removeNotification as z, isClaimed as zt };
+export { bootstrapUrl as $, recentWorkspaces as $t, createPrState as A, STORE_ROOT as An, fail as At, toneOf as B, driverGone as Bt, readEvents as C, git as Cn, fillFileUrlTemplate as Ct, announceJob as D, readAgentPreference as Dn, reviewedShaOf as Dt, telemetryUploadConsent as E, clearAgentPreference as En, followedBranch as Et, markAllRead as F, detectAgents as Fn, isLiveJob as Ft, MANAGED_ROOT as G, latestKissRun as Gt, withUsageRecorded as H, followedRefName as Ht, markRead as I, AgentCancelledError as In, phasesFor as It, modelHelpLines as J, loadWorkspace as Jt, readMarker as K, lineageKeyFor as Kt, pruneNotifications as L, AgentUnavailableError as Ln, progressSteps as Lt, eventName as M, DEFAULT_AGENT_ID as Mn, loadJob as Mt, headline as N, agentById as Nn, saveJob as Nt, branchOf as O, writeAgentPreference as On, allJobs as Ot, listNotifications as P, agentFor as Pn, PHASES as Pt, readIndexToken as Q, previousKissResult as Qt, readNotification as R, purposeOf as Rt, startJob as S, isCommitReview as Sn, remoteHost as St, recordTelemetryUploadConsent as T, resolveModel as Tn, checkReview as Tt, EXPLAIN_SIMPLY_PROMPT as U, groupByLineage as Ut, unreadCount as V, isClaimed as Vt, ReviewBeingDeletedError as W, indexReviewGroups as Wt, compactQueue as X, mutateWorkspace as Xt, relativeTime as Y, matchingWorkspaceIds as Yt, queueForReview as Z, positionInLineage as Zt, agentEnvOf as _, reviewerDispositions as _n, statedWorkspacePort as _t, wasBlocked as a, workspaceStamps as an, spawnServer as at, reanalyseReview as b, resolveTarget as bn, forgeResolver as bt, RefreshUnavailableError as c, queueAddMany as cn, writeServerRecord as ct, refreshPrContext as d, readQueue as dn, feedbackUrl as dt, reviewedCommit as en, clearServerRecord as et, isUnchanged as f, doneVerb as fn, DEFAULT_WORKSPACE_PORT as ft, runningJobs as g, questionsOutstanding as gn, resolveWorkspacePort as gt, liveUpdateFor as h, issuesOutstanding as hn, parseWorkspacePort as ht, liveJobsFor as i, workspaceRevision as in, serverEntryExists as it, createPrUpdate as j, AGENT_IDS as jn, isTerminal as jt, subjectOf as k, CONFIG_PATH as kn, endedAt as kt, mergeUpdateInto as l, queueRemove as ln, BUILD_VERSION as lt, UpdateAlreadyRunningError as m, isQuestionOutstanding as mn, MIN_WORKSPACE_PORT as mt, deleteReview as n, summarise as nn, readServerRecord as nt, discardJob as o, dequeueOnComplete as on, stopServer as ot, askCheckout as p, isIssueOutstanding as pn, MAX_WORKSPACE_PORT as pt, removeWorktree as q, lineagePosition as qt, lineageIds as r, touchWorkspace as rn, reviewsUrl as rt, FETCH_TIMEOUT_MS as s, queueAdd as sn, workspaceUrl as st, deleteLineage as t, reviewedRepositories as tn, ensureServer as tt, updateReview as u, queueStamp as un, PACKAGE_NAME as ut, recordKissRun as v, processDiscussion as vn, writePortPreference as vt, record as w, resolveAgent as wn, checkCodeFreshness as wt, runJob as x, displayRef as xn, forgeFor as xt, startKissJob as y, describeAuthorship as yn, claimRequestUrl as yt, removeNotification as z, clearClaim as zt };