prreviewbuddy 0.56.0 → 0.59.38

package/dist/{delete_review-C5bz0Pts.js → delete_review-D59T6NBn.js}

@@ -1,5 +1,5 @@
-import { basename, delimiter, join, resolve, sep } from "node:path";
-import { execFile, spawn } from "node:child_process";
+import { basename, delimiter, dirname, join, resolve, sep } from "node:path";
+import { execFile, execFileSync, spawn } from "node:child_process";
 import { accessSync, appendFileSync, closeSync, constants, existsSync, linkSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { homedir, hostname, tmpdir } from "node:os";
@@ -1797,7 +1797,8 @@ async function git(cwd, args, options = {}) {
 			cwd,
 			encoding: "utf8",
 			maxBuffer: MAX_BUFFER$1,
-			...options.timeoutMs ? { timeout: options.timeoutMs } : {}
+			...options.timeoutMs ? { timeout: options.timeoutMs } : {},
+			...options.signal ? { signal: options.signal } : {}
 		});
 		return stdout;
 	} catch (error) {
@@ -1806,6 +1807,30 @@ async function git(cwd, args, options = {}) {
 		throw new GitError(args, err.stderr ?? String(error));
 	}
 }
+/**
+* The same, blocking, for the few local questions asked where nothing can wait: which repository a
+* path belongs to, asked while naming where its records live. Read-only plumbing only; what it may
+* run is pinned by `git_sync.test.ts`.
+*/
+function gitSync(cwd, args) {
+	try {
+		return execFileSync("git", [
+			"-c",
+			"core.quotePath=false",
+			...args
+		], {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+	} catch (error) {
+		throw new GitError(args, String(error.stderr ?? error));
+	}
+}
 /** True when the ref resolves. Used to check a base candidate without treating absence as failure. */
 async function refExists(cwd, ref) {
 	try {
@@ -2805,19 +2830,16 @@ async function peel(repoPath, named) {
 async function resolveTarget(input) {
 	const root = await repositoryRoot(input.repoPath);
 	if (input.commitRef) return commitTarget(root, input.commitRef);
-	try {
-		if (input.base) await verifyBase(root, input.base);
-		else await verifyDefaultBase(root);
-	} catch (error) {
-		if (!(error instanceof AmbiguousRefError)) throw error;
-		const head = await headToMeasure(root, input);
-		throw head ? await withReviewRanges(error, root, head) : error;
-	}
+	const base = input.base;
+	const head = () => headToMeasure(root, input);
+	if (base) await verifyOrMeasure(root, () => verifyBase(root, base), head);
+	else if (!input.prUrl) await verifyOrMeasure(root, () => verifyDefaultBase(root), head);
 	const named = input.base ? { base: input.base } : {};
 	if (input.prUrl) {
 		if (!input.resolveRequest) throw new TargetError(`${input.prUrl} is a pull request, but nothing here can look one up. Check the request out locally and review the branch instead.`);
 		const request = await input.resolveRequest(root, input.prUrl);
 		await ensureCommitPresent(root, request.headSha, request.headRef);
+		if (!input.base && !request.baseRef) await verifyOrMeasure(root, () => verifyDefaultBase(root), async () => request.headSha);
 		const resolvedBase = input.base ? void 0 : await resolvePullRequestBase(root, request);
 		return {
 			originRepoPath: root,
@@ -2968,6 +2990,21 @@ async function verifyBase(root, base) {
 * than handed to git as typed, because a name that is itself ambiguous would be settled by git's own
 * preference, which is the guess this module refuses to make.
 */
+/**
+* Run a base check, and give an ambiguity refusal the ranges each choice would review.
+*
+* Measured only for the refusal: which commits each choice would review is the one thing that
+* turns "name the one you mean" into a decision the reviewer can make.
+*/
+async function verifyOrMeasure(root, check, head) {
+	try {
+		await check();
+	} catch (error) {
+		if (!(error instanceof AmbiguousRefError)) throw error;
+		const measured = await head();
+		throw measured ? await withReviewRanges(error, root, measured) : error;
+	}
+}
 async function headToMeasure(root, input) {
 	if (input.prUrl) return void 0;
 	if (!input.branchRef) return "HEAD";
@@ -6299,7 +6336,7 @@ function sanitisePullRequest(value) {
 	};
 	const title = typeof value.title === "string" ? value.title.trim() : "";
 	if (title) pr.title = title.slice(0, 200);
-	if (typeof value.body === "string" && value.body.trim()) pr.body = value.body;
+	if (typeof value.body === "string") pr.body = value.body.trim() ? value.body : "";
 	const headSha = label(value.headSha);
 	if (headSha) pr.headSha = headSha;
 	const headRef = label(value.headRef);
@@ -6471,8 +6508,17 @@ function authStatusArgs(host) {
 *
 * `host` defaults for the one caller that has no repository in hand yet. Both callers that are
 * about to make a real request pass the host they are about to make it against.
+*
+* **A directory that is not there is not a missing `gh`, and is thrown rather than answered.** Node
+* reports a spawn into a missing `cwd` as `ENOENT`, exactly as it reports a missing executable, so
+* without this check a review whose checkout had been deleted read as "`gh` is not installed". The
+* watcher takes that verdict as true of every request reached the same way, and one stale checkout
+* then silenced every other check for the rest of the pass. Neither verdict this function returns is
+* about one directory, so it says neither: the caller gets a failure that belongs to the one
+* review whose checkout it is.
 */
 async function ghAvailable(cwd, env, host = "github.com") {
+	if (!existsSync(cwd)) throw new GhError(`The checkout at ${cwd} no longer exists.`);
 	try {
 		await run(["--version"], cwd, env);
 	} catch {
@@ -6947,7 +6993,15 @@ function readHeadSha(raw) {
 	};
 }
 async function headOf(repo, number, env, cwd) {
-	const availability = await ghAvailable(cwd, env, repo.host);
+	let availability;
+	try {
+		availability = await ghAvailable(cwd, env, repo.host);
+	} catch (error) {
+		return {
+			kind: "failed",
+			detail: error.message
+		};
+	}
 	if (!availability.ok) return {
 		kind: availability.kind,
 		cli: availability.cli
@@ -7542,6 +7596,15 @@ function stopServer() {
 		detail: `Stopped the workspace server (pid ${record.pid}, port ${record.port}). Open reviews are no longer served; running a review starts it again.`
 	};
 }
+/**
+* Remove the record only if it is this process's. A server that is shutting down must not delete
+* the record of the one that is serving: a replacement stopped during a failed handover is signalled
+* just after the old server has written its own record back, and an unconditional delete there left
+* a live server with no record, which the next CLI start then could not find.
+*/
+function clearServerRecordOwnedBy(pid) {
+	if (readServerRecord()?.pid === pid) clearServerRecord();
+}
 function clearServerRecord() {
 	try {
 		unlinkSync(SERVER_RECORD);
@@ -7713,7 +7776,11 @@ async function ensureServer() {
 * the new file at the same path, which is the main reason anybody wants one.
 */
 function spawnServer() {
-	const child = spawn(process.execPath, [serverEntry()], {
+	return spawnDetached([serverEntry()]);
+}
+/** How `spawnServer` starts node, apart so a test can start something else exactly the same way. */
+function spawnDetached(args) {
+	const child = spawn(process.execPath, args, {
 		detached: true,
 		stdio: "ignore",
 		cwd: STORE_ROOT
@@ -7721,6 +7788,24 @@ function spawnServer() {
 	child.unref();
 	return child;
 }
+/**
+* Stop a replacement that never answered, and return only once it has gone.
+*
+* Waiting is the point. A replacement that bound but answered too slowly is a server like any other:
+* on SIGTERM it clears the record if the record is its own. Checking and deleting are two steps, so
+* a server that wrote its record back while that handler ran could lose it. Writing only after the
+* child has exited leaves nothing to race. SIGKILL after the grace, so a child that ignores the
+* signal cannot hold the restart open, or the port, for ever.
+*/
+async function stopChild(child, graceMs = 2e3) {
+	if (child.pid === void 0 || child.exitCode !== null || child.signalCode !== null) return;
+	child.ref();
+	const exited = new Promise((resolve) => child.once("exit", () => resolve()));
+	child.kill("SIGTERM");
+	if (await Promise.race([exited.then(() => true), setTimeout$1(graceMs).then(() => false)])) return;
+	child.kill("SIGKILL");
+	await exited;
+}
 /** Whether there is anything to start. The one foreseeable reason a restart cannot be attempted. */
 function serverEntryExists() {
 	return existsSync(serverEntry());
@@ -8007,6 +8092,65 @@ function explainAgentFailure(agent, detail, env, requestedModel) {
 	const hint = modelFailureHint(agent, detail, requestedModel);
 	return hint ? `${replaced} ${hint}` : replaced;
 }
+function endingPath(jobId) {
+	return jobPath(jobId).replace(/\.json$/, ".ending");
+}
+/**
+* Publish `wanted` unless an ending is already published, and say which ending stands, or null when
+* none can be read. Null is never a win for either side.
+*/
+function claimEnding(jobId, wanted) {
+	const path = endingPath(jobId);
+	mkdirSync(dirname(path), { recursive: true });
+	const draft = `${path}.${randomUUID()}.draft`;
+	writeFileSync(draft, wanted, { mode: 384 });
+	try {
+		linkSync(draft, path);
+		return wanted;
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		return readEnding(jobId);
+	} finally {
+		unlinkSync(draft);
+	}
+}
+function readEnding(jobId) {
+	try {
+		const text = readFileSync(endingPath(jobId), "utf8");
+		return text === "stop" || text === "commit" ? text : null;
+	} catch {
+		return null;
+	}
+}
+/** The page's half. True when the run will stop; false when it had already committed to saving. */
+function requestJobStop(jobId) {
+	return claimEnding(jobId, "stop") === "stop";
+}
+/** The driver's half, before anything is saved. False means a stop got there first. */
+function commitJob(jobId) {
+	return claimEnding(jobId, "commit") === "commit";
+}
+function jobStopRequested(jobId) {
+	return readEnding(jobId) === "stop";
+}
+function clearJobEnding(jobId) {
+	try {
+		unlinkSync(endingPath(jobId));
+	} catch {}
+}
+/**
+* Abort `controller` once a stop is requested, so the agent is killed while it works rather than
+* only refused at the commit. Returns the way to stop watching.
+*
+* Unref'd, so a terminal command is never kept alive by the watch alone once its review is over.
+*/
+function watchForStop(jobId, controller, intervalMs = 500) {
+	const timer = setInterval(() => {
+		if (jobStopRequested(jobId)) controller.abort();
+	}, intervalMs);
+	timer.unref();
+	return () => clearInterval(timer);
+}
 //#endregion
 //#region ../../packages/review-harness/src/workspace/worktree.ts
 /**
@@ -8096,6 +8240,21 @@ function readMarker(worktreePath) {
 	}
 }
 /**
+* Worktrees this process is using with no job record behind them: a mapping run's disposable
+* checkout. The sweep removes an unclaimed worktree git owns at once, whatever its age, so without
+* this it took one from under a run that lasted past the next sweep. Held in memory on purpose: a
+* server that dies releases every hold, and what it left behind is residue again.
+*/
+var held = /* @__PURE__ */ new Set();
+/** Hold `path` until the returned release is called. Take it before the worktree is created. */
+function holdWorktree(path) {
+	held.add(path);
+	return () => held.delete(path);
+}
+function isWorktreeHeld(path) {
+	return held.has(path);
+}
+/**
 * Delete one managed worktree, or explain why not.
 *
 * Two paths, and the difference between them is where the authority comes from.
@@ -9219,51 +9378,87 @@ var REVIEW_ATTENTIONS = [
 * 17KB of perfectly good JSON to 583 characters of prose in front of it, and there was nothing
 * wrong with that answer this function could not have read.
 *
-* Nothing found leaves the reply exactly as it came, so the parser above still reports on what it
-* was actually given rather than on an empty string this function invented.
+* The answer is the first value `isAnswer` accepts, which each caller says in the terms of its own
+* schema. When none is accepted the first value that parsed comes back, so the parser above still
+* reports the wrong shape in its own words. Nothing found at all leaves the reply exactly as it
+* came, so the parser reports on what it was actually given rather than on an empty string this
+* function invented.
 */
-function extractJsonText(raw) {
+function extractJsonText(raw, isAnswer) {
 	const text = raw.trim();
-	for (const match of text.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)) {
-		const inner = match[1].trim();
-		if ((inner.startsWith("{") || inner.startsWith("[")) && parses(inner)) return inner;
+	let first;
+	for (const candidate of jsonCandidates(text)) {
+		first ??= candidate.text;
+		if (isAnswer(candidate.value)) return candidate.text;
 	}
-	return firstJsonValue(text) ?? text;
+	return first ?? text;
 }
-/** Whether this is a whole JSON value, which is the only thing that makes a candidate an answer. */
-function parses(candidate) {
-	try {
-		JSON.parse(candidate);
-		return true;
-	} catch {
-		return false;
-	}
+/**
+* The shape check most callers want: an object carrying at least one of the fields its schema asks
+* for, holding something a reply could use. Every field these schemas name is text or a list, so
+* that is what counts: words, or an array. `{"summary": null}` or `{"summary": 42}` is not an answer,
+* and a complete one later in the reply still wins. Deliberately no deeper than that, because each
+* parser makes its own decision about a thin answer and reports it in its own words; this only has
+* to tell an answer from an example quoted before it.
+*/
+function objectWithAnyOf(...fields) {
+	return (value) => typeof value === "object" && value !== null && !Array.isArray(value) && fields.some((field) => usable(value[field]));
+}
+function usable(value) {
+	return typeof value === "string" && value.trim() !== "" || Array.isArray(value);
 }
 /**
-* The first slice of this text that is a whole JSON value.
+* Every whole JSON value in this text, in the order an answer is looked for: fenced ones first,
+* then each slice the scanner reads whole.
 *
 * Every `{` and `[` is tried in turn, because a brace in a sentence about code is not a rare thing
 * to find in a paragraph a model wrote before the answer. Balance alone would accept one, so each
-* candidate is parsed and the first that survives is the answer. For a reply that is only the
-* object, that is the first character and the loop ends immediately.
+* candidate is parsed and only one that survives is offered. For a reply that is only the object,
+* that is the first character.
+*
+* Parsing is not enough to be the answer, which is why the caller judges each one by its schema.
+* Prose that quotes `{"example": true}` before the real reply parses perfectly well, and taking it
+* made a usable answer fail downstream as the wrong shape. A value that was offered is skipped
+* whole, so an object nested inside a quoted example is not offered in its place.
 *
 * Strings are tracked because a brace inside one is a character rather than a nesting level, and
 * counting it would end the value early or never end it at all. Escapes are tracked because a
 * quote inside a string is the same problem one level down.
 */
-function firstJsonValue(text) {
+function* jsonCandidates(text) {
+	for (const match of text.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)) {
+		const inner = match[1].trim();
+		if (!inner.startsWith("{") && !inner.startsWith("[")) continue;
+		const value = parsed(inner);
+		if (value.ok) yield {
+			text: inner,
+			value: value.value
+		};
+	}
 	for (let start = 0; start < text.length; start += 1) {
 		const opener = text[start];
 		if (opener !== "{" && opener !== "[") continue;
 		const end = closingIndex(text, start, opener);
 		if (end === -1) continue;
 		const candidate = text.slice(start, end + 1);
-		try {
-			JSON.parse(candidate);
-			return candidate;
-		} catch {}
+		const value = parsed(candidate);
+		if (!value.ok) continue;
+		yield {
+			text: candidate,
+			value: value.value
+		};
+		start = end;
+	}
+}
+function parsed(candidate) {
+	try {
+		return {
+			ok: true,
+			value: JSON.parse(candidate)
+		};
+	} catch {
+		return { ok: false };
 	}
-	return null;
 }
 /** Where the value opened at `start` closes, or -1 if it never does. */
 function closingIndex(text, start, opener) {
@@ -10374,6 +10569,8 @@ var MOTIVATION_EVIDENCE_KINDS = [
 ];
 /** Ours, not the model's: what an unsupported claim is replaced with when a question remains. */
 var UNESTABLISHED_MOTIVATION = "It isn't clear why this change is needed.";
+/** Ours, not the model's: asked when a failed or unclear motive came with no question of its own. */
+var FALLBACK_INTENT_QUESTION = "What problem does this change solve, or what goal does it serve?";
 /** Stable, so "Mark answered" on it survives a reload like any other question's. */
 var INTENT_QUESTION_ID = "intent-motivation";
 /**
@@ -10561,6 +10758,26 @@ function withIntentQuestion(questions, motivation) {
 		category: "intent"
 	}];
 }
+/**
+* A finished analysis's motive, carried onto the description an update will show beside it.
+*
+* Commits pushed since show what changed, not why, so a motive is carried rather than re-asked.
+* But a `stated` one is a quote, and it is only true of the description it was found in. When the
+* author has edited that description since, the quote is looked for again, in the same words and by
+* the same check as at analysis time; one that is gone is no longer the author's stated reason and
+* becomes unclear, asking our question. An unchanged description, or a motive that never rested on
+* it, is carried exactly as it was.
+*/
+function carryMotivation(motivation, checkedAgainst, describedNow) {
+	if (motivation?.status !== "stated" || checkedAgainst === describedNow) return motivation;
+	if (isAuthorQuote(motivation.sourceQuote, describedNow)) return motivation;
+	return {
+		contractVersion: 1,
+		status: "unclear",
+		summary: UNESTABLISHED_MOTIVATION,
+		authorQuestion: FALLBACK_INTENT_QUESTION
+	};
+}
 /** The candidate checked and, when it ends unclear, its question filed. */
 function applyMotivation(result, candidate, authorDescription) {
 	const { motivation, correction } = verifyMotivation(candidate, authorDescription);
@@ -10666,8 +10883,10 @@ function parseReviewResponse(raw, authorDescription) {
 		...applied.correction ? { motivationCorrection: applied.correction } : {}
 	};
 }
+/** What tells this reply's answer from a JSON example quoted in the prose before it. */
+var REVIEW_ANSWER = objectWithAnyOf("summary", "recommendation", "issues", "nextSteps");
 function parseUnchecked(raw) {
-	const jsonText = extractJsonText(raw);
+	const jsonText = extractJsonText(raw, REVIEW_ANSWER);
 	let parsed;
 	try {
 		parsed = JSON.parse(jsonText);
@@ -11137,8 +11356,10 @@ var WORTHINESSES = [
 	"consider",
 	"leave"
 ];
+/** What tells this reply's answer from a JSON example quoted in the prose before it. */
+var KISS_ANSWER = objectWithAnyOf("assessment", "summary", "recommendations", "justifiedComplexity");
 function parseKissAnswer(raw) {
-	const jsonText = extractJsonText(raw);
+	const jsonText = extractJsonText(raw, KISS_ANSWER);
 	let parsed;
 	try {
 		parsed = JSON.parse(jsonText);
@@ -11175,14 +11396,24 @@ function optional(key, value) {
 * what makes it auditable. A polished summary with no basis a reader can check is a claim rather
 * than a recommendation. The trade-offs stay optional: some recommendations genuinely cost nothing. What fails is withheld and counted,
 * never padded or truncated, so the page can say that something came back incomplete.
+*
+* Counted against what came back, not against what survived the first filter: a recommendation
+* written as a bare string is still a recommendation the reader is not shown, and counting from the
+* filtered list made `["Remove the wrapper"]` read as a change with nothing to simplify. A
+* collection that is there but is not a list is one unreadable answer, counted as one, for the same
+* reason. Absent is not withheld: an answer with nothing to recommend may leave the field out, and
+* `null` is JSON's way of saying the same, so it is read as absent rather than as unreadable.
 */
 function normalizeRecommendations(value) {
-	if (!Array.isArray(value)) return {
+	if (value === void 0 || value === null) return {
 		kept: [],
 		withheld: 0
 	};
-	const entries = value.filter((item) => typeof item === "object" && item !== null);
-	const kept = entries.map((item, index) => {
+	if (!Array.isArray(value)) return {
+		kept: [],
+		withheld: 1
+	};
+	const kept = value.filter((item) => typeof item === "object" && item !== null).map((item, index) => {
 		const worthiness = WORTHINESSES.includes(item.commentWorthiness) ? item.commentWorthiness : void 0;
 		const gains = asStringArray(item.gains).map((gain) => gain.trim()).filter((gain) => gain !== "");
 		return {
@@ -11204,7 +11435,7 @@ function normalizeRecommendations(value) {
 	}).filter((rec) => rec.title !== "" && rec.gist !== "" && rec.simplerDirection !== "" && rec.evidence !== "" && rec.whyNotJustified !== "" && rec.locations.length > 0);
 	return {
 		kept,
-		withheld: entries.length - kept.length
+		withheld: value.length - kept.length
 	};
 }
 /**
@@ -11647,6 +11878,7 @@ var OPERATION_NAMES = {
 function eventName(notification) {
 	if (notification.kind === "pr-updated") return notification.source === "branch" ? "Branch updated" : "PR updated";
 	if (notification.kind === "pr-state") return notification.state === "merged" ? "PR merged" : "PR closed";
+	if (notification.kind === "architecture") return notification.outcome === "ready" ? "Map ready" : "Mapping failed";
 	return `${OPERATION_NAMES[notification.operation]} ${notification.outcome}`;
 }
 /**
@@ -11667,7 +11899,7 @@ function headline(notification) {
 * so adding the next kind is a compiler error here instead of a silently untinted toast there.
 */
 function toneOf(notification) {
-	return notification.kind === "analysis" ? notification.outcome : "updated";
+	return notification.kind === "analysis" || notification.kind === "architecture" ? notification.outcome : "updated";
 }
 var OPERATIONS = [
 	"review",
@@ -11721,6 +11953,15 @@ function createPrState(input, now = Date.now()) {
 		createdAt: now
 	});
 }
+/** Record that mapping a repository or a part ended. Same `wx` contract: the id names the run. */
+function createArchitectureNotification(input, now = Date.now()) {
+	return create({
+		version: 1,
+		kind: "architecture",
+		...input,
+		createdAt: now
+	});
+}
 function create(record) {
 	if (!ID.test(record.id)) return null;
 	try {
@@ -11785,8 +12026,9 @@ function unreadCount() {
 /**
 * Mark these read, and say how many changed.
 *
-* Only ever by something the reviewer did to the notification itself: opening it, or one of the two
-* mark buttons. Opening the review it points at is not the same act and does not come through here.
+* Read means the reviewer has been where it points, not that they have dealt with what it said: by
+* opening it, by one of the two mark buttons, or by opening its review any other way (see
+* `markReadForReview`). Only `readAt` changes; the record and its history stay as they were.
 */
 function markRead(ids, now = Date.now()) {
 	let changed = 0;
@@ -11803,6 +12045,16 @@ function markRead(ids, now = Date.now()) {
 	}
 	return changed;
 }
+/**
+* Every unread notification about this review, marked read because the review has been opened.
+*
+* An unread notification is a pointer back to a review, and once the reviewer is looking at that
+* review the pointer has done its job; left unread it is badge noise. Idempotent, so two tabs opening
+* the same review end with it read and nothing else, and it creates nothing.
+*/
+function markReadForReview(reviewId, now = Date.now()) {
+	return markRead(listNotifications().filter((notification) => notification.reviewId === reviewId && notification.readAt === void 0).map((notification) => notification.id), now);
+}
 function markAllRead(now = Date.now()) {
 	return markRead(listNotifications().filter((notification) => notification.readAt === void 0).map((notification) => notification.id), now);
 }
@@ -11848,6 +12100,7 @@ function isNotification(value) {
 	if (record.kind === "analysis") return OPERATIONS.includes(record.operation) && OUTCOMES.includes(record.outcome);
 	if (record.kind === "pr-updated") return typeof record.headSha === "string" && typeof record.detail === "string" && (record.source === void 0 || record.source === "branch");
 	if (record.kind === "pr-state") return (record.state === "merged" || record.state === "closed") && typeof record.headSha === "string";
+	if (record.kind === "architecture") return OUTCOMES.includes(record.outcome) && (record.part === void 0 || record.part === true);
 	return false;
 }
 //#endregion
@@ -11864,8 +12117,7 @@ function isNotification(value) {
 *
 * The record is the event. The Notifications page and the workspace's toasts both read it. Any
 * delivery that has to be pushed rather than read belongs here, after `createNotification`, and only
-* for a record this call created, which carries the once-only guarantee over to it for free. Desktop
-* delivery is written that way and parked outside the product: see `desktop_preference.ts`.
+* for a record this call created, which carries the once-only guarantee over to it for free.
 *
 * Never throws. This runs on the success path of a review that has already been saved, and the
 * accounting must not break the thing it accounts for.
@@ -12294,9 +12546,17 @@ async function runJob(workspaceId, runners = {}, reviewType = "standard", option
 		};
 	});
 	if (isBusy(started)) throw busyReason(workspaceId, reviewType);
+	clearJobEnding(started.jobId);
+	const controller = new AbortController();
+	const outer = options.signal;
+	if (outer?.aborted) controller.abort();
+	outer?.addEventListener("abort", () => controller.abort(), { once: true });
+	const unwatch = watchForStop(started.jobId, controller);
 	try {
-		return await drive(started.jobId, workspaceId, runners, started.claim.claim.holder, options.signal);
+		return await drive(started.jobId, workspaceId, runners, started.claim.claim.holder, controller.signal);
 	} finally {
+		unwatch();
+		clearJobEnding(started.jobId);
 		started.claim.release();
 	}
 }
@@ -12458,6 +12718,8 @@ async function drive(jobId, workspaceId, runners, driver, signal) {
 		const payload = await runAnalysisFor(job, workspaceId, runners, signal, (model) => {
 			observedModel = model;
 		});
+		signal?.throwIfAborted();
+		if (!commitJob(job.id)) throw new AgentCancelledError("Cancelled from the workspace page.");
 		if (job.reviewType === "kiss") await applyKiss(job, workspaceId, payload, observedModel);
 		else await applyGuide(job, workspaceId, payload, observedModel);
 		job = update(job, "done");
@@ -12752,6 +13014,126 @@ async function runProvenanceOf(job, observedModel) {
 	};
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/assistant_runs.ts
+var RUN_KINDS = ["ask", "diagram"];
+var runs = /* @__PURE__ */ new Map();
+function keyOf(workspaceId, kind) {
+	return `${workspaceId}:${kind}`;
+}
+/**
+* Start a run, or learn that one is already going.
+*
+* One call rather than a check followed by a start, so there is no gap between them for a second
+* request to fall through. The existing run comes back rather than a bare refusal because the
+* caller's next move is to show it, not to report an error.
+*
+* A stopped run gives up its place at once, though its handler may still be unwinding. Stop is
+* over for the reviewer when it answers, and the page reopens Ask then. A stopped run can keep
+* nothing, and `endRun` leaves a newer run alone, so the two cannot collide. An answered run still
+* holds its place until it is saved, or the next question would be asked without it.
+*/
+function beginRun(workspaceId, kind, detail, now = Date.now()) {
+	const key = keyOf(workspaceId, kind);
+	const existing = runs.get(key);
+	if (existing && existing.state !== "stopped") return { alreadyRunning: existing };
+	const controller = new AbortController();
+	const run = {
+		workspaceId,
+		kind,
+		question: detail.question ?? null,
+		sectionId: detail.sectionId,
+		...detail.drawing ? { drawing: detail.drawing } : {},
+		startedAt: now,
+		signal: controller.signal,
+		state: "running",
+		controller
+	};
+	runs.set(key, run);
+	return { run };
+}
+/** Null for a stopped run as well: it is over for the page, whatever its handler is still doing. */
+function reportRun(workspaceId, kind) {
+	const run = runs.get(keyOf(workspaceId, kind));
+	if (!run || run.state === "stopped") return null;
+	return {
+		question: run.question,
+		sectionId: run.sectionId,
+		...run.drawing ? { drawing: run.drawing } : {},
+		startedAt: run.startedAt
+	};
+}
+/**
+* The reviewer pressed Stop.
+*
+* Idempotent: a second press, a press after the answer landed, and a press with nothing running are
+* all harmless and all answer false. True only when this call is the one that stopped the run.
+*/
+function stopRun(workspaceId, kind) {
+	const run = runs.get(keyOf(workspaceId, kind));
+	if (!run || run.state !== "running") return false;
+	run.state = "stopped";
+	run.controller.abort();
+	return true;
+}
+/**
+* The agent answered. Call this in the same continuation that received the answer, before anything
+* else is awaited, so a Stop handled in between cannot slip ahead of an answer that had already won.
+*
+* False when Stop got there first, and then the answer must not be kept however complete it is.
+*/
+function completeRun(run) {
+	const held = run;
+	if (held.state !== "running") return false;
+	held.state = "completed";
+	return true;
+}
+/**
+* The run is over, whichever way. Removes this run and only this one: by the time a slow handler
+* gets here a newer run of the same kind may have begun, and it is not this handler's to end.
+*/
+function endRun(run) {
+	const key = keyOf(run.workspaceId, run.kind);
+	if (runs.get(key) === run) runs.delete(key);
+}
+/**
+* Whether any question or drawing is still going here, or has answered and is being saved.
+*
+* A stopped run does not count: it can keep nothing, so a restart while its handler unwinds loses
+* nothing either. `server_work` asks this, because a restart ends the agent child with the process.
+*/
+function holdsLiveRun() {
+	for (const run of runs.values()) if (run.state !== "stopped") return true;
+	return false;
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/server_work.ts
+/**
+* Whether this server process is driving any review work of its own.
+*
+* A restart ends this process, and everything a page asks an agent for runs *inside* it: a review,
+* an update, a KISS review, a map, a Buddy AI answer or drawing. A restart during any of them loses
+* that work, so each is counted here: the background ones through `track`, and the assistant's runs
+* through the registry that already holds each one until its answer is saved. A review driven from a terminal has its own
+* process and is untouched, which is exactly why this is a count kept here rather than a look at
+* the jobs on disk: `/revision`'s `live` is machine-wide, and refusing a restart because somebody
+* else's terminal is busy would be the control lying about what it costs.
+*
+* In memory on purpose. The question is "is this process busy", and a process cannot outlive its
+* own answer, so there is nothing to keep in a file and nothing that can go stale. A restart or a
+* crash resets it to the truth.
+*/
+var driving = 0;
+/** Count one piece of work for as long as it runs, however it ends. */
+function track(work) {
+	driving += 1;
+	return work.finally(() => {
+		driving -= 1;
+	});
+}
+function isDriving() {
+	return driving > 0 || holdsLiveRun();
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/kiss_run.ts
 /**
 * Starting a KISS run on a workspace that already exists.
@@ -12784,6 +13166,8 @@ async function recordKissRun(input) {
 	const sha = reviewedCommit(workspace);
 	if (!sha) throw new Error("This review does not record which commit it describes, so KISS cannot run on it.");
 	const agent = input.agentId ? agentById(input.agentId) : workspace.jobId ? agentById(agentIdOf(workspace.session)) : defaultAgent();
+	const sameAgent = !workspace.jobId || agent.id === agentIdOf(workspace.session);
+	const requestedModel = input.requestedModel ?? (sameAgent ? resolveModel({ review: workspace }) : null);
 	const started = await withReviewLock(workspace.id, () => {
 		const target = {
 			originRepoPath: workspace.repoPath,
@@ -12798,7 +13182,7 @@ async function recordKissRun(input) {
 			purpose: "review",
 			reviewType: "kiss",
 			audience: input.audience,
-			...input.requestedModel ? { requestedModel: input.requestedModel } : {}
+			...requestedModel ? { requestedModel } : {}
 		});
 		saveJob(job);
 		const run = startKissRun(workspace, {
@@ -12807,7 +13191,7 @@ async function recordKissRun(input) {
 			reviewedSha: sha,
 			promptVersion: "3",
 			agentId: agent.id,
-			...input.requestedModel ? { requestedModel: input.requestedModel } : {}
+			...requestedModel ? { requestedModel } : {}
 		});
 		mutateWorkspace(workspace.id, (current) => {
 			current.kissRuns = [...current.kissRuns ?? [], run];
@@ -12824,9 +13208,13 @@ async function recordKissRun(input) {
 * The lock is released before the analysis begins, exactly as `reanalyseReview` does, so a deletion
 * during the twenty minutes that follow is refused by the live job claim rather than made to wait
 * for it.
+*
+* Counted by `track` from the first await, so a restart is refused for the whole of the run rather
+* than only once a caller remembered to count it. Only the server calls this; the CLI records the
+* run and drives it in its own process.
 */
-async function startKissJob(input, runners = {}) {
-	return runJob((await recordKissRun(input)).workspaceId, runners, "kiss");
+function startKissJob(input, runners = {}) {
+	return track(recordKissRun(input).then((job) => runJob(job.workspaceId, runners, "kiss")));
 }
 //#endregion
 //#region ../../packages/review-harness/src/workspace/agent_env.ts
@@ -13045,10 +13433,12 @@ var QUESTION_STATUSES = [
 	"still-open",
 	"affected"
 ];
+/** What tells this reply's answer from a JSON example quoted in the prose before it. */
+var RECONCILIATION_ANSWER = objectWithAnyOf("findings", "newIssues", "newSections", "questions", "summary", "recommendation", "nextSteps");
 function parseReconciliationResult(raw, priorCount, options = {}) {
 	let parsed;
 	try {
-		parsed = JSON.parse(extractJsonText(raw));
+		parsed = JSON.parse(extractJsonText(raw, RECONCILIATION_ANSWER));
 	} catch {
 		return null;
 	}
@@ -13567,7 +13957,7 @@ function movable(fetched) {
 	};
 	copy("headSha");
 	copy("title");
-	copy("body");
+	if (typeof fetched.body === "string") updates.body = fetched.body;
 	copy("filesUrl");
 	copy("fileUrlTemplate");
 	copy("author");
@@ -13683,6 +14073,34 @@ var RefreshUnavailableError = class extends Error {};
 var FETCH_TIMEOUT_MS = 6e4;
 /** Said wherever an update is asked of a commit review. One sentence, so both surfaces agree. */
 var COMMIT_REVIEW_CANNOT_UPDATE = "This review is of one commit, and a commit cannot move, so there is nothing to bring it up to date with. To analyse the same commit again, reanalyse it instead.";
+/** What the notice says after a cancel, and what the terminal would print if it could cancel. */
+var UPDATE_CANCELLED = "The review is exactly as it was before the update began.";
+/**
+* The updates this process is driving, by job id, each with the means to end it.
+*
+* In memory, because only the process running the agent can stop it. An update started in a
+* terminal is in that process's map, not the server's, and Ctrl-C is how it ends; the page offers
+* Cancel only for an update this server holds (`cancellableHere`). An entry leaves the map the
+* moment the update commits to writing, so a cancel either stops it before anything is written or
+* finds nothing to stop. It can never land halfway through the write.
+*/
+var cancellers = /* @__PURE__ */ new Map();
+/** Whether this process can cancel the update with this job id. */
+function cancellableHere(jobId) {
+	return cancellers.has(jobId);
+}
+/**
+* Stop the update with this job id, if this process is still able to.
+*
+* Named by job rather than by review, so a press aimed at one update cannot end the next one.
+* False when it has finished, has begun writing, or runs somewhere else.
+*/
+function cancelUpdate(jobId) {
+	const controller = cancellers.get(jobId);
+	if (!controller || controller.signal.aborted) return false;
+	controller.abort();
+	return true;
+}
 /**
 * Computes and mutates the workspace in memory; does not persist.
 *
@@ -13700,30 +14118,55 @@ async function updateReview(workspace, runners = {}) {
 		} } : {}
 	});
 	runners.onStarted?.(held.job.id);
+	const controller = new AbortController();
+	cancellers.set(held.job.id, controller);
+	const { signal } = controller;
 	const current = () => loadJob(held.job.id) ?? held.job;
 	const step = (phase) => saveJob(advance(current(), phase));
 	try {
 		const fetchStartedAt = Date.now();
-		const outcome = await bringForward(workspace, runners, reviewedSha, held, step);
+		const outcome = await bringForward(workspace, runners, reviewedSha, held, step, signal);
+		if (signal.aborted) return cancelled(held, reviewedSha);
 		if (outcome.ok && !outcome.fetchFailed && outcome.toSha) workspace.headSeenAt = fetchStartedAt;
 		const ended = outcome.stop === "analysis-failed" ? fail(current(), outcome.message) : advance(current(), "done", outcome.message);
 		saveJob(ended);
 		announceJob(ended);
 		return outcome;
 	} catch (error) {
+		if (signal.aborted) return cancelled(held, reviewedSha);
 		const failed = fail(current(), error instanceof Error ? error.message : String(error));
 		saveJob(failed);
 		announceJob(failed);
 		throw error;
 	} finally {
+		cancellers.delete(held.job.id);
 		held.claim.release();
 	}
 }
-async function bringForward(workspace, runners, reviewedSha, held, step) {
-	const remote = await remoteHead(workspace);
+/**
+* The reviewer cancelled. Recorded as a stop, not a failure, so nothing announces it or offers a
+* retry, and answered as an outcome the page reports on the review it left untouched.
+*/
+function cancelled(held, reviewedSha) {
+	recordStop(loadJob(held.job.id) ?? held.job, held.claim.claim.holder);
+	return {
+		at: Date.now(),
+		ok: false,
+		message: UPDATE_CANCELLED,
+		stop: "cancelled",
+		fetchFailed: false,
+		moved: false,
+		fromSha: reviewedSha,
+		toSha: reviewedSha
+	};
+}
+async function bringForward(workspace, runners, reviewedSha, held, step, signal) {
+	const remote = await remoteHead(workspace, signal);
+	signal.throwIfAborted();
 	if (!remote.sha) return refuse(reviewedSha, remote.fetchFailed, noRemoteHeadMessage(workspace));
 	if (workspace.prContext) step("conversation");
 	const conversationOk = await reReadConversation(workspace, runners.runRefresh);
+	signal.throwIfAborted();
 	if (reviewedSha && !await commitPresent(workspace.repoPath, reviewedSha)) return settled(reviewedSha, remote.sha, remote.fetchFailed, conversationOk, "baseline-gone", BASELINE_GONE_MESSAGE);
 	if (!reviewedSha || reviewedSha === remote.sha) return settled(reviewedSha, remote.sha, remote.fetchFailed, conversationOk, "already-current", alreadyCurrentMessage(conversationOk));
 	step("context");
@@ -13734,9 +14177,10 @@ async function bringForward(workspace, runners, reviewedSha, held, step) {
 		if (error instanceof ReviewBeingDeletedError) throw error;
 		return settled(reviewedSha, remote.sha, remote.fetchFailed, conversationOk, "analysis-failed", "A checkout of the new commits could not be prepared, so nothing was reassessed.");
 	}
-	return reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, held.job.id);
+	signal.throwIfAborted();
+	return reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, held.job.id, signal);
 }
-async function reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, jobId) {
+async function reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, jobId, signal) {
 	const newHead = remote.sha;
 	let delta;
 	try {
@@ -13767,24 +14211,28 @@ async function reconcile(workspace, runners, reviewedSha, remote, conversationOk
 	let raw;
 	try {
 		const prompt = buildUpdatePrompt(workspace, delta, reviewedSha, newHead, worktreePath);
-		raw = runners.run ? await runners.run(prompt, worktreePath, agentEnvOf(workspace), onProgress, onObservedModel) : await runUpdate(workspace.id, prompt, worktreePath, workspace.repoPath, agentEnvOf(workspace), onProgress, requestedModel, onObservedModel);
+		raw = runners.run ? await runners.run(prompt, worktreePath, agentEnvOf(workspace), onProgress, onObservedModel, signal) : await runUpdate(workspace.id, prompt, worktreePath, workspace.repoPath, agentEnvOf(workspace), onProgress, requestedModel, onObservedModel, signal);
 	} catch (error) {
 		return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "analysis-failed", explainUpdateFailure(error, agentEnvOf(workspace), requestedModel));
 	}
 	const parsed = parseReconciliationResult(raw, previous.issues.length, { priorQuestionCount: previous.questions.length });
 	if (!parsed) return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "analysis-failed", "The reassessment came back in a form this could not read, so nothing was changed.");
 	const issues = [...reconcileIssues(previous.issues, parsed.findings), ...markNewIssues(parsed.newIssues)];
+	const motivation = carryMotivation(previous.motivation, workspace.session.metadata?.authorDescription, workspace.prContext?.pullRequest.body);
+	const questions = reconcileQuestions(previous.questions, parsed.questions);
 	const result = {
 		schemaVersion: 1,
 		summary: parsed.summary || previous.summary,
-		...previous.motivation ? { motivation: previous.motivation } : {},
+		...motivation ? { motivation } : {},
 		overallRisk: parsed.overallRisk ?? previous.overallRisk,
 		recommendation: parsed.recommendation || previous.recommendation,
 		nextSteps: parsed.nextSteps.length ? parsed.nextSteps : previous.nextSteps,
 		sections: composeSections(previous.sections, parsed.newSections),
 		issues,
-		questions: reconcileQuestions(previous.questions, parsed.questions)
+		questions: motivation === previous.motivation ? questions : withIntentQuestion(questions, motivation)
 	};
+	signal.throwIfAborted();
+	cancellers.delete(jobId);
 	await applyUpdate(workspace, result, previous, newHead, worktreePath, {
 		...requestedModel ? { requestedModel } : {},
 		...observedModel ? { observedModel } : {},
@@ -13818,8 +14266,8 @@ var BASELINE_GONE_MESSAGE = "The commit this review was made from is no longer i
 * is allowed to reach the network and that panel is not, so it looks at a newer copy of the same
 * refs.
 */
-async function remoteHead(workspace) {
-	const fetchFailed = !await fetchOrigin(workspace.repoPath);
+async function remoteHead(workspace, signal) {
+	const fetchFailed = !await fetchOrigin(workspace.repoPath, signal);
 	return {
 		sha: (await followedBranch(workspace))?.sha ?? null,
 		fetchFailed
@@ -13836,9 +14284,12 @@ function noRemoteHeadMessage(workspace) {
 * back to origin. Naming one ourselves would mean parsing a remote out of an upstream ref, which
 * is guesswork on any remote whose name contains a slash.
 */
-async function fetchOrigin(repoPath) {
+async function fetchOrigin(repoPath, signal) {
 	try {
-		await git(repoPath, ["fetch"], { timeoutMs: FETCH_TIMEOUT_MS });
+		await git(repoPath, ["fetch"], {
+			timeoutMs: FETCH_TIMEOUT_MS,
+			signal
+		});
 		return true;
 	} catch {
 		return false;
@@ -14131,7 +14582,7 @@ ${buildReconciliationInstructions({
 * that captured the daemon's environment instead was reconciling one review's findings with
 * whichever agent and account the workspace server happened to be started under.
 */
-async function runUpdate(workspaceId, prompt, cwd, originRepoPath, env, onProgress, requestedModel, onObservedModel) {
+async function runUpdate(workspaceId, prompt, cwd, originRepoPath, env, onProgress, requestedModel, onObservedModel, signal) {
 	try {
 		return await withUsageRecorded(workspaceId, "update", env, (onUsage) => agentFor(env).run({
 			capability: "read-code",
@@ -14143,7 +14594,8 @@ async function runUpdate(workspaceId, prompt, cwd, originRepoPath, env, onProgre
 			timeoutMs: UPDATE_TIMEOUT_MS,
 			onProgress,
 			onUsage,
-			...onObservedModel ? { onObservedModel } : {}
+			...onObservedModel ? { onObservedModel } : {},
+			...signal ? { signal } : {}
 		}), void 0, requestedModel);
 	} catch (error) {
 		if (error instanceof AgentUnavailableError) throw new RefreshUnavailableError(`${error.message} It is what this review was made with, so this review cannot be brought up to date.`);
@@ -14336,4 +14788,4 @@ function lineageIds(id) {
 	return [.../* @__PURE__ */ new Set([id, ...lineage.map((review) => review.id)])];
 }
 //#endregion
-export { asString as $, resolveAgent as $n, driverGone as $t, createPrState as A, offersLifecycle as An, statedWorkspacePort as At, toneOf as B, isQuestionOutstanding as Bn, reviewedShaOf as Bt, readEvents as C, workspaceStamps as Cn, PACKAGE_NAME as Ct, announceJob as D, lifecycleAction as Dn, MIN_WORKSPACE_PORT as Dt, telemetryUploadConsent as E, isLifecycle as En, MAX_WORKSPACE_PORT as Et, markAllRead as F, queueRemove as Fn, remoteHost as Ft, authorPreview as G, recommendationsOf as Gn, loadJob as Gt, withUsageRecorded as H, questionsOutstanding as Hn, endedAt as Ht, markRead as I, queueStamp as In, fillFileUrlTemplate as It, renderMarkdown as J, kissOutcome as Jn, isLiveJob as Jt, hasAuthorContent as K, describeAuthorship as Kn, saveJob as Kt, pruneNotifications as L, readQueue as Ln, checkCodeFreshness as Lt, eventName as M, sectionOf as Mn, claimRequestUrl as Mt, headline as N, queueAdd as Nn, forgeResolver as Nt, branchOf as O, lifecycleChip as On, parseWorkspacePort as Ot, listNotifications as P, queueAddMany as Pn, forgeFor as Pt, renderInlineText as Q, git as Qn, clearClaim as Qt, readNotification as R, doneVerb as Rn, checkReview as Rt, startJob as S, workspaceRevision as Sn, BUILD_VERSION as St, recordTelemetryUploadConsent as T, activityLabel as Tn, DEFAULT_WORKSPACE_PORT as Tt, EXPLAIN_SIMPLY_PROMPT as U, reviewerDispositions as Un, fail as Ut, unreadCount as V, issuesOutstanding as Vn, allJobs as Vt, UNESTABLISHED_MOTIVATION as W, processDiscussion as Wn, isTerminal as Wt, CODE_COPY_CLASS as X, displayRef as Xn, progressSteps as Xt, CODE_BLOCK_CLASS as Y, resolveTarget as Yn, phasesFor as Yt, escapeHtml as Z, isCommitReview as Zn, purposeOf as Zt, agentEnvOf as _, recentWorkspaces as _n, serverEntryExists as _t, wasBlocked as a, indexReviewGroups as an, STORE_ROOT as ar, modelHelpLines as at, reanalyseReview as b, summarise as bn, workspaceUrl as bt, RefreshUnavailableError as c, latestKissRun as cn, agentById as cr, compactQueue as ct, refreshPrContext as d, loadWorkspace as dn, AgentCancelledError as dr, readIndexToken as dt, isClaimed as en, resolveModel as er, extractJsonText as et, isUnchanged as f, matchingWorkspaceIds as fn, AgentUnavailableError as fr, bootstrapUrl as ft, runningJobs as g, previousKissResult as gn, reviewsUrl as gt, liveUpdateFor as h, presentedKissRunOf as hn, readServerRecord as ht, liveJobsFor as i, indexKeptIds as in, CONFIG_PATH as ir, removeWorktree as it, createPrUpdate as j, parseLifecycle as jn, writePortPreference as jt, subjectOf as k, lifecyclePill as kn, resolveWorkspacePort as kt, mergeUpdateInto as l, lineageKeyFor as ln, agentFor as lr, queueForReview as lt, UpdateAlreadyRunningError as m, positionInLineage as mn, ensureServer as mt, deleteReview as n, followedRefName as nn, readAgentPreference as nr, MANAGED_ROOT as nt, discardJob as o, kissDecisionRefusal as on, AGENT_IDS as or, relativeTime as ot, askCheckout as p, mutateWorkspace as pn, clearServerRecord as pt, GITHUB_MARKDOWN as q, WITHHELD_REASON as qn, PHASES as qt, lineageIds as r, groupByLineage as rn, writeAgentPreference as rr, readMarker as rt, FETCH_TIMEOUT_MS as s, kissDecisionsOf as sn, DEFAULT_AGENT_ID as sr, activateQueued as st, deleteLineage as t, decideKissRecommendation as tn, clearAgentPreference as tr, ReviewBeingDeletedError as tt, updateReview as u, lineagePosition as un, detectAgents as ur, settleQueue as ut, recordKissRun as v, reviewedCommit as vn, spawnServer as vt, record as w, LIFECYCLES as wn, feedbackUrl as wt, runJob as x, touchWorkspace as xn, writeServerRecord as xt, startKissJob as y, reviewedRepositories as yn, stopServer as yt, removeNotification as z, isIssueOutstanding as zn, followedBranch as zt };
+export { unreadCount as $, queueRemove as $n, remoteHost as $t, reanalyseReview as A, matchingWorkspaceIds as An, AgentCancelledError as Ar, clearServerRecordOwnedBy as At, createArchitectureNotification as B, workspaceRevision as Bn, BUILD_VERSION as Bt, track as C, indexReviewGroups as Cn, CONFIG_PATH as Cr, relativeTime as Ct, endRun as D, lineageKeyFor as Dn, agentById as Dr, settleQueue as Dt, completeRun as E, latestKissRun as En, DEFAULT_AGENT_ID as Er, queueForReview as Et, recordTelemetryUploadConsent as F, recentWorkspaces as Fn, spawnServer as Ft, listNotifications as G, lifecycleAction as Gn, MIN_WORKSPACE_PORT as Gt, createPrUpdate as H, LIFECYCLES as Hn, feedbackUrl as Ht, telemetryUploadConsent as I, reviewedCommit as In, stopChild as It, markReadForReview as J, offersLifecycle as Jn, statedWorkspacePort as Jt, markAllRead as K, lifecycleChip as Kn, parseWorkspacePort as Kt, announceJob as L, reviewedRepositories as Ln, stopServer as Lt, startJob as M, positionInLineage as Mn, readServerRecord as Mt, readEvents as N, presentedKissRunOf as Nn, reviewsUrl as Nt, reportRun as O, lineagePosition as On, agentFor as Or, readIndexToken as Ot, record as P, previousKissResult as Pn, serverEntryExists as Pt, toneOf as Q, queueAddMany as Qn, forgeFor as Qt, branchOf as R, summarise as Rn, workspaceUrl as Rt, isDriving as S, indexKeptIds as Sn, writeAgentPreference as Sr, modelHelpLines as St, beginRun as T, kissDecisionsOf as Tn, AGENT_IDS as Tr, compactQueue as Tt, eventName as U, activityLabel as Un, DEFAULT_WORKSPACE_PORT as Ut, createPrState as V, workspaceStamps as Vn, PACKAGE_NAME as Vt, headline as W, isLifecycle as Wn, MAX_WORKSPACE_PORT as Wt, readNotification as X, sectionOf as Xn, claimRequestUrl as Xt, pruneNotifications as Y, parseLifecycle as Yn, writePortPreference as Yt, removeNotification as Z, queueAdd as Zn, forgeResolver as Zt, liveUpdateFor as _, driverGone as _n, gitSync as _r, holdWorktree as _t, wasBlocked as a, allJobs as an, issuesOutstanding as ar, GITHUB_MARKDOWN as at, recordKissRun as b, followedRefName as bn, clearAgentPreference as br, removeWorktree as bt, RefreshUnavailableError as c, isTerminal as cn, processDiscussion as cr, CODE_COPY_CLASS as ct, mergeUpdateInto as d, PHASES as dn, WITHHELD_REASON as dr, asString as dt, fillFileUrlTemplate as en, queueStamp as er, withUsageRecorded as et, updateReview as f, isLiveJob as fn, kissOutcome as fr, extractJsonText as ft, UpdateAlreadyRunningError as g, clearClaim as gn, git as gr, createWorktree as gt, askCheckout as h, purposeOf as hn, isCommitReview as hr, MANAGED_ROOT as ht, liveJobsFor as i, reviewedShaOf as in, isQuestionOutstanding as ir, hasAuthorContent as it, runJob as j, mutateWorkspace as jn, AgentUnavailableError as jr, ensureServer as jt, stopRun as k, loadWorkspace as kn, detectAgents as kr, bootstrapUrl as kt, cancelUpdate as l, loadJob as ln, recommendationsOf as lr, escapeHtml as lt, isUnchanged as m, progressSteps as mn, displayRef as mr, ReviewBeingDeletedError as mt, deleteReview as n, checkReview as nn, doneVerb as nr, UNESTABLISHED_MOTIVATION as nt, discardJob as o, endedAt as on, questionsOutstanding as or, renderMarkdown as ot, refreshPrContext as p, phasesFor as pn, resolveTarget as pr, objectWithAnyOf as pt, markRead as q, lifecyclePill as qn, resolveWorkspacePort as qt, lineageIds as r, followedBranch as rn, isIssueOutstanding as rr, authorPreview as rt, FETCH_TIMEOUT_MS as s, fail as sn, reviewerDispositions as sr, CODE_BLOCK_CLASS as st, deleteLineage as t, checkCodeFreshness as tn, readQueue as tr, EXPLAIN_SIMPLY_PROMPT as tt, cancellableHere as u, saveJob as un, describeAuthorship as ur, renderInlineText as ut, runningJobs as v, isClaimed as vn, resolveAgent as vr, isWorktreeHeld as vt, RUN_KINDS as w, kissDecisionRefusal as wn, STORE_ROOT as wr, activateQueued as wt, startKissJob as x, groupByLineage as xn, readAgentPreference as xr, requestJobStop as xt, agentEnvOf as y, decideKissRecommendation as yn, resolveModel as yr, readMarker as yt, subjectOf as z, touchWorkspace as zn, writeServerRecord as zt };