pi-pr-review 1.11.0 → 1.11.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.11.2](https://github.com/10ego/pi-pr-review/compare/v1.11.1...v1.11.2) (2026-07-22)
+
+
+### Bug Fixes
+
+* **publish:** repair malformed reviews with light subagent ([#42](https://github.com/10ego/pi-pr-review/issues/42)) ([6bb2f1b](https://github.com/10ego/pi-pr-review/commit/6bb2f1b5d7c42ab0233be27b7fa75984eb0b6357))
+
+## [1.11.1](https://github.com/10ego/pi-pr-review/compare/v1.11.0...v1.11.1) (2026-07-20)
+
+
+### Bug Fixes
+
+* **focus:** coalesce live viewer redraws ([#40](https://github.com/10ego/pi-pr-review/issues/40)) ([6553eb1](https://github.com/10ego/pi-pr-review/commit/6553eb1c0ade7881b220269b22adf22e4a5d7e59))
+
 ## [1.11.0](https://github.com/10ego/pi-pr-review/compare/v1.10.7...v1.11.0) (2026-07-17)
 
 

package/README.md

@@ -188,7 +188,7 @@ Publishing is off by default.
 
 The extension—not the model—owns publishing. After a successful review, it caches one validated completed review per repository and PR in the current Pi session. `autoPostReviews` and `--comment` publish that cached review after completion; `--no-comment` suppresses publication for the run.
 
-If the agent's final review is not valid exact-contract JSON, the extension logs the reason and automatically asks the same agent to correct its completed output once, with tools disabled and the original posting authority unchanged. An invalid correction, a tool call, or overlapping input stops publication rather than starting another correction loop.
+If the agent's final review is not valid exact-contract JSON, the extension logs the reason and runs the configured `light` subagent once to reformat the completed output, with tools disabled and the original posting authority unchanged. An invalid correction or overlapping input stops publication rather than starting another correction loop.
 
 You can publish the cache later with `/pr-review-publish 123`, or directly ask the agent to “post the inline review,” “post it as an inline review,” or “publish the review for PR #123.” The extension handles that request directly before an agent turn. `/pr-review-publish` and a matching direct request publish only the cache; they never start or rerun review agents. Unnumbered direct requests select the latest cached review for the current repository. Only fresh interactive/RPC input can use the direct path.
 

package/extensions/pr-review-focus.ts

@@ -47,6 +47,7 @@ export class ReviewFocusView implements Component {
 	private followTail = true;
 	private unsubscribe?: () => void;
 	private closed = false;
+	private renderTimer?: ReturnType<typeof setTimeout>;
 
 	constructor(
 		private readonly tui: Pick<TUI, "requestRender" | "terminal">,
@@ -74,7 +75,7 @@ export class ReviewFocusView implements Component {
 		} else {
 			this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, snapshot.passes.length - 1));
 		}
-		this.tui.requestRender();
+		this.scheduleRender();
 	}
 
 	handleInput(data: string): void {
@@ -199,6 +200,18 @@ export class ReviewFocusView implements Component {
 	dispose(): void {
 		this.unsubscribe?.();
 		this.unsubscribe = undefined;
+		if (this.renderTimer !== undefined) {
+			clearTimeout(this.renderTimer);
+			this.renderTimer = undefined;
+		}
+	}
+
+	private scheduleRender(): void {
+		if (this.closed || this.renderTimer !== undefined) return;
+		this.renderTimer = setTimeout(() => {
+			this.renderTimer = undefined;
+			if (!this.closed) this.tui.requestRender();
+		}, 16);
 	}
 
 	private pageSize(): number {

package/extensions/pr-review-subagent.ts

@@ -608,6 +608,7 @@ interface SubagentPassRequest {
 	toolPolicy?: ToolPolicy;
 	majorOnly?: boolean;
 	minorHygiene?: boolean;
+	systemPrompt?: string;
 	focusPublisher?: ReviewFocusPublisher;
 }
 
@@ -704,7 +705,7 @@ async function runSubagentAttempt(
 
 		tmp = await writeTempPrompt(
 			pass.tier,
-			buildSubagentSystemPrompt(
+			pass.systemPrompt ?? buildSubagentSystemPrompt(
 				pass.tier,
 				pass.majorOnly === true,
 				pass.minorHygiene && pass.tier === "light",
@@ -812,6 +813,30 @@ async function runSelfReviewAttempt(
 	}
 }
 
+const OUTPUT_REPAIR_SYSTEM_PROMPT = [
+	"You are an isolated output-repair subagent for a completed PR review.",
+	"You have no tools. Do not review the PR, add findings, remove findings, or change the review's substance.",
+	"Convert the supplied completed-review text into exactly one JSON object that satisfies the supplied output contract.",
+	"Return only that JSON object: no Markdown, headings, prose, or code fences. If the source cannot be safely converted, return it unchanged so host validation rejects it.",
+].join("\\n");
+
+/** Run the configured light-tier model as a no-tools, one-shot JSON-format repairer. */
+export async function repairReviewOutput(
+	text: string,
+	outputContract: string,
+	ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted">,
+	signal?: AbortSignal,
+): Promise<string | undefined> {
+	const result = await runSubagentPass(loadConfig(ctx), ctx, {
+		id: "output-repair",
+		tier: "light",
+		objective: `Reformat this completed review without changing its substance.\n\n--- required output contract ---\n${outputContract}\n\n--- completed review ---\n${text}`,
+		toolPolicy: "none",
+		systemPrompt: OUTPUT_REPAIR_SYSTEM_PROMPT,
+	}, signal);
+	return result.status === "completed" && result.text.trim() ? result.text : undefined;
+}
+
 async function runSubagentPass(
 	config: PrReviewConfig,
 	ctx: Pick<ExtensionContext, "cwd">,

package/extensions/review-table.ts

@@ -86,10 +86,23 @@ interface Review {
 }
 
 type MessagePart = { type: string; text?: string };
+type ReviewOutputRepair = (
+	text: string,
+	outputContract: string,
+	ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted">,
+	signal?: AbortSignal,
+) => Promise<string | undefined>;
+
+const defaultReviewOutputRepair: ReviewOutputRepair = async (...args) => {
+	const { repairReviewOutput } = await import("./pr-review-subagent.ts");
+	return repairReviewOutput(...args);
+};
 
 const OWN_REVIEW_PROMPT = fs.realpathSync(
 	fileURLToPath(new URL("../prompts/pr-review.md", import.meta.url)),
 );
+const REVIEW_PROMPT_TEXT = fs.readFileSync(OWN_REVIEW_PROMPT, "utf8");
+const REVIEW_OUTPUT_CONTRACT = REVIEW_PROMPT_TEXT.slice(REVIEW_PROMPT_TEXT.indexOf("## OUTPUT FORMAT"));
 
 function isOwnReviewPrompt(pi: Pick<ExtensionAPI, "getCommands">): boolean {
 	try {
@@ -436,6 +449,7 @@ export default function registerReviewTable(
 	pi: ExtensionAPI,
 	loopCoordinator = new ReviewLoopCoordinator(pi),
 	selfReviewCoordinator = new SelfReviewPermitCoordinator(pi, () => !!loopCoordinator.peek()),
+	repairOutput: ReviewOutputRepair = defaultReviewOutputRepair,
 ) {
 	const completedReviews = new CompletedReviewCache();
 	const sessionIdentity = (ctx: ExtensionContext): CompletedReviewSessionIdentity | undefined => {
@@ -454,7 +468,11 @@ export default function registerReviewTable(
 		restoreCompletedReviewBranch(completedReviews, ctx.sessionManager.getBranch(), session);
 	};
 	type PendingCompletion =
-		| { readonly record: CompletedReviewRecord; readonly session?: CompletedReviewSessionIdentity }
+		| {
+			readonly record: CompletedReviewRecord;
+			readonly replacedRecord?: CompletedReviewRecord;
+			readonly session?: CompletedReviewSessionIdentity;
+		}
 		| { readonly error: string };
 	let pendingCompletion: PendingCompletion | undefined;
 	const completionError = (invocation: ReviewInvocation, failure?: string): PendingCompletion | undefined => {
@@ -474,12 +492,15 @@ export default function registerReviewTable(
 		try {
 			const repository = await resolveRepositoryBinding(ctx.cwd);
 			// Cache before publication preflight; persist after Pi stores the assistant message.
-			const record = completedReviews.remember(parsed.review, invocation, repository);
+			const replacement = completedReviews.replace(parsed.review, invocation, repository);
+			const { record } = replacement;
 			const session = sessionIdentity(ctx);
 			if (!session) {
 				ctx.ui.notify("Completed review cache will not survive reload: session identity is unavailable", "warning");
 			}
-			return session ? { record, session } : { record };
+			return session
+				? { record, ...(replacement.previous ? { replacedRecord: replacement.previous } : {}), session }
+				: { record, ...(replacement.previous ? { replacedRecord: replacement.previous } : {}) };
 		} catch (error) {
 			ctx.ui.notify(`Completed review is not available to publish-only: ${String(error)}`, "warning");
 			return completionError(
@@ -490,6 +511,12 @@ export default function registerReviewTable(
 	};
 	let outputRepairAttempted = false;
 	let outputRepairCancelled = false;
+	let outputRepairGeneration = 0;
+	const clearOutputRepair = () => {
+		outputRepairGeneration++;
+		outputRepairAttempted = false;
+		outputRepairCancelled = false;
+	};
 	const telemetryTracker = new ReviewTelemetryTracker();
 	const persistTelemetry = (completion: ReviewPerformanceTelemetry["completion"]) => {
 		const telemetry = telemetryTracker.finish(completion);
@@ -563,8 +590,7 @@ export default function registerReviewTable(
 		loopCoordinator.clear();
 		selfReviewCoordinator.clear();
 		pendingCompletion = undefined;
-		outputRepairAttempted = false;
-		outputRepairCancelled = false;
+		clearOutputRepair();
 		telemetryTracker.clear();
 	};
 
@@ -586,8 +612,7 @@ export default function registerReviewTable(
 		selfReviewCoordinator.clear();
 		if (!outputRepairCancelled) return;
 		loopCoordinator.clear();
-		outputRepairAttempted = false;
-		outputRepairCancelled = false;
+		clearOutputRepair();
 		persistTelemetry("cleared");
 	});
 
@@ -595,8 +620,7 @@ export default function registerReviewTable(
 		loopCoordinator.clear();
 		selfReviewCoordinator.clear();
 		pendingCompletion = undefined;
-		outputRepairAttempted = false;
-		outputRepairCancelled = false;
+		clearOutputRepair();
 		restoreCompletedReviews(ctx);
 		telemetryTracker.clear();
 		const session = sessionIdentity(ctx);
@@ -615,11 +639,14 @@ export default function registerReviewTable(
 		selfReviewCoordinator.clear();
 		if (outputRepairAttempted) {
 			outputRepairCancelled = true;
+			loopCoordinator.clear();
+			clearOutputRepair();
+			persistTelemetry("cleared");
 			ctx.abort();
-			ctx.ui.notify("PR review output correction was cancelled; overlapping input was not queued, so retry it when the agent settles", "warning");
+			ctx.ui.notify("PR review output correction was cancelled; overlapping input was not queued, so retry it", "warning");
 			return { action: "handled" as const };
 		}
-		outputRepairAttempted = false;
+		clearOutputRepair();
 		const source = event.source as ReviewLoopInputSource;
 		const directPublish = parseDirectPublishRequest(event.text);
 		if (
@@ -748,8 +775,7 @@ export default function registerReviewTable(
 				ctx.ui.notify("PR review was not posted: automatic output correction attempted to call tools", "error");
 				ctx.abort();
 				loopCoordinator.clear();
-				outputRepairAttempted = false;
-				outputRepairCancelled = false;
+				clearOutputRepair();
 				persistTelemetry("cleared");
 				return;
 			}
@@ -766,8 +792,7 @@ export default function registerReviewTable(
 		}
 		if (completion === "clear_invocation") {
 			loopCoordinator.clear();
-			outputRepairAttempted = false;
-			outputRepairCancelled = false;
+			clearOutputRepair();
 			persistTelemetry("cleared");
 			return;
 		}
@@ -787,22 +812,63 @@ export default function registerReviewTable(
 		if (active && !publishable?.review && !outputRepairAttempted) {
 			const error = publishable?.error ?? "final review JSON is invalid";
 			if (loopCoordinator.suspendToolsForRepair()) {
+				const lease = loopCoordinator.repairLease(ctx);
+				if (!lease) {
+					ctx.ui.notify("Automatic PR review output correction was skipped because its review lease was lost", "warning");
+					return;
+				}
 				outputRepairAttempted = true;
 				outputRepairCancelled = false;
-				ctx.ui.notify(`PR review output is invalid (${error}); automatically correcting it once`, "warning");
-				pi.sendMessage(
-					{
-						customType: "pr-review-output-repair",
-						content: [
-							`The completed PR review could not be accepted because ${error}.`,
-							"This is the only automatic correction attempt. Do not call tools, redo the review, or change its substance.",
-							"Re-emit the same completed review as exactly one JSON object satisfying the required OUTPUT FORMAT. Emit no Markdown fences, prose, headings, or trailing text.",
-						].join(" "),
-						display: false,
-						details: { error, attempt: 1 },
-					},
-					{ triggerTurn: true, deliverAs: "followUp" },
-				);
+				const repairGeneration = ++outputRepairGeneration;
+				const isActiveRepair = () => !outputRepairCancelled && repairGeneration === outputRepairGeneration &&
+					loopCoordinator.isRepairLeaseActive(lease, ctx);
+				ctx.ui.notify(`PR review output is invalid (${error}); asking the light repair subagent once`, "warning");
+				void repairOutput(text, REVIEW_OUTPUT_CONTRACT, ctx, lease.signal).then(async (repairedText) => {
+					if (!isActiveRepair()) return;
+					const repaired = repairedText ? parsePublishableReview(repairedText) : undefined;
+					if (!repaired?.review) {
+						if (isActiveRepair()) {
+							loopCoordinator.consume();
+							clearOutputRepair();
+							persistTelemetry("terminal_response");
+							ctx.ui.notify("PR review was not posted: light output correction did not produce valid final JSON", "error");
+						}
+						return;
+					}
+					const invocation = loopCoordinator.peek();
+					if (!invocation || !isActiveRepair()) return;
+					const completion = await resolveCompletion(repaired, invocation, ctx);
+					if (!isActiveRepair()) {
+						if (completion && "record" in completion) {
+							completedReviews.restoreReplacement(completion.record, completion.replacedRecord);
+						}
+						return;
+					}
+					if (completion && "record" in completion) {
+						if (completion.session) {
+							try {
+								pi.appendEntry(COMPLETED_REVIEW_ENTRY_TYPE, completedReviews.persist(completion.record, completion.session));
+							} catch (persistError) {
+								ctx.ui.notify(`Completed review cache will not survive an extension reload: ${String(persistError)}`, "warning");
+							}
+						}
+						if (!isActiveRepair()) return;
+						await publishCompletedReview(completion.record, { kind: "frozen-invocation" }, ctx);
+					} else if (completion && "error" in completion) {
+						ctx.ui.notify(`PR review was not posted: ${completion.error}`, "error");
+					}
+					if (isActiveRepair()) {
+						loopCoordinator.consume();
+						clearOutputRepair();
+						persistTelemetry("terminal_response");
+					}
+				}).catch(() => {
+					if (!isActiveRepair()) return;
+					loopCoordinator.consume();
+					clearOutputRepair();
+					persistTelemetry("terminal_response");
+					ctx.ui.notify("PR review was not posted: light output correction failed", "error");
+				});
 				return;
 			}
 			ctx.ui.notify("Automatic PR review output correction was skipped because tools could not be disabled", "warning");
@@ -812,8 +878,7 @@ export default function registerReviewTable(
 		// Persist timing before publication so network/write latency is never coupled to review wall time.
 		const invocation = active ? loopCoordinator.consume() : undefined;
 		if (invocation) {
-			outputRepairAttempted = false;
-			outputRepairCancelled = false;
+			clearOutputRepair();
 			persistTelemetry("terminal_response");
 		}
 		const review = publishable?.review

package/lib/pr-review-loop.ts

@@ -233,6 +233,24 @@ export class ReviewLoopCoordinator {
 		this.setToolsEnabled(false);
 	}
 
+	/** Return the current loop's abortable lease while its tools are suspended for output repair. */
+	repairLease(ctx: Pick<ExtensionContext, "cwd" | "sessionManager">): ReviewLoopLease | undefined {
+		const phase = this.invocationGate.phase();
+		if (!this.binding || this.suspendedTools === undefined || (phase !== "reviewing" && phase !== "confirmed")) return undefined;
+		if (!sameBinding(this.binding, ctx) || this.binding.controller.signal.aborted) {
+			this.clear();
+			return undefined;
+		}
+		return Object.freeze({ generation: this.binding.generation, signal: this.binding.controller.signal });
+	}
+
+	/** Check a repair lease without re-enabling the review tools. */
+	isRepairLeaseActive(lease: ReviewLoopLease, ctx: Pick<ExtensionContext, "cwd" | "sessionManager">): boolean {
+		return !!this.binding && this.suspendedTools !== undefined &&
+			this.binding.generation === lease.generation && !lease.signal.aborted &&
+			(this.phase() === "reviewing" || this.phase() === "confirmed") && sameBinding(this.binding, ctx);
+	}
+
 	/** Hide every tool for a format-only repair turn while retaining invocation authority. */
 	suspendToolsForRepair(): boolean {
 		const phase = this.invocationGate.phase();

package/lib/pr-review-publish.ts

@@ -603,17 +603,26 @@ export class CompletedReviewCache {
 	private readonly reviews = new Map<string, CompletedReviewRecord>();
 
 	remember(review: ReviewLike, invocation: ReviewInvocation, repository: RepositoryBinding): CompletedReviewRecord {
+		return this.replace(review, invocation, repository).record;
+	}
+
+	/** Replace one PR record while retaining its predecessor for cancellation rollback. */
+	replace(review: ReviewLike, invocation: ReviewInvocation, repository: RepositoryBinding): {
+		record: CompletedReviewRecord;
+		previous?: CompletedReviewRecord;
+	} {
 		const record = {
 			review,
 			invocation: { ...invocation, autoPost: { ...invocation.autoPost } },
 			repository: { ...repository },
 		};
 		const key = completedReviewKey(repository, invocation.prNumber);
+		const previous = this.reviews.get(key);
 		// Refresh insertion order so unnumbered direct publish requests bind to
 		// the most recently completed review in this repository.
 		this.reviews.delete(key);
 		this.reviews.set(key, record);
-		return record;
+		return previous ? { record, previous } : { record };
 	}
 
 	persist(
@@ -675,6 +684,20 @@ export class CompletedReviewCache {
 		return true;
 	}
 
+	/** Remove this exact record without deleting a newer completion for the same PR. */
+	forget(record: CompletedReviewRecord): void {
+		const key = completedReviewKey(record.repository, record.invocation.prNumber);
+		if (this.reviews.get(key) === record) this.reviews.delete(key);
+	}
+
+	/** Undo a replacement only when this exact record is still current. */
+	restoreReplacement(record: CompletedReviewRecord, previous: CompletedReviewRecord | undefined): void {
+		const key = completedReviewKey(record.repository, record.invocation.prNumber);
+		if (this.reviews.get(key) !== record) return;
+		this.reviews.delete(key);
+		if (previous) this.reviews.set(key, previous);
+	}
+
 	get(prNumber: number, repository: RepositoryBinding): CompletedReviewRecord | undefined {
 		return this.reviews.get(completedReviewKey(repository, prNumber));
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-pr-review",
-  "version": "1.11.0",
+  "version": "1.11.2",
   "description": "Parallel AI code review for GitHub pull requests in the Pi coding agent, with model-agnostic tiered subagents, structured findings, optional verification, and safe COMMENT-only publishing.",
   "keywords": [
     "pi-package",