prreviewbuddy 0.25.6 → 0.25.8

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## 0.25.8
+
+**A review that fails says so, instead of reporting itself as ready.** An analysis that failed
+after the agent had started work left no trace of the failure: the job stayed at `Analysing the
+change`, the workspace page kept the running rail over it, and the terminal printed
+`Review ready . Risk not rated . 0 findings`, which reads as a change with nothing wrong with it.
+The review it was reporting did not exist.
+
+The record refuses to be failed by anyone but the run that owns it, so that a driver whose job has
+been taken over cannot mark a healthy review as broken. It asked that question of the record's
+timestamp, and the timestamp moves every time the agent reports what it is doing. So a run that
+streamed a single line and then failed looked, to itself, like a run that had been taken over, and
+declined to record its own failure. It asks the claim now, which is who is actually driving.
+
+**The terminal reports what happened, and refuses to invent the rest.** `prreviewbuddy review` read
+"the job did not fail" as "the review is ready". A run can also stop without recording why, and now
+says so, naming the phase it stopped in, which is the phase running the command again picks up
+from. A finished job holding no review is reported as a review that stopped rather than as a clean
+one: the standard review is held to the rule the KISS lens has always been held to.
+
+**A fenced answer is read to its end, not to the first ``` inside it.** The model is asked for
+JSON and often wraps it in a code fence, and the summary and next steps of a review about code
+frequently hold a fenced snippet of their own. The unwrapping stopped at the first closing marker
+it found, which in that case is the one *opening* a snippet inside one of the answer's own
+strings. A real review of a ten-file pull request was cut in half 24KB in, mid-string, and thrown
+away whole: four themes, six findings, six questions and six next steps, none of which anything
+ever showed. A fence says where an answer starts, not where it ends, so one that does not parse is
+now passed over for the scanner that reads such an object correctly.
+
+## 0.25.7
+
+**The agent you chose is the agent that runs.** Setting a default agent, with
+`prreviewbuddy config set agent codex` or by picking one when asked, made the terminal say
+`Using Codex.` and then start the review under Claude anyway. Only `--agent` typed on the command
+line reached the job; every other way of arriving at an agent, including the configured default and
+the first-run picker, was worked out, announced and then dropped, and the review fell back to
+Claude because that is what a job with no agent recorded means.
+
+Nothing about it was visible unless it failed. A signed-in Claude simply reviewed the change, well,
+under a tool nobody had asked for; the way it surfaced was a sign-in message naming Claude on a
+machine where Codex was the default.
+
+**Resuming a paused review answers `--agent` instead of ignoring it.** A resume continues under the
+agent the review was started by, because the phases it has already finished were done by that one
+and switching halfway would leave a review whose provenance and whose execution disagree. That is
+unchanged; what is new is that it says so, and names `--reanalyse --agent` as the way to analyse
+the same commit with another agent. It stays quiet when the flag asks for the agent already
+running.
+
 ## 0.25.6
 
 **A review you open while it is still running now looks like one that is running.** Following the

package/dist/main.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { B as BUILD_VERSION, Bt as STORE_ROOT, C as statedWorkspacePort, E as updateReview, F as startJob, Ft as agentIdOf, G as forgeResolver, Ht as agentById, J as clearClaim, L as record, Lt as readAgentPreference, Mt as resolveTarget, N as reanalyseReview, Nt as displayRef, P as runJob, Pt as git, Q as removeWorktree, R as recordTelemetryUploadConsent, Rt as writeAgentPreference, St as summarise, V as PACKAGE_NAME, Vt as AGENT_IDS, Wt as detectAgents, X as MANAGED_ROOT, Y as isClaimed, Z as readMarker, a as liveJobsFor, b as MIN_WORKSPACE_PORT, bt as reviewedRepositories, ct as followedRefName, dt as lineageKeyFor, et as checkFreshness, f as ensureServer, g as workspaceUrl, h as stopServer, ht as positionInLineage, it as loadJob, j as recordKissRun, l as readIndexToken, lt as groupByLineage, m as reviewsUrl, mt as matchingWorkspaceIds, o as wasBlocked, pt as loadWorkspace, r as deleteReview$1, rt as isTerminal, s as runningJobs, st as progressSteps, t as relativeTime, tt as allJobs, u as bootstrapUrl, v as DEFAULT_WORKSPACE_PORT, vt as recentWorkspaces, w as writePortPreference, x as parseWorkspacePort, xt as saveWorkspace, y as MAX_WORKSPACE_PORT, z as telemetryUploadConsent, zt as CONFIG_PATH } from "./relative_time-DJ9iHDDG.js";
+import { $ as allJobs, B as BUILD_VERSION, Bt as STORE_ROOT, C as statedWorkspacePort, E as updateReview, F as startJob, Ft as agentIdOf, G as forgeResolver, Gt as detectAgents, Ht as DEFAULT_AGENT_ID, J as MANAGED_ROOT, L as record, Lt as readAgentPreference, Mt as resolveTarget, N as reanalyseReview, Nt as displayRef, P as runJob, Pt as git, Q as checkFreshness, R as recordTelemetryUploadConsent, Rt as writeAgentPreference, St as summarise, Ut as agentById, V as PACKAGE_NAME, Vt as AGENT_IDS, X as removeWorktree, Y as readMarker, a as liveJobsFor, at as progressSteps, b as MIN_WORKSPACE_PORT, bt as reviewedRepositories, ct as followedRefName, dt as lineageKeyFor, f as ensureServer, g as workspaceUrl, h as stopServer, ht as positionInLineage, it as PHASES, j as recordKissRun, l as readIndexToken, lt as groupByLineage, m as reviewsUrl, mt as matchingWorkspaceIds, nt as loadJob, o as wasBlocked, ot as clearClaim, pt as loadWorkspace, r as deleteReview$1, s as runningJobs, st as isClaimed, t as relativeTime, tt as isTerminal, u as bootstrapUrl, v as DEFAULT_WORKSPACE_PORT, vt as recentWorkspaces, w as writePortPreference, x as parseWorkspacePort, xt as saveWorkspace, y as MAX_WORKSPACE_PORT, z as telemetryUploadConsent, zt as CONFIG_PATH } from "./relative_time-D760FOL9.js";
 import { basename, dirname, join, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
@@ -1250,6 +1250,19 @@ function agentUnusedByUpdate(agentId) {
 	return `An update continues the review with the agent it was made by, so \`--agent ${agentId}\` changes nothing here. To analyse the same commit again with another agent, run \`prreviewbuddy review --reanalyse --agent ${agentId}\`.`;
 }
 /**
+* `--agent` was named alongside a resume, where it changes nothing either.
+*
+* A paused job carries the agent it was started under, and its finished phases were done by that
+* agent. Switching engines halfway would leave one review whose provenance and whose execution
+* disagree, so the flag does not mutate the job; it is said instead, for the reason above.
+*
+* Only when the two differ. Resuming a Codex job with `--agent codex` is the agent the reviewer
+* asked for, and telling them it was ignored would be true and useless.
+*/
+function agentUnusedByResume(agentId) {
+	return `A resume continues with the agent the review was started by, so \`--agent ${agentId}\` changes nothing here. To analyse the same commit with it instead, run \`prreviewbuddy review --reanalyse --agent ${agentId}\`.`;
+}
+/**
 * The update's own sentence, which the harness already wrote for the workspace strip, plus the
 * link. Not rephrased here: an update that stopped early has a specific reason and the reviewer
 * gets the same reason whichever surface asked for it.
@@ -1722,7 +1735,8 @@ async function review(command, repoPath) {
 		return operate(command, workspace);
 	}
 	if (command.lens === "kiss") return kiss(command, target);
-	if (!await chooseFor(command)) return 1;
+	const agent = await chooseFor(command);
+	if (!agent) return 1;
 	if (command.operation !== "fresh") {
 		const existing = await findExistingReview(target);
 		if (existing) {
@@ -1732,13 +1746,14 @@ async function review(command, repoPath) {
 				out(existingReview(existing, url));
 				return 0;
 			}
-			err(resumingReview(failed, existing));
+			err(resumingReview(failed.message, existing));
+			if (command.agentId && command.agentId !== failed.agentId) err(agentUnusedByResume(command.agentId));
 			return drive(existing.id, url);
 		}
 	}
 	const workspaceId = await startJob({
 		target,
-		...command.agentId ? { agentId: command.agentId } : {}
+		agentId: agent.id
 	});
 	const url = linkTo(await ensureServer(), workspaceId, loadWorkspace(workspaceId).token);
 	out(startedReview(url, target));
@@ -1787,7 +1802,7 @@ async function kiss(command, target) {
 			type: "kiss",
 			audience
 		},
-		...command.agentId ? { agentId: command.agentId } : {}
+		agentId: agent.id
 	});
 	const fresh = loadWorkspace(workspaceId);
 	const run = (fresh.kissRuns ?? [])[0];
@@ -1905,7 +1920,10 @@ function failureOf(workspaceId) {
 	const job = loadJob(workspace.jobId);
 	if (!job || !isTerminal(job) || job.phase !== "failed") return null;
 	if (isClaimed(job.id)) return null;
-	return job.failure?.message ?? "The reason was not recorded.";
+	return {
+		message: job.failure?.message ?? "The reason was not recorded.",
+		agentId: job.env.agentId ?? DEFAULT_AGENT_ID
+	};
 }
 /**
 * Run the job to its end, saying what it is doing while it does it.
@@ -1932,9 +1950,9 @@ async function drive(workspaceId, url, kissRun) {
 	let finished;
 	try {
 		finished = await runJob(workspaceId, {}, kissRun ? "kiss" : "standard");
-		if (finished.phase === "failed") {
+		if (finished.phase !== "done") {
 			stop();
-			err(reviewFailed(finished.failure?.message ?? "The reason was not recorded.", await linkNow(workspace, url)));
+			err(reviewFailed(failureMessage(finished), await linkNow(workspace, url)));
 			return 1;
 		}
 	} catch (error) {
@@ -1955,10 +1973,26 @@ async function drive(workspaceId, url, kissRun) {
 		out(kissFinished(link, answer.recommendations.length));
 		return 0;
 	}
+	if (!done.session.result) {
+		err(reviewFailed("The analysis finished without recording a review.", link));
+		return 1;
+	}
 	out(reviewFinished(link, summarise(done), finished.conversation));
 	return 0;
 }
 /**
+* Why a run ended, when it did not end by finishing.
+*
+* A job that recorded a failure says so in its own words. One that did not is a driver that went
+* away mid-phase -- killed, or crashed past the point where it could write -- and the honest thing
+* to say is which phase it was in, because that is the phase the next run picks up from.
+*/
+function failureMessage(job) {
+	if (job.failure?.message) return job.failure.message;
+	const doing = PHASES[job.phase].doing;
+	return `The reason was not recorded. It was ${doing.charAt(0).toLowerCase()}${doing.slice(1)} when it stopped.`;
+}
+/**
 * Every link this command prints, and the reason they are not plain workspace URLs.
 *
 * A reviewer who only ever runs this command was never sent to the reviews index, so their browser

package/dist/{relative_time-DJ9iHDDG.js → relative_time-D760FOL9.js}

@@ -3869,6 +3869,223 @@ function pruneOldWorkspaces() {
 	} catch {}
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/exclusive_claim.ts
+/**
+* At most one holder of a name at a time, across processes, on this machine.
+*
+* Extracted from `job_claim.ts`, which had written all of this for one caller. A second caller then
+* needed the same thing under a different name -- see `review_lock.ts` -- and the alternative was a
+* second concurrency system beside a working one, which is how two mechanisms come to disagree
+* about who holds what.
+*
+* The mechanism, and the reasoning behind each half of it, lives here. What a particular claim
+* *means* stays with the module that takes it: "at most one driver owns a job" is a statement about
+* jobs, not about `link()`.
+*
+* Never holds a credential, and holds nothing about the thing it names: a claim is a pid, a host,
+* and two timestamps.
+*/
+/**
+* One directory for every kind of claim, keyed by name.
+*
+* Kept out of `jobs/`, where `allJobs` reads every `.json` and parses it as a `ReviewJob`: a claim
+* file there would be swept as a job. Keys from different callers share the directory and are kept
+* apart by shape -- a job claim is a UUID, a review lock is `review-<id>` -- so neither can name
+* the other's file by accident.
+*/
+var CLAIMS_DIR = join(STORE_ROOT, "claims");
+/** Comfortably inside the lease, so one slow tick is never enough to lose a claim that is held. */
+var CLAIM_RENEW_MS = 3e4;
+function claimPath(key) {
+	return join(CLAIMS_DIR, `${key}.json`);
+}
+function readClaim(key) {
+	try {
+		return JSON.parse(readFileSync(claimPath(key), "utf8"));
+	} catch {
+		return null;
+	}
+}
+/**
+* Whether the process behind a claim still exists.
+*
+* Signal 0 checks for a process without touching it: `ESRCH` means gone, and `EPERM` means it is
+* there but owned by somebody else, which is still there. Only meaningful for a claim written on
+* this machine, and `~/.prreviewbuddy` can sit on a synced home directory, so a claim from another
+* host is left to the lease alone rather than judged against a pid that means nothing here.
+*/
+function ownerAlive(claim) {
+	if (claim.host !== hostname()) return true;
+	try {
+		process.kill(claim.pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+/**
+* The claim on this key, if one is genuinely held.
+*
+* Both conditions, because each covers the other's blind spot. A pid check recovers from a killed
+* holder at once but can be fooled by a reused pid; a lease cannot be fooled but is always late by
+* up to its own length. Requiring both means a reused pid with a stale lease reads as free, and a
+* dead pid with a fresh lease reads as free immediately.
+*/
+function liveClaim$1(key, now = Date.now()) {
+	const claim = readClaim(key);
+	if (!claim) return null;
+	if (now - claim.renewedAt >= 18e4) return null;
+	if (!ownerAlive(claim)) return null;
+	return claim;
+}
+/**
+* Take the claim on a key, or return null because somebody else holds it.
+*
+* Synchronous from the check to the create, with no `await` between them, so two calls inside one
+* process cannot both pass: this keeps the property a module-level `Set` had, and adds the one it
+* lacked.
+*
+* Across processes the create is `link`, which fails with `EEXIST` if the name is taken and does so
+* atomically, unlike a write with a prior existence check. A stale claim is unlinked first, and
+* only if it is still the same stale claim that was read a line earlier, identified by `holder`.
+* The residual race is two processes stealing the *same* stale claim within the same few
+* microseconds, where the loser can delete the winner's fresh file. Left rather than solved: it
+* needs a crashed holder and two attempts fired at the same instant, and `recordFailure` already
+* refuses to write over a job record that moved underneath it, so the cost of losing that race is
+* duplicated work rather than a corrupted review.
+*
+* **Never waits.** A caller that cannot have the key is told so immediately. Queueing would turn a
+* deletion racing an analysis into a deletion that happens twenty minutes later, when the person
+* who asked for it has stopped looking.
+*/
+function acquire(key, now = Date.now()) {
+	const existing = readClaim(key);
+	if (existing) {
+		if (liveClaim$1(key, now)) return null;
+		const current = readClaim(key);
+		if (current && current.holder !== existing.holder) return null;
+		try {
+			unlinkSync(claimPath(key));
+		} catch {}
+	}
+	const claim = {
+		key,
+		holder: randomUUID(),
+		pid: process.pid,
+		host: hostname(),
+		acquiredAt: now,
+		renewedAt: now
+	};
+	mkdirSync(CLAIMS_DIR, { recursive: true });
+	const staging = join(CLAIMS_DIR, `.${claim.holder}.tmp`);
+	writeFileSync(staging, JSON.stringify(claim), { mode: 384 });
+	try {
+		linkSync(staging, claimPath(key));
+	} catch {
+		return null;
+	} finally {
+		rmSync(staging, { force: true });
+	}
+	return startHolding(claim);
+}
+/**
+* Keep the claim fresh for as long as the work runs, and give it up afterwards.
+*
+* The timer is unreferenced on purpose. A heartbeat must never be the reason a process stays alive:
+* the CLI is held open by the await on the job and the workspace server by its socket, and if
+* neither is true any more then this claim is exactly the kind that should be allowed to expire.
+*
+* A renewal that finds the claim *gone* writes it back rather than giving up. A holder whose event
+* loop was blocked past the lease -- parsing a very large diff, say -- can have its claim judged
+* expired and swept while it is still perfectly alive, and a holder that then quietly stopped
+* renewing would leave the key looking free for the rest of its run. Nobody holds the file, so
+* taking it again is the true statement.
+*
+* A renewal that finds the claim held by somebody *else* stops rather than writing over it. By then
+* the other holder is the real one, and reasserting ownership here would produce the two holders
+* this whole file exists to prevent.
+*/
+function startHolding(claim) {
+	let held = claim;
+	const timer = setInterval(() => {
+		const current = readClaim(held.key);
+		if (current && current.holder !== held.holder) {
+			clearInterval(timer);
+			return;
+		}
+		held = {
+			...held,
+			renewedAt: Date.now()
+		};
+		try {
+			writeFileSync(claimPath(held.key), JSON.stringify(held), { mode: 384 });
+		} catch {}
+	}, CLAIM_RENEW_MS);
+	timer.unref?.();
+	return {
+		get claim() {
+			return held;
+		},
+		release() {
+			clearInterval(timer);
+			const current = readClaim(held.key);
+			if (current && current.holder !== held.holder) return;
+			try {
+				unlinkSync(claimPath(held.key));
+			} catch {}
+		}
+	};
+}
+/** Drop a claim without holding it first. For a key being destroyed, and for tests. */
+function clearClaim$1(key) {
+	try {
+		unlinkSync(claimPath(key));
+	} catch {}
+}
+//#endregion
+//#region ../../packages/review-harness/src/workspace/job_claim.ts
+/**
+* Who is driving a job right now, recorded where another process can see it.
+*
+* The invariant this exists to state: **at most one driver owns a job at a time.** `runJob` used to
+* enforce that with a module-level `Set`, which was correct when one process called it and became
+* silently wrong the moment three did -- the MCP server, the workspace server's Retry route, and
+* the CLI. A guard that is invisible across processes is not a guard against the case that
+* actually happens, which is two surfaces on one machine reaching the same job.
+*
+* Idempotence at each collision point was the alternative, and it was rejected: it would have to be
+* rebuilt separately for `createWorktree`, for context building, for the agent spawn and for
+* applying the result, and each one would only ever be as good as the last person who remembered.
+* One claim covers the whole lifecycle.
+*
+* The mechanism is `exclusive_claim.ts`, and this file is now the naming: a job is claimed under
+* its own id, so `claims/<jobId>.json` is where it has always been. The mechanism moved out when a
+* review lock needed the same guarantee under a different name; what stays here is what a job claim
+* means, which is the part that is about jobs rather than about `link()`.
+*/
+/** The claim on this job, if a driver genuinely holds it. */
+function liveClaim(jobId, now = Date.now()) {
+	return liveClaim$1(jobId, now);
+}
+/** Whether a driver owns this job right now. The question every other module actually asks. */
+function isClaimed(jobId, now = Date.now()) {
+	return liveClaim(jobId, now) !== null;
+}
+/**
+* Take the claim on a job, or return null because another driver holds it.
+*
+* Two retries fired together, a retry racing the run `startJob` already kicked off, or a retry
+* racing a driver the sweep wrongly called stopped: all of them land here rather than both reaching
+* `createWorktree` or the analysis spawn.
+*/
+function claimJob(jobId, now = Date.now()) {
+	return acquire(jobId, now);
+}
+/** Drop a job's claim without holding it first. For a job being deleted, and for tests. */
+function clearClaim(jobId) {
+	clearClaim$1(jobId);
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/job_progress.ts
 /**
 * The phases that do work, in the order they run. `done` and `failed` are outcomes, not work.
@@ -4097,20 +4314,31 @@ function fail(job, message, kind, detail) {
 	};
 }
 /**
-* Record a failure, without overwriting a record that has moved on since this run last saw it.
+* Record a failure, unless somebody else is driving this job now.
+*
+* A run only reaches this after an `await` on the git call or the agent spawn that just rejected,
+* and whatever this run's own `job` variable holds by then is a snapshot from before that. If the
+* run that owns the job is no longer this one -- this one's claim lapsed and another driver picked
+* the job up -- saving this run's failure would take a job that is running fine and record it as
+* failed, and nothing downstream could tell the difference from a real one: `saveJob` writes
+* whatever it is given.
 *
-* A run only reaches this after an `await` on the git call or the Claude Code spawn that just
-* rejected, and whatever this run's own `job` variable holds by then is a snapshot from before
-* that. If some other write landed on disk in the meantime -- another run this one should have
-* been refused for racing, had the guard in `runJob` worked, or simply one that started later and
-* is now the run actually driving this job -- saving this run's failure over it would take a job
-* that is running fine and record it as failed, and nothing downstream could tell the difference
-* from a real one: `saveJob` writes whatever it is given.
+* The question is asked of the claim, which is who is driving, and not of `updatedAt`, which is
+* only when the record last moved. Those two came apart the moment the analysis began streaming
+* progress: `runAnalysisFor` writes every line the agent reports onto the record with a fresh
+* `updatedAt` and does not hand the new copy back, so a driver's own commentary made its own
+* snapshot look stale and it declined to record its own failure. The job stayed at `analysing` for
+* ever, the page kept the running rail over it, and the CLI printed `Review ready . 0 findings`.
+*
+* The failure is written onto the record as it now stands rather than onto the snapshot, so the
+* last thing the agent said survives being failed. Only a driver whose own claim has gone is
+* refused, so a job nobody holds -- a crashed driver's, a resumed run's -- is still failable.
 */
-function recordFailure(job, message, kind, detail) {
-	const current = loadJob(job.id);
-	if (current && current.updatedAt !== job.updatedAt) return current;
-	const failed = fail(job, message, kind, detail);
+function recordFailure(job, message, driver, kind, detail) {
+	const current = loadJob(job.id) ?? job;
+	const claim = liveClaim(job.id);
+	if (claim && claim.holder !== driver) return current;
+	const failed = fail(current, message, kind, detail);
 	saveJob(failed);
 	return failed;
 }
@@ -4719,223 +4947,6 @@ function message$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
-//#region ../../packages/review-harness/src/workspace/exclusive_claim.ts
-/**
-* At most one holder of a name at a time, across processes, on this machine.
-*
-* Extracted from `job_claim.ts`, which had written all of this for one caller. A second caller then
-* needed the same thing under a different name -- see `review_lock.ts` -- and the alternative was a
-* second concurrency system beside a working one, which is how two mechanisms come to disagree
-* about who holds what.
-*
-* The mechanism, and the reasoning behind each half of it, lives here. What a particular claim
-* *means* stays with the module that takes it: "at most one driver owns a job" is a statement about
-* jobs, not about `link()`.
-*
-* Never holds a credential, and holds nothing about the thing it names: a claim is a pid, a host,
-* and two timestamps.
-*/
-/**
-* One directory for every kind of claim, keyed by name.
-*
-* Kept out of `jobs/`, where `allJobs` reads every `.json` and parses it as a `ReviewJob`: a claim
-* file there would be swept as a job. Keys from different callers share the directory and are kept
-* apart by shape -- a job claim is a UUID, a review lock is `review-<id>` -- so neither can name
-* the other's file by accident.
-*/
-var CLAIMS_DIR = join(STORE_ROOT, "claims");
-/** Comfortably inside the lease, so one slow tick is never enough to lose a claim that is held. */
-var CLAIM_RENEW_MS = 3e4;
-function claimPath(key) {
-	return join(CLAIMS_DIR, `${key}.json`);
-}
-function readClaim(key) {
-	try {
-		return JSON.parse(readFileSync(claimPath(key), "utf8"));
-	} catch {
-		return null;
-	}
-}
-/**
-* Whether the process behind a claim still exists.
-*
-* Signal 0 checks for a process without touching it: `ESRCH` means gone, and `EPERM` means it is
-* there but owned by somebody else, which is still there. Only meaningful for a claim written on
-* this machine, and `~/.prreviewbuddy` can sit on a synced home directory, so a claim from another
-* host is left to the lease alone rather than judged against a pid that means nothing here.
-*/
-function ownerAlive(claim) {
-	if (claim.host !== hostname()) return true;
-	try {
-		process.kill(claim.pid, 0);
-		return true;
-	} catch (error) {
-		return error.code === "EPERM";
-	}
-}
-/**
-* The claim on this key, if one is genuinely held.
-*
-* Both conditions, because each covers the other's blind spot. A pid check recovers from a killed
-* holder at once but can be fooled by a reused pid; a lease cannot be fooled but is always late by
-* up to its own length. Requiring both means a reused pid with a stale lease reads as free, and a
-* dead pid with a fresh lease reads as free immediately.
-*/
-function liveClaim$1(key, now = Date.now()) {
-	const claim = readClaim(key);
-	if (!claim) return null;
-	if (now - claim.renewedAt >= 18e4) return null;
-	if (!ownerAlive(claim)) return null;
-	return claim;
-}
-/**
-* Take the claim on a key, or return null because somebody else holds it.
-*
-* Synchronous from the check to the create, with no `await` between them, so two calls inside one
-* process cannot both pass: this keeps the property a module-level `Set` had, and adds the one it
-* lacked.
-*
-* Across processes the create is `link`, which fails with `EEXIST` if the name is taken and does so
-* atomically, unlike a write with a prior existence check. A stale claim is unlinked first, and
-* only if it is still the same stale claim that was read a line earlier, identified by `holder`.
-* The residual race is two processes stealing the *same* stale claim within the same few
-* microseconds, where the loser can delete the winner's fresh file. Left rather than solved: it
-* needs a crashed holder and two attempts fired at the same instant, and `recordFailure` already
-* refuses to write over a job record that moved underneath it, so the cost of losing that race is
-* duplicated work rather than a corrupted review.
-*
-* **Never waits.** A caller that cannot have the key is told so immediately. Queueing would turn a
-* deletion racing an analysis into a deletion that happens twenty minutes later, when the person
-* who asked for it has stopped looking.
-*/
-function acquire(key, now = Date.now()) {
-	const existing = readClaim(key);
-	if (existing) {
-		if (liveClaim$1(key, now)) return null;
-		const current = readClaim(key);
-		if (current && current.holder !== existing.holder) return null;
-		try {
-			unlinkSync(claimPath(key));
-		} catch {}
-	}
-	const claim = {
-		key,
-		holder: randomUUID(),
-		pid: process.pid,
-		host: hostname(),
-		acquiredAt: now,
-		renewedAt: now
-	};
-	mkdirSync(CLAIMS_DIR, { recursive: true });
-	const staging = join(CLAIMS_DIR, `.${claim.holder}.tmp`);
-	writeFileSync(staging, JSON.stringify(claim), { mode: 384 });
-	try {
-		linkSync(staging, claimPath(key));
-	} catch {
-		return null;
-	} finally {
-		rmSync(staging, { force: true });
-	}
-	return startHolding(claim);
-}
-/**
-* Keep the claim fresh for as long as the work runs, and give it up afterwards.
-*
-* The timer is unreferenced on purpose. A heartbeat must never be the reason a process stays alive:
-* the CLI is held open by the await on the job and the workspace server by its socket, and if
-* neither is true any more then this claim is exactly the kind that should be allowed to expire.
-*
-* A renewal that finds the claim *gone* writes it back rather than giving up. A holder whose event
-* loop was blocked past the lease -- parsing a very large diff, say -- can have its claim judged
-* expired and swept while it is still perfectly alive, and a holder that then quietly stopped
-* renewing would leave the key looking free for the rest of its run. Nobody holds the file, so
-* taking it again is the true statement.
-*
-* A renewal that finds the claim held by somebody *else* stops rather than writing over it. By then
-* the other holder is the real one, and reasserting ownership here would produce the two holders
-* this whole file exists to prevent.
-*/
-function startHolding(claim) {
-	let held = claim;
-	const timer = setInterval(() => {
-		const current = readClaim(held.key);
-		if (current && current.holder !== held.holder) {
-			clearInterval(timer);
-			return;
-		}
-		held = {
-			...held,
-			renewedAt: Date.now()
-		};
-		try {
-			writeFileSync(claimPath(held.key), JSON.stringify(held), { mode: 384 });
-		} catch {}
-	}, CLAIM_RENEW_MS);
-	timer.unref?.();
-	return {
-		get claim() {
-			return held;
-		},
-		release() {
-			clearInterval(timer);
-			const current = readClaim(held.key);
-			if (current && current.holder !== held.holder) return;
-			try {
-				unlinkSync(claimPath(held.key));
-			} catch {}
-		}
-	};
-}
-/** Drop a claim without holding it first. For a key being destroyed, and for tests. */
-function clearClaim$1(key) {
-	try {
-		unlinkSync(claimPath(key));
-	} catch {}
-}
-//#endregion
-//#region ../../packages/review-harness/src/workspace/job_claim.ts
-/**
-* Who is driving a job right now, recorded where another process can see it.
-*
-* The invariant this exists to state: **at most one driver owns a job at a time.** `runJob` used to
-* enforce that with a module-level `Set`, which was correct when one process called it and became
-* silently wrong the moment three did -- the MCP server, the workspace server's Retry route, and
-* the CLI. A guard that is invisible across processes is not a guard against the case that
-* actually happens, which is two surfaces on one machine reaching the same job.
-*
-* Idempotence at each collision point was the alternative, and it was rejected: it would have to be
-* rebuilt separately for `createWorktree`, for context building, for the agent spawn and for
-* applying the result, and each one would only ever be as good as the last person who remembered.
-* One claim covers the whole lifecycle.
-*
-* The mechanism is `exclusive_claim.ts`, and this file is now the naming: a job is claimed under
-* its own id, so `claims/<jobId>.json` is where it has always been. The mechanism moved out when a
-* review lock needed the same guarantee under a different name; what stays here is what a job claim
-* means, which is the part that is about jobs rather than about `link()`.
-*/
-/** The claim on this job, if a driver genuinely holds it. */
-function liveClaim(jobId, now = Date.now()) {
-	return liveClaim$1(jobId, now);
-}
-/** Whether a driver owns this job right now. The question every other module actually asks. */
-function isClaimed(jobId, now = Date.now()) {
-	return liveClaim(jobId, now) !== null;
-}
-/**
-* Take the claim on a job, or return null because another driver holds it.
-*
-* Two retries fired together, a retry racing the run `startJob` already kicked off, or a retry
-* racing a driver the sweep wrongly called stopped: all of them land here rather than both reaching
-* `createWorktree` or the analysis spawn.
-*/
-function claimJob(jobId, now = Date.now()) {
-	return acquire(jobId, now);
-}
-/** Drop a job's claim without holding it first. For a job being deleted, and for tests. */
-function clearClaim(jobId) {
-	clearClaim$1(jobId);
-}
-//#endregion
 //#region ../../packages/review-harness/src/workspace/review_lock.ts
 /**
 * The lock that makes "nothing is running" a fact rather than an observation.
@@ -6907,7 +6918,14 @@ var REVIEW_ATTENTIONS = [
 * reply then finds the block *inside* a string and hands back a snippet of Ruby as the review,
 * which fails to parse and loses the whole thing.
 *
-* So a fence is only believed when what it wraps looks like the object or array being asked for.
+* So a fence is believed only when what it wraps is the object or array being asked for **and
+* parses whole**. Looking at the opening alone is not enough, because the marker that ends the
+* match need not be the one that ends the fence: a model that wraps its answer *and* puts a
+* fenced `bash` snippet in one of its own strings closes the non-greedy match 24KB early, in the
+* middle of a string, on a candidate that still begins with `{`. A live review answered in
+* exactly that shape and lost 26KB of perfectly good JSON. A fence says where the answer is, not
+* where it ends, so a candidate that does not parse is passed over rather than returned, and the
+* scanner below -- which tracks strings and reads such an object whole -- gets its turn.
 *
 * With no fence anywhere, the value is cut out of whatever surrounds it. The prompt asks for JSON
 * and nothing else, and that is the *only* instruction in the session this product controls: the
@@ -6923,10 +6941,19 @@ function extractJsonText(raw) {
 	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("[")) return inner;
+		if ((inner.startsWith("{") || inner.startsWith("[")) && parses(inner)) return inner;
 	}
 	return firstJsonValue(text) ?? 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 first slice of this text that is a whole JSON value.
 *
@@ -8528,7 +8555,7 @@ async function runJob(workspaceId, runners = {}, reviewType = "standard") {
 	});
 	if (isBusy(started)) throw busyReason(workspaceId, reviewType);
 	try {
-		return await drive(started.jobId, workspaceId, runners);
+		return await drive(started.jobId, workspaceId, runners, started.claim.claim.holder);
 	} finally {
 		started.claim.release();
 	}
@@ -8581,7 +8608,7 @@ function runOfJob(workspace, jobId) {
 	if (!run) throw new Error("This KISS job has no run to write its answer to.");
 	return run;
 }
-async function drive(jobId, workspaceId, runners) {
+async function drive(jobId, workspaceId, runners, driver) {
 	let job = loadJob(jobId);
 	if (!job) throw new Error("No such job.");
 	const startedAt = Date.now();
@@ -8688,7 +8715,7 @@ async function drive(jobId, workspaceId, runners) {
 	} catch (error) {
 		const kind = error instanceof GuideRejected || error instanceof KissRejected ? "agent_output_invalid" : error instanceof AgentRunError ? error.kind : void 0;
 		const raw = message(error);
-		job = recordFailure(job, explain(job, raw), kind, raw);
+		job = recordFailure(job, explain(job, raw), driver, kind, raw);
 		if (job.reviewType === "kiss") failCurrentKissRun(workspaceId, job, job.failure?.message ?? raw, kind, error instanceof KissRejected ? error.answer : void 0);
 		finished(job, workspaceId, startedAt, false);
 		return job;
@@ -10735,4 +10762,4 @@ function relativeTime(ms) {
 	return `${days} day${days === 1 ? "" : "s"} ago`;
 }
 //#endregion
-export { checkCodeFreshness as $, agentEnvOf as A, processDiscussion as At, BUILD_VERSION as B, STORE_ROOT as Bt, statedWorkspacePort as C, touchWorkspace as Ct, refreshPrContext as D, issuesOutstanding as Dt, updateReview as E, isQuestionOutstanding as Et, startJob as F, agentIdOf as Ft, forgeResolver as G, AgentCancelledError as Gt, feedbackUrl as H, agentById as Ht, readEvents as I, clearAgentPreference as It, clearClaim as J, fillFileUrlTemplate as K, AgentUnavailableError as Kt, record as L, readAgentPreference as Lt, startKissJob as M, resolveTarget as Mt, reanalyseReview as N, displayRef as Nt, isUnchanged as O, questionsOutstanding as Ot, runJob as P, git as Pt, removeWorktree as Q, recordTelemetryUploadConsent as R, writeAgentPreference as Rt, resolveWorkspacePort as S, summarise as St, RefreshUnavailableError as T, isIssueOutstanding as Tt, withUsageRecorded as U, agentFor as Ut, PACKAGE_NAME as V, AGENT_IDS as Vt, EXPLAIN_SIMPLY_PROMPT as W, detectAgents as Wt, MANAGED_ROOT as X, isClaimed as Y, readMarker as Z, writeServerRecord as _, recentReviewGroups as _t, liveJobsFor as a, saveJob as at, MIN_WORKSPACE_PORT as b, reviewedRepositories as bt, discardJob as c, followedRefName as ct, clearServerRecord as d, lineageKeyFor as dt, checkFreshness as et, ensureServer as f, lineagePosition as ft, workspaceUrl as g, previousKissResult as gt, stopServer as h, positionInLineage as ht, lineageIds as i, loadJob as it, recordKissRun as j, describeAuthorship as jt, askCheckout as k, reviewerDispositions as kt, readIndexToken as l, groupByLineage as lt, reviewsUrl as m, matchingWorkspaceIds as mt, deleteLineage as n, fail as nt, wasBlocked as o, PHASES as ot, readServerRecord as p, loadWorkspace as pt, ReviewBeingDeletedError as q, deleteReview as r, isTerminal as rt, runningJobs as s, progressSteps as st, relativeTime as t, allJobs as tt, bootstrapUrl as u, latestKissRun as ut, DEFAULT_WORKSPACE_PORT as v, recentWorkspaces as vt, writePortPreference as w, doneVerb as wt, parseWorkspacePort as x, saveWorkspace as xt, MAX_WORKSPACE_PORT as y, reviewedCommit as yt, telemetryUploadConsent as z, CONFIG_PATH as zt };
+export { allJobs as $, agentEnvOf as A, processDiscussion as At, BUILD_VERSION as B, STORE_ROOT as Bt, statedWorkspacePort as C, touchWorkspace as Ct, refreshPrContext as D, issuesOutstanding as Dt, updateReview as E, isQuestionOutstanding as Et, startJob as F, agentIdOf as Ft, forgeResolver as G, detectAgents as Gt, feedbackUrl as H, DEFAULT_AGENT_ID as Ht, readEvents as I, clearAgentPreference as It, MANAGED_ROOT as J, fillFileUrlTemplate as K, AgentCancelledError as Kt, record as L, readAgentPreference as Lt, startKissJob as M, resolveTarget as Mt, reanalyseReview as N, displayRef as Nt, isUnchanged as O, questionsOutstanding as Ot, runJob as P, git as Pt, checkFreshness as Q, recordTelemetryUploadConsent as R, writeAgentPreference as Rt, resolveWorkspacePort as S, summarise as St, RefreshUnavailableError as T, isIssueOutstanding as Tt, withUsageRecorded as U, agentById as Ut, PACKAGE_NAME as V, AGENT_IDS as Vt, EXPLAIN_SIMPLY_PROMPT as W, agentFor as Wt, removeWorktree as X, readMarker as Y, checkCodeFreshness as Z, writeServerRecord as _, recentReviewGroups as _t, liveJobsFor as a, progressSteps as at, MIN_WORKSPACE_PORT as b, reviewedRepositories as bt, discardJob as c, followedRefName as ct, clearServerRecord as d, lineageKeyFor as dt, fail as et, ensureServer as f, lineagePosition as ft, workspaceUrl as g, previousKissResult as gt, stopServer as h, positionInLineage as ht, lineageIds as i, PHASES as it, recordKissRun as j, describeAuthorship as jt, askCheckout as k, reviewerDispositions as kt, readIndexToken as l, groupByLineage as lt, reviewsUrl as m, matchingWorkspaceIds as mt, deleteLineage as n, loadJob as nt, wasBlocked as o, clearClaim as ot, readServerRecord as p, loadWorkspace as pt, ReviewBeingDeletedError as q, AgentUnavailableError as qt, deleteReview as r, saveJob as rt, runningJobs as s, isClaimed as st, relativeTime as t, isTerminal as tt, bootstrapUrl as u, latestKissRun as ut, DEFAULT_WORKSPACE_PORT as v, recentWorkspaces as vt, writePortPreference as w, doneVerb as wt, parseWorkspacePort as x, saveWorkspace as xt, MAX_WORKSPACE_PORT as y, reviewedCommit as yt, telemetryUploadConsent as z, CONFIG_PATH as zt };

package/dist/server.js

@@ -1,4 +1,4 @@
-import { $ as checkCodeFreshness, A as agentEnvOf, At as processDiscussion, B as BUILD_VERSION, Bt as STORE_ROOT, C as statedWorkspacePort, Ct as touchWorkspace, D as refreshPrContext, Dt as issuesOutstanding, E as updateReview, Et as isQuestionOutstanding, Gt as AgentCancelledError, H as feedbackUrl, I as readEvents, It as clearAgentPreference, K as fillFileUrlTemplate, Kt as AgentUnavailableError, L as record, Lt as readAgentPreference, M as startKissJob, O as isUnchanged, Ot as questionsOutstanding, P as runJob, Pt as git, Q as removeWorktree, R as recordTelemetryUploadConsent, Rt as writeAgentPreference, S as resolveWorkspacePort, T as RefreshUnavailableError, Tt as isIssueOutstanding, U as withUsageRecorded, Ut as agentFor, Vt as AGENT_IDS, W as EXPLAIN_SIMPLY_PROMPT, X as MANAGED_ROOT, Y as isClaimed, Z as readMarker, _ as writeServerRecord, _t as recentReviewGroups, a as liveJobsFor, at as saveJob, b as MIN_WORKSPACE_PORT, c as discardJob, ct as followedRefName, d as clearServerRecord, et as checkFreshness, ft as lineagePosition, gt as previousKissResult, i as lineageIds, it as loadJob, jt as describeAuthorship, k as askCheckout, kt as reviewerDispositions, l as readIndexToken, n as deleteLineage, nt as fail, o as wasBlocked, ot as PHASES, p as readServerRecord, pt as loadWorkspace, q as ReviewBeingDeletedError, r as deleteReview, rt as isTerminal, st as progressSteps, t as relativeTime$1, tt as allJobs, ut as latestKissRun, v as DEFAULT_WORKSPACE_PORT, w as writePortPreference, wt as doneVerb, x as parseWorkspacePort, xt as saveWorkspace, y as MAX_WORKSPACE_PORT, yt as reviewedCommit, z as telemetryUploadConsent } from "./relative_time-DJ9iHDDG.js";
+import { $ as allJobs, A as agentEnvOf, At as processDiscussion, B as BUILD_VERSION, Bt as STORE_ROOT, C as statedWorkspacePort, Ct as touchWorkspace, D as refreshPrContext, Dt as issuesOutstanding, E as updateReview, Et as isQuestionOutstanding, H as feedbackUrl, I as readEvents, It as clearAgentPreference, J as MANAGED_ROOT, K as fillFileUrlTemplate, Kt as AgentCancelledError, L as record, Lt as readAgentPreference, M as startKissJob, O as isUnchanged, Ot as questionsOutstanding, P as runJob, Pt as git, Q as checkFreshness, R as recordTelemetryUploadConsent, Rt as writeAgentPreference, S as resolveWorkspacePort, T as RefreshUnavailableError, Tt as isIssueOutstanding, U as withUsageRecorded, Vt as AGENT_IDS, W as EXPLAIN_SIMPLY_PROMPT, Wt as agentFor, X as removeWorktree, Y as readMarker, Z as checkCodeFreshness, _ as writeServerRecord, _t as recentReviewGroups, a as liveJobsFor, at as progressSteps, b as MIN_WORKSPACE_PORT, c as discardJob, ct as followedRefName, d as clearServerRecord, et as fail, ft as lineagePosition, gt as previousKissResult, i as lineageIds, it as PHASES, jt as describeAuthorship, k as askCheckout, kt as reviewerDispositions, l as readIndexToken, n as deleteLineage, nt as loadJob, o as wasBlocked, p as readServerRecord, pt as loadWorkspace, q as ReviewBeingDeletedError, qt as AgentUnavailableError, r as deleteReview, rt as saveJob, st as isClaimed, t as relativeTime$1, tt as isTerminal, ut as latestKissRun, v as DEFAULT_WORKSPACE_PORT, w as writePortPreference, wt as doneVerb, x as parseWorkspacePort, xt as saveWorkspace, y as MAX_WORKSPACE_PORT, yt as reviewedCommit, z as telemetryUploadConsent } from "./relative_time-D760FOL9.js";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { timingSafeEqual } from "node:crypto";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prreviewbuddy",
-  "version": "0.25.6",
+  "version": "0.25.8",
   "description": "Review a branch or pull request in an isolated checkout, from your terminal, with the coding agent you already have installed.",
   "license": "UNLICENSED",
   "homepage": "https://prreviewbuddy.com",