prreviewbuddy 0.91.1 → 0.93.0

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

@@ -4213,6 +4213,11 @@ var IMPACT_GROUPS = [
 	"intent",
 	"maintenance"
 ];
+var STEP_KINDS = [
+	"verify",
+	"decide",
+	"fix"
+];
 /**
 * The JSON in a reply, whether or not the model wrapped it in a fence.
 *
@@ -4414,11 +4419,33 @@ function normalizeStep(value) {
 	const item = value;
 	const text = asString$1(item.text).trim();
 	if (!text) return void 0;
-	return item.kind === "verify" || item.kind === "decide" ? {
+	return STEP_KINDS.includes(item.kind) ? {
 		kind: item.kind,
 		text
 	} : { text };
 }
+/**
+* A question's scan-first framing, or nothing.
+*
+* Well-formedness only, the consequence's rule: a framing with no question or no reason has nothing
+* to say and is dropped, so the card shows the original question rather than an empty headline.
+*/
+function normalizeQuestionFraming(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const item = value;
+	const question = asString$1(item.question).trim();
+	const why = asString$1(item.why).trim();
+	if (!question || !why) return void 0;
+	const needed = asString$1(item.needed).trim();
+	return {
+		question,
+		why,
+		...needed ? { needed } : {}
+	};
+}
+function withFraming(framing) {
+	return framing ? { framing } : {};
+}
 /** Spread form, so an issue without one carries no `consequence` key at all. */
 function withConsequence(consequence) {
 	return consequence ? { consequence } : {};
@@ -4449,7 +4476,8 @@ function normalizeQuestions(value) {
 			importance: REVIEW_ATTENTIONS.includes(item.importance) ? item.importance : void 0,
 			whyThisMatters: typeof item.whyThisMatters === "string" ? item.whyThisMatters : void 0,
 			file: typeof item.file === "string" ? item.file : void 0,
-			sectionId: asSectionId(item)
+			sectionId: asSectionId(item),
+			...withFraming(normalizeQuestionFraming(item.framing))
 		};
 	}).filter((question) => question.question.trim() !== "");
 }
@@ -5739,6 +5767,20 @@ function reviewerDispositions(session) {
 		isStale: (issue) => issue.reconciliationStatus === "affected" && (byId.get(issue.id)?.sessionId ?? session.id) !== session.id
 	};
 }
+function framableFindings(session) {
+	const dispositions = reviewerDispositions(session);
+	const answered = new Set(session.answeredQuestionIds ?? []);
+	const verdicts = verdictClosure(session);
+	return {
+		issue: (issue) => isIssueOutstanding(issue, dispositions),
+		question: (question) => isQuestionOutstanding(question, answered, verdicts.question)
+	};
+}
+/** For a caller with no session: nothing may gain framing. */
+var NOTHING_FRAMABLE = {
+	issue: () => false,
+	question: () => false
+};
 /**
 * An issue is done when the commits fixed it, or when the reviewer dismissed it and that decision
 * still stands.
@@ -7699,9 +7741,34 @@ var UPDATE_ORDER = [
 	"context",
 	"analysing"
 ];
+/**
+* The same phases, as a Re-check of the pull request discussion runs them. Nothing is fetched, so
+* there is no `preparing` step to show, and the checkout is of the commit the review read.
+*/
+var RECHECK_PHASES = {
+	...UPDATE_PHASES,
+	conversation: {
+		doing: "Fetching the PR discussion",
+		done: "Fetched the PR discussion"
+	},
+	context: {
+		doing: "Preparing the reviewed code",
+		done: "Prepared the reviewed code"
+	},
+	analysing: {
+		doing: "Reassessing issues and questions",
+		done: "Reassessed issues and questions"
+	}
+};
+var RECHECK_ORDER = [
+	"conversation",
+	"context",
+	"analysing"
+];
 /** The names this job's phases go by. */
 function phasesFor(job) {
-	return purposeOf(job) === "update" ? UPDATE_PHASES : PHASES;
+	if (purposeOf(job) !== "update") return PHASES;
+	return job.scope === "conversation" ? RECHECK_PHASES : UPDATE_PHASES;
 }
 /**
 * Whether a phase is part of *this* review, rather than part of the pipeline in general.
@@ -7741,7 +7808,7 @@ function progressSteps(job) {
 	const failedAt = job.phase === "failed" ? job.failure?.phase : void 0;
 	const update = purposeOf(job) === "update";
 	const names = phasesFor(job);
-	const order = (update ? UPDATE_ORDER : WORK_PHASES).filter((phase) => appliesTo(job, phase));
+	const order = (update ? job.scope === "conversation" ? RECHECK_ORDER : UPDATE_ORDER : WORK_PHASES).filter((phase) => appliesTo(job, phase));
 	return (update && job.phase === "done" ? order.filter((phase) => job.completed.includes(phase)) : order).map((phase) => {
 		const complete = job.completed.includes(phase) || !update && job.phase === "done";
 		const failed = failedAt === phase;
@@ -7834,6 +7901,7 @@ function strippedForDeletedReview(job) {
 		},
 		...job.purpose ? { purpose: job.purpose } : {},
 		...job.reanalysis ? { reanalysis: true } : {},
+		...job.scope ? { scope: job.scope } : {},
 		...job.reviewType ? { reviewType: job.reviewType } : {},
 		phase: job.phase,
 		startedAt: job.startedAt,
@@ -12557,14 +12625,20 @@ var SUMMARY_GUIDANCE = `"summary": WHAT the change does, for a reviewer about to
 * extension's investigation cannot drift apart. The fragment is the whole shape, never an
 * abbreviation: a model cannot follow a schema it was not shown.
 */
-var CONSEQUENCE_FIELD = "\"consequence\": { \"title\": string, \"scenario\": string, \"group\": \"failure\" | \"risk\" | \"intent\" | \"maintenance\", \"next\"?: { \"kind\": \"verify\" | \"decide\", \"text\": string } }";
+var CONSEQUENCE_FIELD = "\"consequence\": { \"title\": string, \"scenario\": string, \"group\": \"failure\" | \"risk\" | \"intent\" | \"maintenance\", \"next\"?: { \"kind\": \"verify\" | \"decide\" | \"fix\", \"text\": string } }";
 /** The same shape on a prior finding's entry in an update, where null withdraws it and absence keeps it. */
 var CONSEQUENCE_REVISION_FIELD = `${CONSEQUENCE_FIELD.replace("\"consequence\": ", "\"consequence\"?: ")} | null`;
 var CONSEQUENCE_GUIDANCE = `"consequence" on an issue: the same issue told as what it means, for someone who knows the product but may not know its implementation. It is shown first; "title" and "description" stay the technical account behind it. Reframe around the consequence, do not just simplify the technical wording.
   - "title": the observable consequence or the meaningful development constraint, as a short sentence (e.g. "Creating a meal can fail halfway, leaving it outside the planner").
   - "scenario": one or two sentences: the triggering condition and what happens (e.g. "If adding it to the day fails after saving, the user sees an error but the meal still exists. Retrying may then be blocked by its name.").
-  - "next": the one step that would settle it, when there is a specific one. "kind" is "verify" for a check or test that would establish whether it happens (e.g. "Try a receipt with an unreadable amount.") and "decide" for an acceptance or intent call only the reviewer can make (e.g. "Confirm this broader change is intended."). Omit "next" rather than writing a generic step.
-  - "group", by the evidence behind the issue, never by how sure you sound and independently of "severity": "failure" when the code you read establishes an incorrect outcome under a stated condition; "risk" when a plausible undesirable consequence still needs verifying; "intent" when the change has a concrete behavioural consequence whose correctness depends on what was intended; "maintenance" when it constrains future development, maintainability or reliability rather than current behaviour. "confidence" is reported separately and does not decide the group: if the evidence does not establish the failure, it is a "risk", and say what is unverified.
+  - "next": the one specific step this issue calls for, when there is one. "kind" is "verify" for a test or evidence-gathering step that would settle whether it happens (e.g. "Try a receipt with an unreadable amount."), "decide" for an acceptance, requirement or intent call only the reviewer can make (e.g. "Confirm this broader change is intended."), and "fix" for a concrete corrective action the finding itself supports (e.g. "Update the recovery runbook to name the new restore command."). A fix is not a verification: do not label a remedy "verify". Omit "next" rather than write a generic step or invent a remedy the evidence does not support.
+  - "group", by the consequence and the evidence behind it, never by the kind of file, never by how sure you sound and independently of "severity":
+    - "failure" when the evidence you read establishes an incorrect outcome under a stated condition (e.g. "Saving a meal with no ingredients deletes the existing ones.").
+    - "risk" when a plausible adverse consequence still needs verifying (e.g. "Two people editing the same plan at once may overwrite each other; nothing shows whether saves are serialised."), and say what is unverified.
+    - "intent" when there is a concrete behavioural consequence whose acceptability depends on requirements or intent (e.g. "Rotating the sign-in secret now signs every customer out.").
+    - "maintenance" when it constrains future development, maintainability or reliability and no concrete failure or risk fits better (e.g. "Each new payment provider has to be added in four places that must stay in step.").
+    - Documentation, runbooks, configuration and scripts are classified by what they cause like any code: recovery instructions that restore to the wrong database cause an operational failure when the text establishes it, or a risk when unverified. They are not "maintenance" because they are documentation.
+    - "confidence" is reported separately and does not decide the group. A well-evidenced failure stays a failure at medium confidence; a high severity does not make an unverified risk a failure; a low confidence does not by itself turn a failure into a risk.
   - Keep every condition and qualification that affects the decision. Avoid code identifiers unless the consequence cannot be understood without one. Do not state severity.
   - Never claim user harm, a measured performance effect, a reproduction or a certainty the evidence does not give. A performance concern nobody measured says so (e.g. "Opening a meal may do unnecessary work for nested meals... The effect has not been measured."). A maintenance or intent issue is described as one, not as a user-facing failure.
   - An issue names a concrete consequence. A request for missing requirements with no concrete consequence is a question for the author, not an issue, and is never raised as both.`;
