prreviewbuddy 0.25.7 → 0.25.13

package/dist/server.js

@@ -1,7 +1,7 @@
-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, H as feedbackUrl, I as readEvents, It as clearAgentPreference, 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 removeWorktree, 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 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, qt as AgentUnavailableError, 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-CDvK_Zaj.js";
+import { $ as checkCodeFreshness, $t as AgentCancelledError, A as liveUpdateFor, At as workspaceStamps, B as recordTelemetryUploadConsent, C as writePortPreference, D as isUnchanged, E as refreshPrContext, Et as saveWorkspace, Ft as questionsOutstanding, G as withUsageRecorded, Gt as writeAgentPreference, H as BUILD_VERSION, I as runJob, It as reviewerDispositions, J as fillFileUrlTemplate, Jt as AGENT_IDS, K as EXPLAIN_SIMPLY_PROMPT, Lt as processDiscussion, M as agentEnvOf, Mt as isIssueOutstanding, Nt as isQuestionOutstanding, O as askCheckout, Ot as touchWorkspace, P as startKissJob, Pt as issuesOutstanding, Q as removeWorktree, R as readEvents, Rt as describeAuthorship, S as statedWorkspacePort, St as recentReviewGroups, T as updateReview, Ut as clearAgentPreference, V as telemetryUploadConsent, Vt as git, W as feedbackUrl, Wt as readAgentPreference, X as MANAGED_ROOT, Y as ReviewBeingDeletedError, Z as readMarker, Zt as agentFor, _ as DEFAULT_WORKSPACE_PORT, _t as lineagePosition, a as liveJobsFor, at as loadJob, b as parseWorkspacePort, c as readIndexToken, ct as phasesFor, en as AgentUnavailableError, et as checkFreshness, f as readServerRecord, ft as isClaimed, g as writeServerRecord, ht as latestKissRun, i as lineageIds, it as isTerminal, jt as doneVerb, k as UpdateAlreadyRunningError, kt as workspaceRevision, lt as progressSteps, n as deleteLineage, nt as endedAt, o as wasBlocked, ot as saveJob, pt as followedRefName, qt as STORE_ROOT, r as deleteReview, rt as fail, s as discardJob, t as relativeTime$1, tt as allJobs, u as clearServerRecord, ut as purposeOf, v as MAX_WORKSPACE_PORT, vt as loadWorkspace, w as RefreshUnavailableError, wt as reviewedCommit, x as resolveWorkspacePort, xt as previousKissResult, y as MIN_WORKSPACE_PORT, z as record } from "./relative_time-vn8Ex9E8.js";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { timingSafeEqual } from "node:crypto";
+import { createHash, timingSafeEqual } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { createServer } from "node:http";
 //#region ../../packages/review-harness/src/domain/ai_review/review_composition.ts