@@ -12578,20 +12652,40 @@ var ORIENTATION_GUIDANCE = `"orientation": one sentence, at most about 25 words,
 * consequence that no longer describes the finding is worse than none, so the model is shown each
 * one and must keep, restate or withdraw it.
 */
-var CONSEQUENCE_UPDATE_GUIDANCE = `"consequence" on a finding entry: a finding marked [consequence: ...] has an impact summary the reviewer reads first. Omit "consequence" when it still describes the finding accurately, which is the usual case. Return a restated "consequence" (same shape as on a new issue) when what has changed since alters the condition, the evidence, the next step or the group it describes, most often for an "affected" finding. Return null when it no longer holds and you cannot restate it accurately. Never return "consequence" for a finding without a [consequence: ...] marker.
+var CONSEQUENCE_UPDATE_GUIDANCE = `"consequence" on a finding entry: a finding marked [consequence: ...] has an impact summary the reviewer reads first. Omit "consequence" when it still describes the finding accurately, which is the usual case. Return a restated "consequence" (same shape as on a new issue) when what has changed since alters the condition, the evidence, the next step or the group it describes, most often for an "affected" finding. Return null when it no longer holds and you cannot restate it accurately.
+A finding marked [consequence: none yet, write one] is still outstanding and has no impact summary: unless you mark it "resolved", return a "consequence" for it, written from the evidence its description already gives together with anything these changes show. Classify it into whichever of the four groups that evidence supports; do not default to "risk", and do not demand fresh proof to keep a failure the existing evidence already establishes. Keep its uncertainty as stated: rewording a finding is not re-verifying it, so never describe it as newly confirmed or tested. Never return "consequence" for a finding with neither marker.
 "resolvedBehaviour" on a finding entry: only with "resolved", and only when the changed code shows what now happens under the finding's condition, in one sentence for someone who knows the product (e.g. "If adding the meal to the planner fails, the meal is no longer saved."). Omit it when the code does not show that, and whenever the finding is settled by a comment rather than by code.`;
 /**
 * The impact summary the reviewer reads first, shown under a prior finding so a later pass can keep,
 * restate or withdraw it (`CONSEQUENCE_UPDATE_GUIDANCE`, and the investigation's own rule). Group
-* and step are included: either can go stale on its own. A finding stored without one shows
-* nothing, which is also what tells the model not to add one.
+* and step are included: either can go stale on its own. A finding stored without one is marked
+* as needing one only when the update may add it (`framable`, an outstanding finding); otherwise it
+* shows nothing, which is what tells the model not to add one.
 */