@@ -2144,9 +2144,9 @@ function verdictLabel(verdict) {
 */
 var PHASE_CAVEAT = { preparing: "This can take a minute on a large repository." };
 /** The shared phase name as a sentence, with whatever this surface adds to it. */
-function phaseCopy(phase) {
-	const caveat = PHASE_CAVEAT[phase];
-	return `${PHASES[phase].doing}.${caveat ? ` ${caveat}` : ""}`;
+function phaseCopy(phase, job) {
+	const caveat = purposeOf(job) === "review" ? PHASE_CAVEAT[phase] : void 0;
+	return `${phasesFor(job)[phase].doing}.${caveat ? ` ${caveat}` : ""}`;
 }
 /**
 * The same phases, as a noun, for the retry sentence.
@@ -2204,7 +2204,7 @@ function conversationNote$1(outcome) {
 * than a gap where a sentence should be.
 */
 function phaseSentence(job) {
-	return job && isWorkPhase(job.phase) ? phaseCopy(job.phase) : "";
+	return job && isWorkPhase(job.phase) ? phaseCopy(job.phase, job) : "";
 }
 /**
 * A stopped run: what happened, and what would change it.
@@ -2248,7 +2248,7 @@ function renderJobState(job) {
   <p>${escapeHtml$1(note)}</p>
 </div>`;
 	}
-	const copy = isWorkPhase(job.phase) ? phaseCopy(job.phase) : "";
+	const copy = isWorkPhase(job.phase) ? phaseCopy(job.phase, job) : "";
 	const progress = job.progress ? ` <span class="prb-job-progress">${escapeHtml$1(job.progress)}</span>` : "";
 	return `<div class="prb-job" data-job-phase="${escapeHtml$1(job.phase)}" role="status" aria-live="polite">
   <p><span class="prb-spinner" aria-hidden="true"></span> ${escapeHtml$1(copy)}${progress}</p>
@@ -2261,7 +2261,7 @@ function jobStatus(job) {
 		progress: "",
 		failed: false
 	};
-	const progress = job.phase === "failed" ? job.failure?.message ?? "" : job.progress ?? (isWorkPhase(job.phase) ? phaseCopy(job.phase) : "");
+	const progress = job.phase === "failed" ? job.failure?.message ?? "" : job.progress ?? (isWorkPhase(job.phase) ? phaseCopy(job.phase, job) : "");
 	return {
 		phase: job.phase,
 		progress,
@@ -3121,9 +3121,10 @@ function changeIsRead(job) {
 * second renderer, and the two would disagree the first time either changed.
 */
 function renderSteps(job) {
+	const names = phasesFor(job);
 	return `<ol class="prb-progress-steps">${progressSteps(job).map((step) => {
 		const note = step.note ? `<p class="prb-progress-note" data-step-note>${escapeHtml$1(step.note)}</p>` : "";
-		return `<li class="prb-progress-step" data-phase="${escapeHtml$1(step.phase)}" data-state="${escapeHtml$1(step.state)}" data-label-doing="${escapeHtml$1(PHASES[step.phase].doing)}" data-label-done="${escapeHtml$1(PHASES[step.phase].done)}">
+		return `<li class="prb-progress-step" data-phase="${escapeHtml$1(step.phase)}" data-state="${escapeHtml$1(step.state)}" data-label-doing="${escapeHtml$1(names[step.phase].doing)}" data-label-done="${escapeHtml$1(names[step.phase].done)}">
       <span class="prb-progress-mark" aria-hidden="true"></span>
       <span class="prb-progress-label">${escapeHtml$1(step.label)}</span>
       ${note}
@@ -3165,6 +3166,25 @@ function renderProgressView(job, fileCount) {
     ${renderAvailable(job, fileCount)}
     <p class="prb-progress-elapsed" data-started-at="${job.startedAt}">Running for ${escapeHtml$1(elapsedWords(job.startedAt))}.</p>`;
 }
+/**
+* An update running over the review it is updating.
+*
+* A strip above the review rather than the progress pane, because nothing here is missing. The
+* review below is still the current one until the update applies in a single write, so it stays
+* readable and in place; taking the page over would hide the one thing worth reading while waiting.
+*
+* Nothing once the job has ended. The reload that follows an update is what reports it, through the
+* outcome notice, and a strip still standing after that would be describing work that is over.
+*/
+function renderUpdateProgress(job) {
+	if (!job || job.phase === "done" || job.phase === "failed") return "";
+	return `<div class="prb-update-progress" data-update-phase="${escapeHtml$1(job.phase)}" role="status" aria-live="polite">
+  <p class="prb-update-progress-title"><span class="prb-spinner" aria-hidden="true"></span>Updating this review</p>
+  <p class="prb-update-progress-lead">The review below stays as it is until the update finishes.</p>
+  ${renderSteps(job)}
+  <p class="prb-progress-elapsed" data-started-at="${job.startedAt}">Running for ${escapeHtml$1(elapsedWords(job.startedAt))}.</p>
+</div>`;
+}
 //#endregion
 //#region ../../packages/review-harness/src/workspace/page.ts
 function renderWorkspace(view) {
@@ -3194,13 +3214,14 @@ function renderWorkspace(view) {
 <link rel="stylesheet" href="/assets/sidebar.css">
 <link rel="stylesheet" href="/assets/shell.css">
 </head>
-<body data-api-base="${escapeHtml$1(view.apiBase)}"${view.token ? ` data-token="${escapeHtml$1(view.token)}"` : ""}${view.editor ? ` data-editor-label="${escapeHtml$1(view.editor.label)}" data-editor-template="${escapeHtml$1(view.editor.template)}"` : ""}${view.repoPath ? ` data-repo-path="${escapeHtml$1(view.repoPath)}"` : ""} data-session-id="${escapeHtml$1(view.session.id)}" data-explain-prompt="${escapeHtml$1(EXPLAIN_SIMPLY_PROMPT)}" data-way-back="${escapeHtml$1(wayBackSentence())}" data-default-view="${session.result ? "overview" : showsProgress(view) ? "progress" : "kiss"}">
+<body data-api-base="${escapeHtml$1(view.apiBase)}"${view.token ? ` data-token="${escapeHtml$1(view.token)}"` : ""}${view.editor ? ` data-editor-label="${escapeHtml$1(view.editor.label)}" data-editor-template="${escapeHtml$1(view.editor.template)}"` : ""}${view.repoPath ? ` data-repo-path="${escapeHtml$1(view.repoPath)}"` : ""}${view.revision === void 0 ? "" : ` data-workspace-revision="${escapeHtml$1(String(view.revision))}"`} data-session-id="${escapeHtml$1(view.session.id)}" data-explain-prompt="${escapeHtml$1(EXPLAIN_SIMPLY_PROMPT)}" data-way-back="${escapeHtml$1(wayBackSentence())}" data-default-view="${session.result ? "overview" : showsProgress(view) ? "progress" : "kiss"}">
 ${renderHeader(view, freshness)}
 ${showsProgress(view) ? "" : renderJobState(view.job ?? null)}
 <div class="prb-fresh-region" data-fresh-region${freshness ? ` data-report="${escapeHtml$1(JSON.stringify(freshness))}"` : ""}${view.dismissedFreshnessSha ? ` data-dismissed-sha="${escapeHtml$1(view.dismissedFreshnessSha)}"` : ""}>${renderFreshness(freshness ?? null, {
 		dismissedSha: view.dismissedFreshnessSha,
 		actions: view.token !== void 0
 	})}</div>
+${renderUpdateProgress(view.updateJob)}
 ${renderUpdateOutcome(view.lastUpdate)}
 ${renderLineageNotice(view)}
 ${renderReviewBody(view, sections)}
@@ -4131,6 +4152,21 @@ function statusLabel(status) {
 	if (status === "complete") return "Reviewed";
 	return status === "in-progress" ? "In progress" : "New";
 }
+/**
+* Whether any of that is work still going on, which is what sets the polling cadence.
+*
+* Here rather than beside `analysisStates` because this module is the DOM-free, filesystem-free
+* arithmetic both halves of the index share, and the renderer needs this one answer without
+* needing an import that reads the jobs directory to get it.
+*
+* A stopped analysis is a state, not an activity. Counting it as live would leave the index asking
+* once a second about a review that finished failing an hour ago, for as long as the tab stayed
+* open.
+*/
+function anythingRunning(states) {
+	for (const state of states.values()) if (state.phase !== "failed") return true;
+	return false;
+}
 //#endregion
 //#region ../../packages/review-harness/src/workspace/reviews_page.ts
 function renderReviewsPage(view) {
@@ -4147,7 +4183,7 @@ function renderReviewsPage(view) {
 <link rel="stylesheet" href="/assets/sidebar.css">
 <link rel="stylesheet" href="/assets/shell.css">
 </head>
-<body class="prb-index-body">
+<body class="prb-index-body"${view.revision === void 0 ? "" : ` data-index-revision="${escapeHtml$1(view.revision)}"`} data-live="${anythingRunning(view.analyses ?? /* @__PURE__ */ new Map())}">
 <header class="prb-header">
   <span class="prb-wordmark"><b>pr</b>review<b>buddy</b></span>
   <span class="prb-change-ref">Reviews</span>
@@ -4164,7 +4200,7 @@ function renderReviewsPage(view) {
     <button type="button" class="prb-index-select" data-select-mode aria-pressed="false">Select</button>
   </div>`}
   <div class="prb-cards" data-cards>
-    ${ordered.map((group) => renderCard(group, now)).join("")}
+    ${ordered.map((group) => renderCard(group, now, view.analyses?.get(group.latest.id))).join("")}
   </div>
   ${ordered.length === 0 ? `<p class="prb-index-empty">No reviews stored yet. Ask Claude Code to review a change and one will appear here.</p>` : `<p class="prb-index-none" data-no-matches hidden>Nothing matches that.</p>`}
   ${ordered.length > 15 ? renderPager() : ""}
@@ -4265,7 +4301,7 @@ function renderBulkBar() {
 * card and is shown only in selection mode, so entering that mode is a stylesheet change rather
 * than a rebuild of the list.
 */
-function renderCard(group, now) {
+function renderCard(group, now, analysis) {
 	const review = group.latest;
 	const status = statusOf(review);
 	const href = `/r/${encodeURIComponent(review.id)}?t=${encodeURIComponent(review.token)}`;
@@ -4291,7 +4327,8 @@ function renderCard(group, now) {
         ${renderRisk(review.overallRisk)}
         <span>${review.changedFiles} file${review.changedFiles === 1 ? "" : "s"}</span>
         <span class="prb-card-diffstat"><span class="prb-add">+${review.additions}</span> <span class="prb-del">&minus;${review.deletions}</span></span>
-        <span class="prb-card-left">${escapeHtml$1(whatIsLeft(review))}</span>
+        ${analysis !== void 0 && !review.hasStandardReview ? "" : `<span class="prb-card-left">${escapeHtml$1(whatIsLeft(review))}</span>`}
+        ${renderAnalysisState(analysis)}
         <span class="prb-card-when"><time datetime="${new Date(touchedAt(review)).toISOString()}" title="${escapeHtml$1(new Date(touchedAt(review)).toLocaleString())}">${escapeHtml$1(whenLabel(review, now))}</time></span>
       </p>
     </a>
@@ -4426,6 +4463,28 @@ function renderHistoryRow(review, number, latest, now) {
   </li>`;
 }
 /**
+* What is being done to this review right now, when anything is.
+*
+* The words come from `PHASES` in `job_progress.ts` and are not written again here. That table is
+* already what the terminal prints and what the review page's checklist shows, and the last time a
+* surface kept its own copy the two drifted until a stopped run read "Analysed the change" -- a
+* tick beside a verb saying the work had happened. One table, three surfaces.
+*
+* A failed analysis says so rather than saying nothing. Before this, a review being analysed, one
+* whose analysis had failed and one never analysed were the same card: all three said "No standard
+* review yet", which is true of all three and useful about none of them.
+*
+* Nothing at all for a job that is neither live nor failed. That is the non-terminal job with no
+* driver behind it -- killed terminal, crashed process -- which sits in a working phase for up to
+* half an hour before the sweep calls it stopped. Narrating it as running would be a lie, and
+* calling it stopped here would be this renderer pre-empting a decision the sweep makes.
+*/
+function renderAnalysisState(analysis) {
+	if (analysis === void 0) return "";
+	if (analysis.phase === "failed") return "<span class=\"prb-card-analysis\" data-analysis=\"stopped\">Analysis stopped</span>";
+	return `<span class="prb-card-analysis" data-analysis="running"><i></i>${escapeHtml$1(phasesFor({ purpose: analysis.purpose })[analysis.phase].doing)}</span>`;
+}
+/**
 * What this review still has open.
 *
 * Unresolved counts, not totals: "1 unanswered question" says where the review stands, where
@@ -4758,6 +4817,130 @@ function renderPrivacySection(settings) {
   </section>`;
 }
 //#endregion
+//#region ../../packages/review-harness/src/workspace/reviews_revision.ts
+/**
+* Whether anything the reviews index draws has changed, as one token.
+*
+* The index reacts to a change by reloading, which is what makes an aggregate the right shape: it
+* never needs to know *which* review changed, so it asks one question whose cost is the same for
+* five reviews and five hundred. Per-card revisions would be more information than the page has any
+* use for, and a request per card to carry it.
+*
+* Opaque and **equality only**, the same contract as `workspaceRevision` in `store.ts`: compare two
+* tokens for equality, never order them, never parse one. The implementation below is a hash of
+* facts the page happens to draw today, and the whole point of saying so here is that it can be
+* replaced by a counter, a watch, or anything else without a page having to be told.
+*
+* ## What is in it, and what is deliberately not
+*
+* In: every review's id and file revision, and the phase of every analysis running right now.
+* Between them those cover everything a card shows — the summary, the risk badge, the counts, the
+* pin, the reviewed mark, the running line — because every one of those reaches disk through
+* `writeWorkspace`, and the set of ids covers a review appearing or being deleted.
+*
+* Not in: **`job.updatedAt` and `job.progress`.** This is the load-bearing omission. An agent
+* streams its progress into the job record every few seconds, so a token derived from job file
+* mtimes would differ on nearly every poll, and a page that reloads whenever the token differs
+* would then reload every few seconds for the whole length of an analysis — a page thrashing
+* itself, with the reviewer's scroll position going with it. Phase only, which changes four times
+* in a run.
+*/
+/**
+* What is being done to each review, or was last done and stopped.
+*
+* Keyed by review, valued by the phase the card should name. Two states reach it and a third
+* deliberately does not:
+*
+* - **Running.** A job that is not terminal *and* whose driver holds a live claim. The claim is the
+*   load-bearing half: a job whose driver was killed sits in a working phase for up to half an hour
+*   before the sweep calls it stopped, and narrating one of those as "Analysing the change" would
+*   be the index confidently reporting work that nothing is doing.
+* - **`failed`.** Reported whether or not anything still holds the claim, which is the whole reason
+*   this function is not simply `runningJobs`. It was: `runningJobs` drops terminal jobs, and
+*   `isTerminal` counts `failed` as terminal, so a failed analysis could never reach the renderer
+*   and the card's "Analysis stopped" branch was unreachable in production while passing a unit
+*   test that handed it a state the product could not produce. A review whose analysis failed went
+*   back to reading "No standard review yet" the moment its driver let go.
+* - **`done`, and an unclaimed job still in a working phase.** Nothing. A finished job has its
+*   result on the card already, and an abandoned one is the sweep's to judge rather than this
+*   renderer's to pre-empt.
+*
+* **Every job a review has, not the latest one.** A review accumulates them -- a standard analysis,
+* a KISS run, a retry -- and two of them genuinely run at once: `handleKiss` refuses only a second
+* KISS run, and the review page's poll is built around one finishing while the other goes on. An
+* earlier cut picked the single newest job and then asked what it was, so a KISS run that ended
+* first spoke for a standard analysis that was still working, and the card fell silent on work that
+* was happening in front of the reviewer.
+*
+* So the precedence is running, then the most recent ending, and it is stated in that order because
+* that is the property: **nothing that has ended can hide something that has not.**
+*
+* `jobs` is injected only so a test can hand the same set in two different orders and prove the
+* answer does not move. Production always reads the directory.
+*
+* A failure is visible for as long as the job record survives, which is the sweep's retention. Once
+* that passes the card quietly returns to saying nothing, which is the same silence every review
+* had before this existed.
+*/
+function analysisStates(now = Date.now(), jobs = allJobs()) {
+	const byReview = /* @__PURE__ */ new Map();
+	for (const job of jobs) {
+		if (purposeOf(job) === "ask") continue;
+		const held = byReview.get(job.workspaceId);
+		if (held) held.push(job);
+		else byReview.set(job.workspaceId, [job]);
+	}
+	/**
+	* Both comparators are **total**, and that is a requirement rather than tidiness.
+	*
+	* `allJobs` reads a directory, so a tie leaves the winner to whatever order the filesystem
+	* happened to return. This function's output is hashed into the index token, and the page reloads
+	* whenever that token changes -- so an arbitrary winner is not a cosmetic wobble, it is the page
+	* reloading itself for as long as the tie exists, with no cause a reviewer could ever see. The
+	* same hazard the sorting rule was written for, one level further down.
+	*
+	* Ties are real. Two jobs can carry the same timestamp to the millisecond, and a record written
+	* before `finishedAt` existed falls back to `updatedAt`, which two records can share. The id is
+	* the last resort because it is the only field guaranteed to differ.
+	*/
+	const byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+	const startedLast = (a, b) => b.startedAt - a.startedAt || byId(a, b);
+	const endedLast = (a, b) => endedAt(b) - endedAt(a) || b.startedAt - a.startedAt || byId(a, b);
+	const states = /* @__PURE__ */ new Map();
+	for (const [reviewId, jobs] of byReview) {
+		const running = jobs.filter((job) => !isTerminal(job) && isClaimed(job.id, now)).sort(startedLast);
+		if (running.length > 0) {
+			states.set(reviewId, {
+				phase: running[0].phase,
+				purpose: purposeOf(running[0])
+			});
+			continue;
+		}
+		if (jobs.filter((job) => isTerminal(job) && purposeOf(job) === "review").sort(endedLast)[0]?.phase === "failed") states.set(reviewId, {
+			phase: "failed",
+			purpose: "review"
+		});
+	}
+	return states;
+}
+/**
+* The token.
+*
+* Takes the live analyses rather than reading them, so that one request answers with a token and a
+* running state that describe the same instant. Computing them separately would let a phase change
+* land between the two, and the page would then be told "nothing has changed" alongside a state it
+* had not seen.
+*/
+function reviewsRevision(live = analysisStates()) {
+	const hash = createHash("sha1");
+	for (const [id, revision] of workspaceStamps()) hash.update(`${id}:${revision}\n`);
+	for (const id of [...live.keys()].sort()) {
+		const state = live.get(id);
+		hash.update(`${id}@${state.purpose}:${state.phase}\n`);
+	}
+	return hash.digest("base64url");
+}
+//#endregion
 //#region ../../packages/review-harness/src/workspace/ask.ts
 /** Long enough for a real look at the repository; short enough that a hang is not forever. */
 var ASK_TIMEOUT_MS = 18e4;
@@ -5420,6 +5603,64 @@ var CONTENT_TYPES = {
 	".woff2": "font/woff2",
 	".png": "image/png"
 };
+/**
+* The freshness policy, in three classes and one place.
+*
+* Every response this server sends falls into exactly one of them, and which one is decided by the
+* helper that writes it rather than by the route that produced it. That is the whole shape of this:
+* a route may not have an opinion about caching, because the bug this replaced was four HTML
+* responses that each said nothing and were each individually reasonable.
+*
+*     mutable workspace state  ->  no-store    never stored, so never reused
+*     fingerprinted asset      ->  immutable   reused indefinitely; the hash is the identity
+*     other static asset       ->  no-cache    may be stored, must revalidate before reuse
+*
+* `no-cache` is a rule about reuse and not a ban on storage, which is the thing about these two
+* names that is worth saying out loud once: the assets already carried it while the pages, which
+* are the things that actually change, carried nothing at all. A reviewer marked a review reviewed,
+* pressed Back, and was shown the list as it had been — and the server had been right the whole
+* time, because it was never asked.
+*
+* The browser half of the same policy is `reloadOnRestore` in `client/page_restore.ts`. Nothing
+* here reaches the back/forward cache reliably: a restored page is a frozen document being thawed
+* rather than a stored response being reused, and browsers disagree about whether `no-store` should
+* keep a document out of that cache. Only the page itself can refuse its own restoration.
+*/
+var NO_STORE = "no-store";
+var REVALIDATE = "no-cache";
+var IMMUTABLE = "public, max-age=31536000, immutable";
+/**
+* Whether this asset's name encodes its content, which is the only thing that makes `immutable`
+* safe to say about it.
+*
+* The names come from `vite.client.ts`, which emits `chunk-[hash].js` for everything the bundler
+* split out and a bare `[name].js` for the three page entries. So the chunks may be kept forever —
+* a new build produces new names and the old ones are simply never asked for again — while
+* `workspace.js`, the stylesheets, the font and the icon are all names that survive an upgrade
+* with different content behind them, and must be revalidated every time they are reused.
+*
+* `freshness_policy.test.ts` holds this to the vite option it is derived from. The two halves are
+* in different packages' build config and source, and a change to the emitted name would otherwise
+* turn "cache forever" from safe into a stale asset nobody can clear.
+*/
+function isFingerprinted(name) {
+	return /^chunk-/.test(name);
+}
+/**
+* An HTML document, which is always a view of mutable workspace state.
+*
+* Every HTML response goes through here. There is no second way to write one, and
+* `freshness_policy.test.ts` is what keeps it that way: the cost of this bug was not that somebody
+* chose wrong, it was that four routes each got to choose.
+*/
+function sendHtml(res, status, html, cookie) {
+	res.writeHead(status, {
+		"content-type": "text/html; charset=utf-8",
+		"cache-control": NO_STORE,
+		...cookie ? { "set-cookie": cookie } : {}
+	});
+	res.end(html);
+}
 function createWorkspaceServer(options = {}) {
 	return createServer((req, res) => {
 		handle(req, res, options).catch((error) => {
@@ -5443,6 +5684,7 @@ async function handle(req, res, options) {
 	if (url.pathname === "/pin") return handlePin(req, res, options.indexToken);
 	if (url.pathname === "/delete") return handleDelete(req, res, options.indexToken);
 	if (url.pathname === "/status") return handleStatus(req, res, options.indexToken);
+	if (url.pathname === "/revision") return handleRevision(req, res, options.indexToken);
 	const match = /^\/(?:r|api)\/([0-9a-f-]{36})(\/[a-z]+)?$/.exec(url.pathname);
 	if (!match) return send(res, 404, { error: "Not found" });
 	const [, id, action] = match;
@@ -5451,7 +5693,7 @@ async function handle(req, res, options) {
 	if (!tokenMatches(workspace, url.searchParams.get("t"))) return send(res, 403, { error: "This link is missing its access token." });
 	if (url.pathname.startsWith("/r/")) {
 		touchWorkspace(workspace);
-		return sendHtml(res, workspace);
+		return sendWorkspacePage(res, workspace);
 	}
 	if (action === "/job") return send(res, 200, jobReport(workspace));
 	if (action === "/retry") return handleRetry(res, workspace);
@@ -5525,12 +5767,12 @@ function handleIndex(req, res, params, indexToken) {
 	}
 	const cookie = indexCookieHeader(indexToken);
 	if (onward) return redirect(res, onward, cookie);
-	const html = renderReviewsPage({ groups: recentReviewGroups(MAX_LISTED_BRANCHES) });
-	res.writeHead(200, {
-		"content-type": "text/html; charset=utf-8",
-		"set-cookie": cookie
-	});
-	res.end(html);
+	const states = analysisStates();
+	sendHtml(res, 200, renderReviewsPage({
+		groups: recentReviewGroups(MAX_LISTED_BRANCHES),
+		analyses: states,
+		revision: reviewsRevision(states)
+	}), cookie);
 }
 /**
 * Where `?go=` is allowed to send someone, which is one shape and no other.
@@ -5547,6 +5789,7 @@ function safeDestination(value) {
 function redirect(res, location, cookie) {
 	res.writeHead(302, {
 		location,
+		"cache-control": NO_STORE,
 		...cookie ? { "set-cookie": cookie } : {}
 	});
 	res.end();
@@ -5569,8 +5812,7 @@ function redirect(res, location, cookie) {
 function refuseIndex(req, res) {
 	const way = wayBack();
 	if (!wantsHtml(req)) return send(res, 403, { error: `This link is missing its access token. Run ${wayBackSentence(way)} to get the current one.` });
-	res.writeHead(403, { "content-type": "text/html; charset=utf-8" });
-	res.end(page("Your reviews", `<h1>This browser has not been shown your reviews yet</h1>
+	sendHtml(res, 403, page("Your reviews", `<h1>This browser has not been shown your reviews yet</h1>
       <p>Nothing is lost. Every review is still here, and the link you came from still works. The
       list has its own credential, separate from the one that opens a single review, so a review
       page is not able to hand it over.</p>
@@ -5614,12 +5856,7 @@ async function handleSettings(req, res, params, indexToken) {
 			error
 		});
 	}
-	const html = renderSettingsPage({ settings: readSettings() });
-	res.writeHead(200, {
-		"content-type": "text/html; charset=utf-8",
-		"set-cookie": indexCookieHeader(indexToken)
-	});
-	res.end(html);
+	sendHtml(res, 200, renderSettingsPage({ settings: readSettings() }), indexCookieHeader(indexToken));
 }
 /**
 * Whether the caller is a browser navigating, rather than something reading the API.
@@ -5693,6 +5930,34 @@ async function handleStatus(req, res, indexToken) {
 	});
 }
 /**
+* Has anything the reviews index draws changed, and is anything still being made.
+*
+* The whole of the index's liveness, in one request that costs the same whether the machine holds
+* five reviews or five hundred. The page reloads when `revision` differs from the one it was
+* rendered with; it never needs to know which review changed, because its answer to any change is
+* the same answer.
+*
+* Both fields describe one instant, which is why `liveAnalyses` is read once and passed in rather
+* than read twice. Computed separately, a phase could change between them and the page would be
+* told nothing had changed alongside a running state it had not seen.
+*
+* `live` sets the **cadence**, never whether to poll. A page that renders with nothing running
+* still has to learn that a review was started from a terminal somewhere, and a page whose work has
+* finished has to slow down without needing a reload to be told. See `client/reviews.ts`.
+*
+* Authorised by the index credential like `/pin`, `/delete` and `/status`, because this is the list
+* asking about itself. Flat rather than under `/api/`, which is the per-review namespace and whose
+* route requires a review id this question does not have.
+*/
+function handleRevision(req, res, indexToken) {
+	if (!indexToken || !secretMatches(indexToken, indexCookie(req))) return send(res, 403, { error: "Not authorised." });
+	const states = analysisStates();
+	send(res, 200, {
+		revision: reviewsRevision(states),
+		live: anythingRunning(states)
+	});
+}
+/**
 * Pin or unpin a review.
 *
 * Authorised by the index credential rather than the review's own, because pinning is a fact about
@@ -5876,7 +6141,7 @@ function recordWorkspaceOpened(workspace) {
 	const event = workspaceOpenedEvent(workspace);
 	if (event) record(event);
 }
-async function sendHtml(res, workspace) {
+async function sendWorkspacePage(res, workspace) {
 	const freshness = await freshnessOrNull(workspace);
 	const kissFreshness = await kissFreshnessOrNull(workspace);
 	const kissRun = latestKissRun(workspace);
@@ -5909,8 +6174,10 @@ async function sendHtml(res, workspace) {
 		lastUpdate: notice,
 		diagrams: workspace.diagrams,
 		reviewedSha: reviewedCommit(workspace),
+		revision: workspaceRevision(workspace),
 		lineage: lineagePosition(workspace),
 		job: workspace.jobId ? loadJob(workspace.jobId) : void 0,
+		updateJob: liveUpdateFor(workspace.id),
 		kissRun,
 		kissJob: kissRun ? loadJob(kissRun.jobId) : void 0,
 		kissFreshness,
@@ -5925,8 +6192,7 @@ async function sendHtml(res, workspace) {
 		code: freshness.code.state,
 		checkout: freshness.checkout.state
 	});
-	res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
-	res.end(html);
+	sendHtml(res, 200, html);
 }
 function sendAsset(res, pathname) {
 	const name = pathname.slice(8);
@@ -5936,7 +6202,7 @@ function sendAsset(res, pathname) {
 	const ext = name.slice(name.lastIndexOf("."));
 	res.writeHead(200, {
 		"content-type": CONTENT_TYPES[ext] ?? "application/octet-stream",
-		"cache-control": "no-cache"
+		"cache-control": isFingerprinted(name) ? IMMUTABLE : REVALIDATE
 	});
 	res.end(body);
 }
@@ -5998,7 +6264,8 @@ function jobReport(workspace) {
 	const kissRun = latestKissRun(workspace);
 	return {
 		...jobStatus(workspace.jobId ? loadJob(workspace.jobId) : null),
-		kiss: jobStatus(kissRun ? loadJob(kissRun.jobId) : null)
+		kiss: jobStatus(kissRun ? loadJob(kissRun.jobId) : null),
+		update: jobStatus(liveUpdateFor(workspace.id))
 	};
 }
 /**
@@ -6011,10 +6278,12 @@ function jobReport(workspace) {
 async function handleFreshness(res, workspace) {
 	const kiss = await kissFreshnessOrNull(workspace);
 	const report = await freshnessOrNull(workspace);
+	const revision = workspaceRevision(workspace) ?? null;
 	if (!report) return send(res, 200, {
 		report: null,
 		kiss,
-		kissDismissedSha: workspace.dismissedKissFreshnessSha ?? null
+		kissDismissedSha: workspace.dismissedKissFreshnessSha ?? null,
+		revision
 	});
 	record({
 		event: "freshness_checked",
@@ -6027,7 +6296,8 @@ async function handleFreshness(res, workspace) {
 		report,
 		dismissedSha: workspace.dismissedFreshnessSha ?? null,
 		kiss,
-		kissDismissedSha: workspace.dismissedKissFreshnessSha ?? null
+		kissDismissedSha: workspace.dismissedKissFreshnessSha ?? null,
+		revision
 	});
 }
 /**
@@ -6095,6 +6365,7 @@ async function handleUpdate(res, workspace) {
 	try {
 		outcome = await updateReview(workspace);
 	} catch (error) {
+		if (error instanceof UpdateAlreadyRunningError) return send(res, 409, { error: error.message });
 		outcome = {
 			at: Date.now(),
 			ok: false,
@@ -6385,7 +6656,10 @@ async function readJson(req) {
 	}
 }
 function send(res, status, payload) {
-	res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": NO_STORE
+	});
 	res.end(JSON.stringify(payload));
 }
 var ASK_SOURCES = [
@@ -6506,16 +6780,12 @@ async function sweep(now = Date.now()) {
 			if (markAbandoned(job, now)) report.abandoned += 1;
 			continue;
 		}
-		if (now - finishedAt(job) < 216e5) continue;
+		if (now - endedAt(job) < 216e5) continue;
 		if (await retire(job, report)) report.retired += 1;
 	}
 	await removeOrphans(jobs, report);
 	return report;
 }
-/** When this job stopped doing work. `finishedAt` predates nothing, but a record can be old. */
-function finishedAt(job) {
-	return job.finishedAt ?? job.updatedAt;
-}
 /**
 * Record that a job stopped, unless it has moved since this pass read it.
 *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prreviewbuddy",
-  "version": "0.25.7",
+  "version": "0.25.13",
   "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",