-function formatPriorConsequence(issue) {
+function formatPriorConsequence(issue, framable = false) {
 	const consequence = issue.consequence;
-	if (!consequence) return "";
+	if (!consequence) return framable ? "\n   [consequence: none yet, write one]" : "";
 	const next = consequence.next ? ` Next (${consequence.next.kind ?? "step"}): ${consequence.next.text}` : "";
 	return `\n   [consequence: group ${consequence.group ?? "none"}] ${consequence.title.trim().replace(/[.!?]$/, "")}. ${consequence.scenario.trim()}${next}`;
 }
+/** A question's scan-first framing, as every prompt that asks questions asks for it. The whole shape. */
+var QUESTION_FRAMING_FIELD = "\"framing\": { \"question\": string, \"why\": string, \"needed\"?: string }";
+/** The same shape on a prior question's entry in an update, where null withdraws it and absence keeps it. */
+var QUESTION_FRAMING_REVISION_FIELD = `${QUESTION_FRAMING_FIELD.replace("\"framing\": ", "\"framing\"?: ")} | null`;
+var QUESTION_FRAMING_GUIDANCE = `"framing" on a question: the same question, asked so a reviewer who knows the product but not the code can see at a glance what is being asked and why. It is shown first; the original "question" and "whyThisMatters" stay the technical account behind it. It is a presentation of this question, never a second one.
+  - "question": short, at product or operations level (e.g. "Should rotating the sign-in secret require all customers to sign in again?").
+  - "why": one or two sentences on why the answer matters, keeping every condition and uncertainty (e.g. "The current encryption ties stored sessions to that secret."). A conditional premise stays conditional: do not turn "if" into a fact.
+  - "needed": the specific answer or confirmation required, when the question does not already make it plain (e.g. "Confirm whether this consequence is acceptable and documented."). Omit it otherwise.
+  - A question with several parts names every part, so none is lost from view. Do not answer the question in its framing.`;
+var QUESTION_FRAMING_UPDATE_GUIDANCE = `"framing" on a question entry: a question marked [framing: ...] has a short framing the reviewer reads first. Omit "framing" when it still describes the question accurately. Return a restated "framing" (same shape as on a new question) when these changes alter what is being asked, its condition or what is needed; in particular, when you mark a question "answered" or the changes answer part of it, restate it to name only what is still open, or return null if nothing in it still needs asking. Return null when it no longer holds and you cannot restate it.
+A question marked [framing: none yet, write one] is still outstanding and has no framing: unless you mark it "answered", return a "framing" for it from what the question and its reasons already say together with anything these changes show, keeping its conditions and uncertainty. Never return "framing" for a question with neither marker.`;
+/** A prior question's framing, or the marker asking for one, as the update shows it. */
+function formatPriorFraming(question, framable = false) {
+	const framing = question.framing;
+	if (!framing) return framable ? "\n   [framing: none yet, write one]" : "";
+	const needed = framing.needed ? ` Needed: ${framing.needed.trim()}` : "";
+	return `\n   [framing] ${framing.question.trim()} ${framing.why.trim()}${needed}`;
+}
 //#endregion
 //#region ../../packages/review-harness/src/domain/discussion/discussion_delta.ts
 /**
@@ -13371,7 +13465,7 @@ var STRUCTURED_OUTPUT_INSTRUCTIONS = `In addition to the review principles above
     "recommendedStartingPoint": boolean
   }],
   "issues": [{ "id": string, "severity": "critical" | "major" | "minor" | "nit", "title": string, "description": string, "file"?: string, "line"?: number, "sectionId"?: string, "confidence"?: "high" | "medium" | "low", ${CONSEQUENCE_FIELD}, "existingDiscussion"?: { "threadId": string, "relation": "same" | "related" } }],
-  "questions": [{ "id": string, "question": string, "importance"?: "high" | "medium" | "low", "whyThisMatters"?: string, "file"?: string, "sectionId"?: string }],
+  "questions": [{ "id": string, "question": string, "importance"?: "high" | "medium" | "low", "whyThisMatters"?: string, ${QUESTION_FRAMING_FIELD}, "file"?: string, "sectionId"?: string }],
   "recommendation": string,
   "nextSteps": string[]
 }
@@ -13391,6 +13485,7 @@ Field guidance:
 - "nextSteps": concrete actions to take before merging (specific tests to run, files to double-check), not a restatement of the Guide.
 - "issues": report only issues worth the reviewer's attention — do not invent issues to fill out the array, and do not omit significant issues. Let the count reflect the actual PR (a trivial PR may have zero or one issue; a large or risky PR may have several).
 - ${CONSEQUENCE_GUIDANCE}
+- ${QUESTION_FRAMING_GUIDANCE}
 - ${ORIENTATION_GUIDANCE}
 - "existingDiscussion" on an issue: set this only when a thread in the PR DISCUSSION CONTEXT block already raises this same concern, and you have independently confirmed from the diff that it still applies. "threadId" must be copied verbatim from that thread's [T_...] marker — never invent an id, never guess, and omit the field entirely if no thread matches. Set "relation" to "same" when the thread already makes this exact point, or "related" when it discusses this area without covering the finding — a reviewer acts differently on "someone said this already" than on "someone was looking near here". Still write the issue normally; this field only records that the point was raised before, so the reviewer is not shown it as a fresh discovery. Do not use it to pad the review with issues you would otherwise have left out.
 - "confidence" on an issue: how sure you are the issue is real, on the same high/medium/low scale as a question's "importance". This is a separate axis from "severity", which is how much it would matter if real — a critical issue you are unsure about and a nit you are certain of are different things to act on, so do not let one field stand in for the other. Use LOW when you are reasoning from a diff excerpt without the surrounding code, and say what would confirm it in the description. Omit the field rather than guessing a middle value.
@@ -18089,13 +18184,13 @@ function priorFindingVerdict(issue, flag) {
 * reviewer may have moved it, and a model told only the analysis's grade would re-judge from where
 * the review no longer stands. A caller with no ledger passes `ANALYSIS_ONLY`.
 */
-function formatPriorFindings(issues, assess, reassess = /* @__PURE__ */ new Map(), status = NO_STATUS) {
+function formatPriorFindings(issues, assess, reassess = /* @__PURE__ */ new Map(), status = NO_STATUS, framable = NOTHING_FRAMABLE) {
 	if (!issues.length) return "(The previous analysis raised no issues.)";
 	return issues.map((issue, index) => {
 		const related = (issue.relatedFiles ?? []).map((file) => ` [related: ${file}, not changed]`).join("");
 		const location = (issue.file ? ` [${issue.file}${issue.line ? `:${issue.line}` : ""}]` : "") + related;
 		const description = issue.description.trim();
-		return `${index}. (${promptGrade(assess("issue", issue))})${location}${priorFindingVerdict(issue, reassess.get(index))}${acceptedVerdict(status("issue", issue.id))} ${issue.title.trim()}${description ? `\n   ${description}` : ""}${formatPriorConsequence(issue)}`;
+		return `${index}. (${promptGrade(assess("issue", issue))})${location}${priorFindingVerdict(issue, reassess.get(index))}${acceptedVerdict(status("issue", issue.id))} ${issue.title.trim()}${description ? `\n   ${description}` : ""}${formatPriorConsequence(issue, framable.issue(issue))}`;
 	}).join("\n");
 }
 /**
@@ -18104,7 +18199,7 @@ function formatPriorFindings(issues, assess, reassess = /* @__PURE__ */ new Map(
 * of the issue shape returned issues with no severity, no file and in some cases no content.
 * Keep in step with STRUCTURED_OUTPUT_INSTRUCTIONS in pipeline.ts.
 */
-var QUESTION_SHAPE_LINE = "  \"questions\": [{ \"sourceIndex\": number, \"status\": \"answered\" | \"still-open\" | \"affected\", \"answer\"?: string, \"note\"?: string, \"importance\"?: \"high\" | \"medium\" | \"low\", \"importanceReason\"?: string }],";
+var QUESTION_SHAPE_LINE = `  "questions": [{ "sourceIndex": number, "status": "answered" | "still-open" | "affected", "answer"?: string, "note"?: string, ${QUESTION_FRAMING_REVISION_FIELD}, "importance"?: "high" | "medium" | "low", "importanceReason"?: string }],`;
 var RECONCILIATION_SHAPE = `{
   "findings": [{ "sourceIndex": number, "status": "resolved" | "still-open" | "affected", "note"?: string, ${CONSEQUENCE_REVISION_FIELD}, "resolvedBehaviour"?: string, "severity"?: "critical" | "major" | "minor" | "nit", "severityReason"?: string }],
   "newIssues": [{ "id": string, "severity": "critical" | "major" | "minor" | "nit", "title": string, "description": string, "file"?: string, "line"?: number, ${CONSEQUENCE_FIELD}, "confidence"?: "high" | "medium" | "low" }],
@@ -18150,7 +18245,7 @@ function reconciliationShape(includeQuestions, withDiscussion = false) {
 * question's own id is withheld so it cannot be echoed back in place of an index, and enough
 * context travels for a judgement without inviting a rewrite of the question itself.
 */
-function formatPriorQuestions(questions, assess, status = NO_STATUS) {
+function formatPriorQuestions(questions, assess, status = NO_STATUS, framable = NOTHING_FRAMABLE) {
 	if (!questions.length) return "(The previous analysis raised no questions.)";
 	return questions.map((question, index) => {
 		const related = (question.relatedFiles ?? []).map((file) => ` [related: ${file}, not changed]`).join("");
@@ -18159,7 +18254,7 @@ function formatPriorQuestions(questions, assess, status = NO_STATUS) {
 		const verdict = alreadyAnswered(question) ? " [previously: answered]" : priorVerdict(question);
 		const assessment = assess("question", question);
 		const importance = assessment.current ? ` [importance: ${promptGrade(assessment)}]` : "";
-		return `${index}.${location}${verdict}${acceptedVerdict(status("question", question.id))}${importance} ${question.question.trim()}${why ? `\n   ${why}` : ""}`;
+		return `${index}.${location}${verdict}${acceptedVerdict(status("question", question.id))}${importance} ${question.question.trim()}${why ? `\n   ${why}` : ""}${formatPriorFraming(question, framable.question(question))}`;
 	}).join("\n");
 }
 /**
@@ -18240,7 +18335,7 @@ function buildReconciliationInstructions(input, options = {}) {
 	const discussion = options.discussion;
 	const conversationOnly = discussion !== void 0 && !discussion.codeChanged;
 	const truncationWarning = possiblyTruncated ? `\n\nIMPORTANT: the list of changes above is INCOMPLETE — more files changed than could be retrieved. Do not mark a previous finding "resolved" on the strength of absence: a file you cannot see may or may not contain the fix. Prefer "still-open" or "affected" where you cannot see the relevant code, and say so in the note.` : "";
-	const questionList = includeQuestions ? `\n\nPrevious open questions, numbered — refer to each by its number in "sourceIndex":\n${formatPriorQuestions(previous.questions, input.assess, input.status)}` : "";
+	const questionList = includeQuestions ? `\n\nPrevious open questions, numbered — refer to each by its number in "sourceIndex":\n${formatPriorQuestions(previous.questions, input.assess, input.status, input.framable)}` : "";
 	const tasks = [
 		`${discussion ? `For EVERY numbered finding above, decide what ${conversationOnly ? "the changes in the conversation" : "the new commits and the changes in the conversation"} did to it:
    - "resolved": ${conversationOnly ? "" : "the new commits fix it, and you can point at the change that does so; or "}the conversation gives evidence that invalidates its premise, under the rules below.
@@ -18278,7 +18373,7 @@ Overall risk: ${previous.overallRisk}
 Recommendation: ${previous.recommendation}
 
 Previous findings, numbered — refer to each by its number in "sourceIndex":
-${formatPriorFindings(previous.issues, input.assess, reassess, input.status)}${questionList}${truncationWarning}
+${formatPriorFindings(previous.issues, input.assess, reassess, input.status, input.framable)}${questionList}${truncationWarning}
 ${discussion ? `\n${DISCUSSION_RULES}\n` : ""}
 YOUR TASK
 
@@ -18292,7 +18387,7 @@ ${reconciliationShape(includeQuestions, discussion !== void 0)}
 ${CONSEQUENCE_UPDATE_GUIDANCE}
 
 ${CONSEQUENCE_GUIDANCE}
-
+${includeQuestions ? `\n${QUESTION_FRAMING_UPDATE_GUIDANCE}\n\n${QUESTION_FRAMING_GUIDANCE}\n` : ""}
 "severity" on a new issue is how much it would matter if real; "confidence" is how sure you are that it is real. Separate axes — do not let one stand in for the other, and omit "confidence" rather than guessing a middle. Report only what is worth the reviewer's attention: empty arrays are valid answers and are far better than padded ones.`;
 }
 /**
@@ -18454,14 +18549,14 @@ function parseReconciliationResult(raw, priorCount, options = {}) {
 * Every prior finding therefore survives into the new result, in its original order, carrying its
 * original id, severity and text. Only the status is added.
 */
-function reconcileIssues(prior, findings, record) {
+function reconcileIssues(prior, findings, record, framable = NOTHING_FRAMABLE) {
 	const byIndex = new Map(findings.map((f) => [f.sourceIndex, f]));
 	return prior.map((issue, index) => {
 		const verdict = byIndex.get(index);
 		const flag = issue.reconciliationStatus === "resolved" ? record?.flags?.get(index) : void 0;
 		if (flag && record) {
 			const entry = reassessedEntry(verdict, flag, record);
-			const { resolvedBehaviour: _reopened, ...reassessed } = withRevisedConsequence(issue, verdict);
+			const { resolvedBehaviour: _reopened, ...reassessed } = withRevisedConsequence(issue, verdict, false);
 			return {
 				...reassessed,
 				reconciliationStatus: entry.status,
@@ -18474,26 +18569,45 @@ function reconcileIssues(prior, findings, record) {
 		const status = verdict?.status ?? "still-open";
 		const recorded = record && isStatusChange(issue.reconciliationStatus, status) ? { statusHistory: appendStatusChange(issue, changeEntry(status, verdict, record)) } : {};
 		const fixedInCode = status === "resolved" && !verdict?.evidence && record?.basis !== "conversation";
-		const { resolvedBehaviour: _previous, ...current } = withRevisedConsequence(issue, verdict);
+		const { resolvedBehaviour: _previous, ...current } = withRevisedConsequence(issue, verdict, status !== "resolved" && framable.issue(issue));
 		return {
-			...current,
+			...withNote(current, verdict?.note, isStatusChange(issue.reconciliationStatus, status)),
 			...fixedInCode && verdict?.resolvedBehaviour ? { resolvedBehaviour: verdict.resolvedBehaviour } : {},
 			reconciliationStatus: status,
-			...verdict?.note ? { reconciliationNote: verdict.note } : {},
 			...recorded,
 			...record?.against ? { reconciledAgainst: verdict?.evidence ? "conversation" : record.against } : {}
 		};
 	});
 }
 /**
-* The issue with its consequence kept, restated or withdrawn, as the update said.
+* The finding with the note this round gave, or the one it had. A note argues for the status it was
+* written with, so silence keeps it only while that status holds: one this round changed leaves it
+* behind, where it would contradict the new status on the card.
+*/
+function withNote(finding, note, statusChanged) {
+	if (note) return {
+		...finding,
+		reconciliationNote: note
+	};
+	if (!statusChanged) return finding;
+	const { reconciliationNote: _superseded, ...rest } = finding;
+	return rest;
+}
+/**
+* The issue with its consequence kept, restated, withdrawn or added, as the update said.
 *
-* Only for an issue that already had one. An update is never the place a historical issue gains
-* an impact summary it was not written with, so an answer for one without is ignored. Silence
-* keeps it: the model was shown it and asked to change it only where it no longer holds.
+* Silence keeps it: the model was shown it and asked to change it only where it no longer holds.
+* An issue stored without one gains the one offered only when `mayFrame`: it is still outstanding
+* after this update, so the card the reviewer is about to work from becomes scan-first. A resolved,
+* dismissed or verdict-closed issue is never given presentation it was not written with, and a
+* `null` for an issue that has nothing to withdraw changes nothing.
 */
-function withRevisedConsequence(issue, verdict) {
-	if (!issue.consequence || verdict?.consequence === void 0) return issue;
+function withRevisedConsequence(issue, verdict, mayFrame) {
+	if (verdict?.consequence === void 0) return issue;
+	if (!issue.consequence) return mayFrame && verdict.consequence ? {
+		...issue,
+		consequence: verdict.consequence
+	} : issue;
 	if (verdict.consequence === null) {
 		const { consequence: _withdrawn, ...rest } = issue;
 		return rest;
@@ -18526,10 +18640,12 @@ function parseQuestions(value, priorCount) {
 		const note = asString$1(item.note).trim();
 		const answer = asString$1(item.answer).trim();
 		const grade = parseGrade("question", item.importance, item.importanceReason);
+		const framing = item.framing === null ? null : normalizeQuestionFraming(item.framing);
 		questions.push({
 			sourceIndex,
 			status,
 			...note ? { note } : {},
+			...framing !== void 0 ? { framing } : {},
 			...status === "answered" && answer ? { answer } : {},
 			...grade ? { grade: {
 				to: grade.to,
@@ -18564,7 +18680,7 @@ function parseQuestions(value, priorCount) {
 function alreadyAnswered(question) {
 	return question.reconciliationStatus === "answered" || question.reconciliationAnswer !== void 0;
 }
-function reconcileQuestions(prior, reconciled, against) {
+function reconcileQuestions(prior, reconciled, against, framable = NOTHING_FRAMABLE) {
 	const recorded = against ? { reconciledAgainst: against } : {};
 	const byIndex = new Map(reconciled.map((entry) => [entry.sourceIndex, entry]));
 	return prior.map((question, index) => {
@@ -18580,15 +18696,35 @@ function reconcileQuestions(prior, reconciled, against) {
 		};
 		const answered = verdict.status === "answered" && verdict.answer !== void 0;
 		const status = verdict.status !== "answered" ? verdict.status : answered ? "answered" : "affected";
+		const changed = (question.reconciliationStatus ?? "still-open") !== status;
 		return {
-			...question,
+			...withNote(withRevisedFraming(question, verdict, status !== "answered" && framable.question(question)), verdict.note, changed),
 			reconciliationStatus: status,
-			...verdict.note ? { reconciliationNote: verdict.note } : {},
 			...answered ? { reconciliationAnswer: verdict.answer } : {},
 			...recorded
 		};
 	});
 }
+/**
+* The question with its framing kept, restated, withdrawn or added: `withRevisedConsequence`'s rule.
+* A framed question is revised whatever its new status, because an answer is exactly what can make
+* its "needed" line stale; an unframed one gains a framing only while it is still outstanding.
+*/
+function withRevisedFraming(question, verdict, mayFrame) {
+	if (verdict.framing === void 0) return question;
+	if (!question.framing) return mayFrame && verdict.framing ? {
+		...question,
+		framing: verdict.framing
+	} : question;
+	if (verdict.framing === null) {
+		const { framing: _withdrawn, ...rest } = question;
+		return rest;
+	}
+	return {
+		...question,
+		framing: verdict.framing
+	};
+}
 /** Marks a reconciliation's own findings as new, so the UI can tell them from carried-forward ones. */
 function markNewIssues(issues, against) {
 	return issues.map((issue) => ({
@@ -18664,6 +18800,13 @@ function countUpdateChanges(previous, result) {
 		...reopened ? { reopened } : {}
 	};
 }
+/**
+* Whether a reconciliation moved any finding or put anything to the reviewer. Still-open findings
+* are the ones it left alone, so they are the one count that is not a change.
+*/
+function findingsChanged(counts) {
+	return counts.resolved + counts.affected + counts.newIssues + counts.questionsAnswered + (counts.reopened ?? 0) + (counts.gradeChanges ?? 0) + (counts.decisionsChallenged ?? 0) > 0;
+}
 //#endregion
 //#region ../../packages/review-harness/src/domain/ai_review/update_reconciliation.ts
 function reconciledAgainstOf(basis) {
@@ -18691,8 +18834,8 @@ function applyReconciliation(previous, parsed, context) {
 		basis: context.codeChanged ? "code" : "conversation",
 		flags,
 		against
-	}), ...markNewIssues(parsed.newIssues, against)];
-	const questions = reconcileQuestions(previous.questions, parsed.questions, against);
+	}, context.framable), ...markNewIssues(parsed.newIssues, against)];
+	const questions = reconcileQuestions(previous.questions, parsed.questions, against, context.framable);
 	const { motivation } = context;
 	const composed = {
 		schemaVersion: 1,
@@ -18989,8 +19132,93 @@ async function updateReview(workspace, runners = {}) {
 	if (workspace.changeSet.targetType === "commit") return refuse(reviewedSha, false, COMMIT_REVIEW_CANNOT_UPDATE);
 	const parked = parkedUpdateRefusal(workspace);
 	if (parked) return refuse(reviewedSha, false, parked);
+	let fetchStartedAt = 0;
+	return driveUpdateJob(workspace, runners, reviewedSha, {
+		startedAt,
+		now
+	}, void 0, async (held, step, signal, clock) => {
+		fetchStartedAt = Date.now();
+		const outcome = await bringForward(workspace, runners, reviewedSha, held, step, signal, clock);
+		if (!signal.aborted && outcome.ok && !outcome.fetchFailed && outcome.toSha) workspace.headSeenAt = fetchStartedAt;
+		return outcome;
+	});
+}
+/**
+* Reconcile the review's findings with its pull request discussion as it is now, at the commit the
+* review read: the Re-check button.
+*
+* The discussion half of an update and nothing else. The conversation is re-read exactly as an
+* update re-reads it, so every "already raised" line is corrected first; then, when something in it
+* is new to the analysis, the same reconciliation an update runs is asked of the same agent with no
+* code delta. It may answer a question, resolve or reopen an issue on the evidence the discussion
+* rules allow, suggest a grade, or raise a concern as a new issue once it has confirmed it in the
+* reviewed code. It never fetches and never moves the review to a newer commit: that is an update's,
+* and the review's commit stays where it was so the next update still sees those commits as new.
+*
+* Computes and mutates in memory, like `updateReview`; the route saves.
+*/
+async function recheckConversation(workspace, runners = {}) {
+	const now = runners.now ?? Date.now;
+	const startedAt = now();
+	const reviewedSha = workspace.session.metadata?.commitSha || null;
+	const recheck = (outcome) => ({
+		...outcome,
+		scope: "conversation"
+	});
+	if (!workspace.prContext) return recheck(refuse(reviewedSha, false, "This review has no pull request conversation attached, so there is nothing to re-read."));
+	const cannotReassess = parkedUpdateRefusal(workspace) ?? (!workspace.session.result || !reviewedSha ? "This review has no analysis to reassess." : null);
+	if (cannotReassess) {
+		adoptLegacyBaseline(workspace);
+		const conversationOk = await reReadConversation(workspace, runners.runRefresh);
+		return recheck(settled(reviewedSha, reviewedSha, false, conversationOk, "refused", conversationOk ? cannotReassess : rereadFailureOf(workspace)));
+	}
+	return driveUpdateJob(workspace, runners, reviewedSha, {
+		startedAt,
+		now
+	}, "conversation", async (held, step, signal, clock) => recheck(await reconcileConversation(workspace, runners, reviewedSha, held, step, signal, clock)));
+}
+/** What a failed re-read said, for an outcome that reports it. */
+function rereadFailureOf(workspace) {
+	return workspace.lastPrRefresh && !workspace.lastPrRefresh.ok ? workspace.lastPrRefresh.message : "The pull request conversation could not be re-read. Nothing here has changed.";
+}
+/** Said when the conversation holds nothing the findings have not already been weighed against. */
+var NOTHING_NEW_IN_DISCUSSION = "Nothing in the PR discussion is new since the findings were last assessed, so no findings changed.";
+async function reconcileConversation(workspace, runners, reviewedSha, held, step, signal, clock) {
+	adoptLegacyBaseline(workspace);
+	step("conversation");
+	const conversationOk = await reReadConversation(workspace, runners.runRefresh);
+	signal.throwIfAborted();
+	if (!conversationOk) return settled(reviewedSha, reviewedSha, false, false, "refused", rereadFailureOf(workspace));
+	const { prepared } = await prepareConversation(workspace, {
+		reread: false,
+		...workspace.lastPrRefresh ? { rereadOutcome: workspace.lastPrRefresh } : {}
+	});
+	if (!conversationMoved(prepared)) return settled(reviewedSha, reviewedSha, false, true, "already-current", NOTHING_NEW_IN_DISCUSSION);
+	if (!await commitPresent(workspace.repoPath, reviewedSha)) return settled(reviewedSha, reviewedSha, false, true, "baseline-gone", BASELINE_GONE_MESSAGE);
+	step("context");
+	let worktreePath;
+	try {
+		({path: worktreePath} = await pinCheckout(workspace, reviewedSha, held));
+	} catch (error) {
+		if (error instanceof ReviewBeingDeletedError) throw error;
+		return settled(reviewedSha, reviewedSha, false, true, "analysis-failed", "A checkout of the reviewed commit could not be prepared, so the findings were not reassessed.");
+	}
+	signal.throwIfAborted();
+	return reconcile(workspace, runners, reviewedSha, {
+		sha: reviewedSha,
+		fetchFailed: false
+	}, true, worktreePath, step, held.job, signal, clock, prepared, true, "conversation");
+}
+/**
+* The life of an update's job, whatever the update does inside it: the claim, the cancel, the steps,
+* how it ends and what it announces. Shared by Update and Re-check so the two cannot disagree about
+* how a run is watched, cancelled or reported.
+*/
+async function driveUpdateJob(workspace, runners, reviewedSha, clock, scope, work) {
+	const { startedAt, now } = clock;
 	const held = await claimCheckoutJob(workspace, reviewedSha ?? "", {
 		purpose: "update",
+		...scope ? { scope } : {},
 		...runners.source ? { source: runners.source } : {},
 		...workspace.prContext ? { conversation: {
 			kind: "attached",
@@ -19004,16 +19232,11 @@ async function updateReview(workspace, runners = {}) {
 	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, signal, {
-			startedAt,
-			now
-		});
-		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);
+		const outcome = await work(held, step, signal, clock);
+		if (signal.aborted) return scoped(cancelled(held, reviewedSha), scope);
+		const ended = outcome.stop === "analysis-failed" || scope && outcome.conversationOk === false ? fail(current(), outcome.message) : advance(current(), "done", outcome.message);
 		saveJob(ended);
-		if (outcome.ok && outcome.stop === null) {
+		if (!scope && outcome.ok && outcome.stop === null) {
 			const completedAt = now();
 			recordRuntimeBestEffort({
 				operation: "update",
@@ -19029,7 +19252,7 @@ async function updateReview(workspace, runners = {}) {
 		announceJob(ended, updateFacts(outcome, workspace));
 		return outcome;
 	} catch (error) {
-		if (signal.aborted) return cancelled(held, reviewedSha);
+		if (signal.aborted) return scoped(cancelled(held, reviewedSha), scope);
 		const failed = fail(current(), error instanceof Error ? error.message : String(error));
 		saveJob(failed);
 		announceJob(failed);
@@ -19039,6 +19262,12 @@ async function updateReview(workspace, runners = {}) {
 		held.claim.release();
 	}
 }
+function scoped(outcome, scope) {
+	return scope ? {
+		...outcome,
+		scope
+	} : outcome;
+}
 /**
 * 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.
@@ -19082,7 +19311,7 @@ async function bringForward(workspace, runners, reviewedSha, held, step, signal,
 	signal.throwIfAborted();
 	return reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, held.job, signal, clock, prepared, discussionMoved);
 }
-async function reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, job, signal, clock, prepared, discussionMoved) {
+async function reconcile(workspace, runners, reviewedSha, remote, conversationOk, worktreePath, step, job, signal, clock, prepared, discussionMoved, scope) {
 	const { id: jobId, env } = job;
 	const newHead = remote.sha;
 	let delta = null;
@@ -19117,7 +19346,7 @@ async function reconcile(workspace, runners, reviewedSha, remote, conversationOk
 	const requestedModel = resolveModel({ review: { session: workspace.session } }) ?? void 0;
 	let raw;
 	try {
-		const prompt = buildUpdatePrompt(workspace, delta, prepared, reviewedSha, newHead, worktreePath);
+		const prompt = buildUpdatePrompt(workspace, delta, prepared, reviewedSha, newHead, worktreePath, scope);
 		raw = runners.run ? await runners.run(prompt, worktreePath, env, onProgress, onObservedModel, signal) : await runUpdate(workspace.id, prompt, worktreePath, workspace.repoPath, env, onProgress, requestedModel, onObservedModel, signal);
 	} catch (error) {
 		return settled(reviewedSha, newHead, remote.fetchFailed, conversationOk, "analysis-failed", explainUpdateFailure(error, env, requestedModel));
@@ -19132,7 +19361,8 @@ async function reconcile(workspace, runners, reviewedSha, remote, conversationOk
 		codeChanged: delta !== null,
 		conversation: prepared,
 		assess: assessmentLookup(workspace.session),
-		motivation
+		motivation,
+		framable: framableFindings(workspace.session)
 	});
 	signal.throwIfAborted();
 	cancellers.delete(jobId);
@@ -19333,11 +19563,36 @@ function mergeUpdateInto(fresh, updated) {
 	for (const field of UPDATE_OWNED_FIELDS) if (field in updated) target[field] = source[field];
 	else delete target[field];
 	merged.session = keepReviewerFields(fresh, updated.session);
+	keepNewerConversation(merged, fresh, updated);
 	carryUpdateSuggestions(merged, updated);
 	dropStaleChangeMap(merged);
 	return merged;
 }
 /**
+* A conversation re-read that landed on disk while this ran, kept rather than put back.
+*
+* An Ask turn re-reads the conversation and saves it, and an update holds its copy for minutes. Laid
+* over whole, the update's older copy replaced the newer one and the "already raised" lines went
+* back with it. The newer copy stays, and the attributions are derived again from it: arithmetic,
+* the same pass the re-read itself runs. `analysedConversation` is untouched either way: it is the
+* snapshot this run actually reconciled against, so whatever arrived since is still new to the next.
+*/
+function keepNewerConversation(merged, fresh, updated) {
+	const theirs = fresh.prContext ? orderOf(fresh.prContext.discussion) : void 0;
+	const ours = updated.prContext ? orderOf(updated.prContext.discussion) : void 0;
+	if (theirs === void 0 || ours === void 0 || theirs <= ours || !fresh.prContext) return;
+	merged.prContext = fresh.prContext;
+	if (fresh.lastPrRefresh) merged.lastPrRefresh = fresh.lastPrRefresh;
+	const result = merged.session.result;
+	if (result) {
+		const { result: attributed } = attributeIssuesToDiscussion(result, processDiscussion(fresh.prContext.discussion));
+		merged.session = {
+			...merged.session,
+			result: attributed
+		};
+	}
+}
+/**
 * The grade changes this update suggested, onto the review as it is on disk.
 *
 * The ledger is the reviewer's and comes from the fresh read, so the update's proposals, written on
@@ -19614,20 +19869,20 @@ function stillPresent(counts) {
 * Everything after it is the shared builder, so the two clients cannot drift into asking for
 * different shapes.
 */
-function buildUpdatePrompt(workspace, delta, conversation, reviewedSha, newHead, worktreePath) {
+function buildUpdatePrompt(workspace, delta, conversation, reviewedSha, newHead, worktreePath, scope) {
 	const previous = workspace.session.result;
 	const discussionChanged = conversationMoved(conversation);
 	const conversationBlock = updateConversationBlock(conversation);
-	const opening = delta ? `An earlier review of this branch is being brought up to date with the commits pushed since it was written${discussionChanged ? ", and with what has changed in its pull request conversation since" : ""}.` : "An earlier review of this branch is being brought up to date with what has changed in its pull request conversation since it was written. No commits have been pushed since.";
+	const opening = delta ? `An earlier review of this branch is being brought up to date with the commits pushed since it was written${discussionChanged ? ", and with what has changed in its pull request conversation since" : ""}.` : scope === "conversation" ? "An earlier review of this branch is being reconciled with what has changed in its pull request conversation since it was written. Only the conversation is reassessed in this pass, against the commit the review read. Newer commits on the branch, if any, are not part of it: a comment saying a fix landed in one cannot be confirmed from this checkout, so that finding stays open for a later update to check against the code." : "An earlier review of this branch is being brought up to date with what has changed in its pull request conversation since it was written. No commits have been pushed since.";
 	const code = delta ? `The change below is what happened between ${reviewedSha} and ${newHead}. It is not the whole branch: the earlier review already covered everything up to ${reviewedSha}.
 
 ${renderChangeInventory(delta.changeSet.data.files, inlinePathsOf(delta))}
 
-${delta.diff}` : `The code is unchanged since the earlier review: ${newHead} is the commit it read.`;
+${delta.diff}` : scope === "conversation" ? `There is no code delta in this pass: ${newHead} is the commit the earlier review read.` : `The code is unchanged since the earlier review: ${newHead} is the commit it read.`;
 	const commits = delta ? (delta.changeSet.authors ?? []).reduce((total, author) => total + author.commits, 0) : 0;
 	return `${opening}
 
-The working tree at ${worktreePath} is checked out at ${newHead}, which is the code as it now stands. You may read any file in it, and you should: the point of doing this here rather than from a diff alone is that you can open the code and see whether a fix actually holds. Read only. Change nothing, commit nothing, and run no command that writes.
+The working tree at ${worktreePath} is checked out at ${newHead}, which is ${scope === "conversation" ? "the code the review read" : "the code as it now stands"}. You may read any file in it, and you should: the point of doing this here rather than from a diff alone is that you can open the code and see whether a fix actually holds. Read only. Change nothing, commit nothing, and run no command that writes.
 
 ${code}
 
@@ -19641,6 +19896,7 @@ ${buildReconciliationInstructions({
 		previous,
 		assess: assessmentLookup(workspace.session),
 		status: statusLookup(workspace.session),
+		framable: framableFindings(workspace.session),
 		fromSha: reviewedSha,
 		toSha: newHead,
 		totalCommits: commits,
@@ -21360,4 +21616,4 @@ var MCP_TOOL_NAMES = [
 	"ask_buddy"
 ];
 //#endregion
-export { readAskRequest as $, runnableAgents as $a, explanationOf as $i, authorPreview as $n, kissDecisionsOf as $r, recordRuntimeBestEffort as $t, settleQueue as A, TargetError as Aa, createWithMembers as Ai, moveIds as An, attemptIdOf as Ar, UpdateAlreadyRunningError as At, humanizeModelId as B, agentIdOf as Ba, queueStamp as Bi, existingPaths as Bn, phasesFor as Br, append as Bt, parsePullRequestLink as C, objectWithAnyOf as Ca, lifecyclePillAction as Ci, createPrState as Cn, followedBranch as Cr, RefreshUnavailableError as Ct, activateQueued as D, resolveTarget as Da, sectionOf as Di, markAllRead as Dn, fillFileUrlTemplate as Dr, parkedUpdateRefusal as Dt, relativeTime as E, kissOutcome as Ea, parseLifecycle as Ei, listNotifications as En, forgeResolver as Er, mergeUpdateInto as Et, spawnRunner as F, shorthandOf as Fa, setMembership as Fi, retireNotification as Fn, pruneJobResidue as Fr, prepareReview as Ft, reviewTag as G, STORE_ROOT as Ga, issuesOutstanding as Gi, storedConversation as Gn, isClaimed as Gr, recordTelemetryUploadConsent as Gt, findingRef as H, readAgentPreference as Ha, doneVerb as Hi, adoptLegacyBaseline as Hn, purposeOf as Hr, record as Ht, applyUpdate as I, git as Ia, updateCollections as Ii, toneOf as In, saveJob as Ir, settleReview as It, forgetAskRequest as J, agentFor as Ja, reviewerDispositions as Ji, isUnchanged as Jn, followedRefName as Jr, BUILD_VERSION as Jt, reviewTagsIn as K, AGENT_IDS as Ka, questionsOutstanding as Ki, unforeseenFailure as Kn, CLAIM_LEASE_MS as Kr, telemetryUploadConsent as Kt, modelProvenanceOf as L, refExists as La, queueAdd as Li, unreadAround as Ln, PHASES as Lr, reanalyseReview as Lt, RUNNER_MARKER as M, resolveBase as Ma, nameProblemText as Mi, readNotification as Mn, fail as Mr, runningJobs as Mt, cliEntry as N, AmbiguousRefError as Na, readCollections as Ni, readStateOf as Nn, isTerminal as Nr, failureOf as Nt, compactQueue as O, originRemote as Oa, collectionsStamp as Oi, markRead as On, RUN_RECORD_RETENTION_MS as Or, updateReview as Ot, runDetached as P, shortNameOf as Pa, renameCollection as Pi, removeNotification as Pn, loadJob as Pr, observeReview as Pt, markAskRunning as Q, parkedReason as Qa, explanationActionOf as Qi, UNESTABLISHED_MOTIVATION as Qn, kissDecisionRefusal as Qr, mapRuntimes as Qt, provenanceDetailLines as R, resolveAgent as Ra, queueAddMany as Ri, unreadCount as Rn, isLiveJob as Rr, runJob as Rt, extractPullRequestLinks as S, extractJsonText as Sa, lifecycleName as Si, createArchitectureNotification as Sn, checkReview as Sr, FETCH_TIMEOUT_MS as St, runBatch as T, WITHHELD_REASON as Ta, offersLifecycle as Ti, eventName as Tn, fetchHead as Tr, cancellableHere as Tt, findingRefs as U, writeAgentPreference as Ua, isIssueOutstanding as Ui, prepareConversationWithin as Un, clearClaim as Ur, stamp as Ut, findingAtRef as V, clearAgentPreference as Va, readQueue as Vi, ASK_REREAD_CEILING_MS as Vn, progressSteps as Vr, readEvents as Vt, refOf as W, CONFIG_PATH as Wa, isQuestionOutstanding as Wi, saveRefresh as Wn, driverGone as Wr, deliver as Wt, isRequestId as X, detectAgents as Xa, processDiscussion as Xi, EXPLAIN_SIMPLY_PROMPT as Xn, indexKeptIds as Xr, feedbackUrl as Xt, interruption as Y, agentIdentityOf as Ya, verdictClosure as Yi, agentEnvOf as Yn, groupByLineage as Yr, PACKAGE_NAME as Yt, isTerminalAsk as Z, isAgentId as Za, recommendationsOf as Zi, chatConversationSection as Zn, indexReviewGroups as Zr, waitingHistory as Zt, endRun as _, statusLookup as _a, activityAttributes as _i, writeJsonAtomically as _n, requestJobStop as _r, parseWorkspacePort as _t, lineageIds as a, assessmentLookup as aa, mutateWorkspace as ai, loadArchitecture as an, escapeHtml as ar, healthyPort as at, stopRun as b, SEVERITIES as ba, lifecycleChip as bi, subjectOf as bn, findExistingReview as br, writePortPreference as bt, discardJob as c, findingAssessment as ca, previousKissResult as ci, repositoryKey as cn, ReviewBeingDeletedError as cr, serverEntryExists as ct, startKissJob as d, gradeScale as da, reviewedRepositories as di, trackedFiles as dn, MANAGED_ROOT as dr, stopServer as dt, isExplanationAction as ea, latestKissRun as ei, RUNTIME_WORDS as en, versionFrom as eo, hasAuthorContent as er, recordAskAccepted as et, isDriving as f, isGradeFor as fa, summarise as fi, ownersOf as fn, createWorktree as fr, workspaceUrl as ft, completeRun as g, sourcePhrase as ga, LIFECYCLES as gi, isArchitectureId as gn, removeWorktree as gr, MIN_WORKSPACE_PORT as gt, beginRun as h, reassessIn as ha, workspaceStamps as hi, ancestorsOf as hn, readMarker as hr, MAX_WORKSPACE_PORT as ht, deleteReview as i, analysisRefOf as ia, matchingWorkspaceIds as ii, checkArchitecture as in, CODE_COPY_CLASS as ir, ensureServer as it, RUNNER_KINDS as j, isCommitReview as ja, deleteCollection as ji, pruneNotifications as jn, endedAt as jr, liveUpdateFor as jt, queueForReview as k, DetachedHeadError as ka, createCollection as ki, markReadForReview as kn, allJobs as kr, askCheckout as kt, kissAgentId as l, findingIn as la, recentWorkspaces as li, storeArchitecture as ln, isBusy as lr, spawnServer as lt, RUN_KINDS as m, promptGrade as ma, workspaceRevision as mi, REPOSITORY_SCOPE as mn, isWorktreeHeld as mr, DEFAULT_WORKSPACE_PORT as mt, MCP_TOOL_NAMES as n, ANALYSIS_ONLY as na, lineagePosition as ni, formatDuration as nn, AgentCancelledError as no, renderMarkdown as nr, bootstrapUrl as nt, liveJobsFor as o, closesFinding as oa, positionInLineage as oi, partFiles as on, renderInlineText as or, readServerRecord as ot, track as p, isOffered as pa, touchWorkspace as pi, QUOTE_LIMITS as pn, holdWorktree as pr, writeServerRecord as pt, endAskRequest as q, agentById as qa, resolvedByConversation as qi, refreshPrContext as qn, decideKissRecommendation as qr, telemetryUploadEnabled as qt, deleteLineage as r, NO_STATUS as ra, loadWorkspace as ri, ARCHITECTURE_DIR as rn, AgentUnavailableError as ro, CODE_BLOCK_CLASS as rr, clearServerRecordOwnedBy as rt, wasBlocked as s, currentGradeIn as sa, presentedKissRunOf as si, readArchitecture as sn, modelHelpLines as sr, reviewsUrl as st, MCP_SERVER_INFO_NAME as t, withExplanation as ta, lineageKey as ti, describeRuntimes as tn, AGENT_RUN_MARKER as to, GITHUB_MARKDOWN as tr, readIndexToken as tt, recordKissRun as u, findingStatus as ua, reviewedCommit as ui, storedScopes as un, withReviewLock as ur, stopChild as ut, heldRuns as v, wasReassessed as va, activityLabel as vi, announceJob as vn, describeMovement as vr, resolveWorkspacePort as vt, unsupportedReason as w, describeAuthorship as wa, lifecyclePillLabel as wi, createPrUpdate as wn, reviewedShaOf as wr, cancelUpdate as wt, batchIdentity as x, asString$1 as xa, lifecycleItemLabel as xi, categoryOf as xn, checkCodeFreshness as xr, COMMIT_REVIEW_CANNOT_UPDATE as xt, reportRun as y, followUpFindingId as ya, isLifecycle as yi, branchOf as yn, describeSubject as yr, statedWorkspacePort as yt, agentDisplayName as z, resolveModel as za, queueRemove as zi, withUsageRecorded as zn, isTerminalJobPhase as zr, startJob as zt };
+export { readAskRequest as $, versionFrom as $a, isExplanationAction as $i, hasAuthorContent as $n, latestKissRun as $r, waitingHistory as $t, settleQueue as A, isCommitReview as Aa, deleteCollection as Ai, markRead as An, endedAt as Ar, askCheckout as At, humanizeModelId as B, clearAgentPreference as Ba, readQueue as Bi, unreadCount as Bn, progressSteps as Br, runJob as Bt, parsePullRequestLink as C, describeAuthorship as Ca, lifecyclePillLabel as Ci, categoryOf as Cn, reviewedShaOf as Cr, RefreshUnavailableError as Ct, activateQueued as D, originRemote as Da, collectionsStamp as Di, eventName as Dn, RUN_RECORD_RETENTION_MS as Dr, parkedUpdateRefusal as Dt, relativeTime as E, resolveTarget as Ea, sectionOf as Ei, createPrUpdate as En, fillFileUrlTemplate as Er, mergeUpdateInto as Et, spawnRunner as F, git as Fa, updateCollections as Fi, readStateOf as Fn, saveJob as Fr, failureOf as Ft, reviewTag as G, AGENT_IDS as Ga, questionsOutstanding as Gi, saveRefresh as Gn, CLAIM_LEASE_MS as Gr, stamp as Gt, findingRef as H, writeAgentPreference as Ha, isIssueOutstanding as Hi, existingPaths as Hn, clearClaim as Hr, append as Ht, applyUpdate as I, refExists as Ia, queueAdd as Ii, removeNotification as In, PHASES as Ir, observeReview as It, forgetAskRequest as J, agentIdentityOf as Ja, verdictClosure as Ji, agentEnvOf as Jn, groupByLineage as Jr, telemetryUploadConsent as Jt, reviewTagsIn as K, agentById as Ka, resolvedByConversation as Ki, storedConversation as Kn, decideKissRecommendation as Kr, deliver as Kt, modelProvenanceOf as L, resolveAgent as La, queueAddMany as Li, retireNotification as Ln, isLiveJob as Lr, prepareReview as Lt, RUNNER_MARKER as M, AmbiguousRefError as Ma, readCollections as Mi, moveIds as Mn, isTerminal as Mr, UpdateAlreadyRunningError as Mt, cliEntry as N, shortNameOf as Na, renameCollection as Ni, pruneNotifications as Nn, loadJob as Nr, liveUpdateFor as Nt, compactQueue as O, DetachedHeadError as Oa, createCollection as Oi, listNotifications as On, allJobs as Or, recheckConversation as Ot, runDetached as P, shorthandOf as Pa, setMembership as Pi, readNotification as Pn, pruneJobResidue as Pr, runningJobs as Pt, markAskRunning as Q, runnableAgents as Qa, explanationOf as Qi, authorPreview as Qn, kissDecisionsOf as Qr, feedbackUrl as Qt, provenanceDetailLines as R, resolveModel as Ra, queueRemove as Ri, toneOf as Rn, isTerminalJobPhase as Rr, settleReview as Rt, extractPullRequestLinks as S, objectWithAnyOf as Sa, lifecyclePillAction as Si, subjectOf as Sn, followedBranch as Sr, FETCH_TIMEOUT_MS as St, runBatch as T, kissOutcome as Ta, parseLifecycle as Ti, createPrState as Tn, forgeResolver as Tr, cancellableHere as Tt, findingRefs as U, CONFIG_PATH as Ua, isQuestionOutstanding as Ui, ASK_REREAD_CEILING_MS as Un, driverGone as Ur, readEvents as Ut, findingAtRef as V, readAgentPreference as Va, doneVerb as Vi, withUsageRecorded as Vn, purposeOf as Vr, startJob as Vt, refOf as W, STORE_ROOT as Wa, issuesOutstanding as Wi, prepareConversationWithin as Wn, isClaimed as Wr, record as Wt, isRequestId as X, isAgentId as Xa, recommendationsOf as Xi, chatConversationSection as Xn, indexReviewGroups as Xr, BUILD_VERSION as Xt, interruption as Y, detectAgents as Ya, processDiscussion as Yi, EXPLAIN_SIMPLY_PROMPT as Yn, indexKeptIds as Yr, telemetryUploadEnabled as Yt, isTerminalAsk as Z, parkedReason as Za, explanationActionOf as Zi, UNESTABLISHED_MOTIVATION as Zn, kissDecisionRefusal as Zr, PACKAGE_NAME as Zt, endRun as _, wasReassessed as _a, activityLabel as _i, ancestorsOf as _n, describeMovement as _r, parseWorkspacePort as _t, lineageIds as a, closesFinding as aa, positionInLineage as ai, ARCHITECTURE_DIR as an, renderInlineText as ar, healthyPort as at, stopRun as b, asString$1 as ba, lifecycleItemLabel as bi, announceJob as bn, checkCodeFreshness as br, writePortPreference as bt, discardJob as c, findingIn as ca, recentWorkspaces as ci, partFiles as cn, isBusy as cr, serverEntryExists as ct, startKissJob as d, isGradeFor as da, summarise as di, storeArchitecture as dn, createWorktree as dr, stopServer as dt, withExplanation as ea, lineageKey as ei, mapRuntimes as en, AGENT_RUN_MARKER as eo, GITHUB_MARKDOWN as er, recordAskAccepted as et, isDriving as f, isOffered as fa, touchWorkspace as fi, storedScopes as fn, holdWorktree as fr, workspaceUrl as ft, completeRun as g, statusLookup as ga, activityAttributes as gi, REPOSITORY_SCOPE as gn, requestJobStop as gr, MIN_WORKSPACE_PORT as gt, beginRun as h, sourcePhrase as ha, LIFECYCLES as hi, QUOTE_LIMITS as hn, removeWorktree as hr, MAX_WORKSPACE_PORT as ht, deleteReview as i, assessmentLookup as ia, mutateWorkspace as ii, formatDuration as in, escapeHtml as ir, ensureServer as it, RUNNER_KINDS as j, resolveBase as ja, nameProblemText as ji, markReadForReview as jn, fail as jr, findingsChanged as jt, queueForReview as k, TargetError as ka, createWithMembers as ki, markAllRead as kn, attemptIdOf as kr, updateReview as kt, kissAgentId as l, findingStatus as la, reviewedCommit as li, readArchitecture as ln, withReviewLock as lr, spawnServer as lt, RUN_KINDS as m, reassessIn as ma, workspaceStamps as mi, ownersOf as mn, readMarker as mr, DEFAULT_WORKSPACE_PORT as mt, MCP_TOOL_NAMES as n, NO_STATUS as na, loadWorkspace as ni, RUNTIME_WORDS as nn, AgentUnavailableError as no, CODE_BLOCK_CLASS as nr, bootstrapUrl as nt, liveJobsFor as o, currentGradeIn as oa, presentedKissRunOf as oi, checkArchitecture as on, modelHelpLines as or, readServerRecord as ot, track as p, promptGrade as pa, workspaceRevision as pi, trackedFiles as pn, isWorktreeHeld as pr, writeServerRecord as pt, endAskRequest as q, agentFor as qa, reviewerDispositions as qi, isUnchanged as qn, followedRefName as qr, recordTelemetryUploadConsent as qt, deleteLineage as r, analysisRefOf as ra, matchingWorkspaceIds as ri, describeRuntimes as rn, CODE_COPY_CLASS as rr, clearServerRecordOwnedBy as rt, wasBlocked as s, findingAssessment as sa, previousKissResult as si, loadArchitecture as sn, ReviewBeingDeletedError as sr, reviewsUrl as st, MCP_SERVER_INFO_NAME as t, ANALYSIS_ONLY as ta, lineagePosition as ti, recordRuntimeBestEffort as tn, AgentCancelledError as to, renderMarkdown as tr, readIndexToken as tt, recordKissRun as u, gradeScale as ua, reviewedRepositories as ui, repositoryKey as un, MANAGED_ROOT as ur, stopChild as ut, heldRuns as v, followUpFindingId as va, isLifecycle as vi, isArchitectureId as vn, describeSubject as vr, resolveWorkspacePort as vt, unsupportedReason as w, WITHHELD_REASON as wa, offersLifecycle as wi, createArchitectureNotification as wn, fetchHead as wr, cancelUpdate as wt, batchIdentity as x, extractJsonText as xa, lifecycleName as xi, branchOf as xn, checkReview as xr, COMMIT_REVIEW_CANNOT_UPDATE as xt, reportRun as y, SEVERITIES as ya, lifecycleChip as yi, writeJsonAtomically as yn, findExistingReview as yr, statedWorkspacePort as yt, agentDisplayName as z, agentIdOf as za, queueStamp as zi, unreadAround as zn, phasesFor as zr, reanalyseReview as zt };