pi-pr-review 1.10.2 → 1.10.4

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "1.10.2"
+  ".": "1.10.4"
 }

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.10.4](https://github.com/10ego/pi-pr-review/compare/v1.10.3...v1.10.4) (2026-07-15)
+
+
+### Bug Fixes
+
+* **publish:** summarize findings without diff patches ([#29](https://github.com/10ego/pi-pr-review/issues/29)) ([bdee1ff](https://github.com/10ego/pi-pr-review/commit/bdee1ff024863019a2f357b04cffe944006a5726))
+
+## [1.10.3](https://github.com/10ego/pi-pr-review/compare/v1.10.2...v1.10.3) (2026-07-15)
+
+
+### Bug Fixes
+
+* **publish:** retry invalid review output once ([#27](https://github.com/10ego/pi-pr-review/issues/27)) ([9689505](https://github.com/10ego/pi-pr-review/commit/968950579c4eeec0ac264dccf3bda9b1833df160))
+
 ## [1.10.2](https://github.com/10ego/pi-pr-review/compare/v1.10.1...v1.10.2) (2026-07-15)
 
 

package/README.md

@@ -184,7 +184,9 @@ Publishing is off by default.
 
 The extension—not the model—owns publishing. It creates one formal review with the event hardcoded to `COMMENT`; it never submits `APPROVE` or `REQUEST_CHANGES`. Before writing, it verifies the current PR head, validates inline anchors, and checks for a review of the same head by the current GitHub identity.
 
-Closed or merged PRs use a body-only review. Open PRs attach eligible P0–P3 findings as inline comments and keep nits or off-diff findings in the review body. When multiple findings target the same diff anchor, the first is attached inline and later findings remain in the review body so publication neither fails nor drops review content.
+If the agent's final review is not valid exact-contract JSON, the extension logs the validation reason and automatically asks the same agent to correct its completed output once, with all tools disabled and without changing the captured posting authority. A valid correction is cached and publication is attempted under the original flags/config. If that single correction is also invalid or attempts to call a tool, publication stops and reports the error instead of looping. Overlapping input cancels the correction, remains unqueued, and must be retried after the agent settles.
+
+Closed or merged PRs use a body-only review. Open PRs attach eligible P0–P3 findings as inline comments and keep nits or off-diff findings in the review body. When GitHub omits patch metadata needed to validate an inline anchor, the affected finding remains in the review summary instead of blocking publication. When multiple findings target the same diff anchor, the first is attached inline and later findings remain in the review body so publication neither fails nor drops review content.
 
 After a review completes, you can directly ask the agent to “post the inline review” or “post it as an inline review.” The extension handles that request directly before an agent turn, selecting the latest cached review for an unnumbered request or the named PR in “publish the review for PR #123.” Only fresh interactive/RPC input can trigger this path; extension-generated, queued, or steering input cannot. The extension publishes only validated cached content, never replacement model-authored text, and never starts or reruns review agents. A direct request permits stale publication.
 

package/extensions/review-table.ts

@@ -456,6 +456,8 @@ export default function registerReviewTable(
 				session?: CompletedReviewSessionIdentity;
 		  }
 		| undefined;
+	let outputRepairAttempted = false;
+	let outputRepairCancelled = false;
 	const telemetryTracker = new ReviewTelemetryTracker();
 	const persistTelemetry = (completion: ReviewPerformanceTelemetry["completion"]) => {
 		const telemetry = telemetryTracker.finish(completion);
@@ -554,6 +556,8 @@ export default function registerReviewTable(
 		loopCoordinator.clear();
 		selfReviewCoordinator.clear();
 		pendingCompletion = undefined;
+		outputRepairAttempted = false;
+		outputRepairCancelled = false;
 		telemetryTracker.clear();
 	};
 
@@ -573,12 +577,19 @@ export default function registerReviewTable(
 
 	pi.on("agent_settled", () => {
 		selfReviewCoordinator.clear();
+		if (!outputRepairCancelled) return;
+		loopCoordinator.clear();
+		outputRepairAttempted = false;
+		outputRepairCancelled = false;
+		persistTelemetry("cleared");
 	});
 
 	pi.on("session_tree", (event, ctx) => {
 		loopCoordinator.clear();
 		selfReviewCoordinator.clear();
 		pendingCompletion = undefined;
+		outputRepairAttempted = false;
+		outputRepairCancelled = false;
 		restoreCompletedReviews(ctx);
 		telemetryTracker.clear();
 		const session = sessionIdentity(ctx);
@@ -595,6 +606,13 @@ export default function registerReviewTable(
 		// Any new input revokes the prior top-level task generation before it can
 		// authorize a replay or a queued/steering continuation.
 		selfReviewCoordinator.clear();
+		if (outputRepairAttempted) {
+			outputRepairCancelled = true;
+			ctx.abort();
+			ctx.ui.notify("PR review output correction was cancelled; overlapping input was not queued, so retry it when the agent settles", "warning");
+			return { action: "handled" as const };
+		}
+		outputRepairAttempted = false;
 		const source = event.source as ReviewLoopInputSource;
 		const directPublish = parseDirectPublishRequest(event.text);
 		if (
@@ -715,7 +733,20 @@ export default function registerReviewTable(
 	pi.on("message_end", async (event, ctx) => {
 		if (event.message.role !== "assistant") return;
 		const completion = classifyAssistantCompletion(event.message.stopReason, hasToolCall(event.message));
+		if (outputRepairCancelled) {
+			if (completion === "continue_tools") ctx.abort();
+			return;
+		}
 		if (completion === "continue_tools") {
+			if (outputRepairAttempted && loopCoordinator.peek()) {
+				ctx.ui.notify("PR review was not posted: automatic output correction attempted to call tools", "error");
+				ctx.abort();
+				loopCoordinator.clear();
+				outputRepairAttempted = false;
+				outputRepairCancelled = false;
+				persistTelemetry("cleared");
+				return;
+			}
 			const toolCalls = Array.isArray(event.message.content)
 				? event.message.content.filter((part) => part.type === "toolCall")
 				: [];
@@ -729,6 +760,8 @@ export default function registerReviewTable(
 		}
 		if (completion === "clear_invocation") {
 			loopCoordinator.clear();
+			outputRepairAttempted = false;
+			outputRepairCancelled = false;
 			persistTelemetry("cleared");
 			return;
 		}
@@ -744,15 +777,42 @@ export default function registerReviewTable(
 			return;
 		}
 
-		// Every other terminal response consumes authority, whether valid, empty, or unrelated.
+		let publishable = active ? parsePublishableReview(text) : undefined;
+		if (active && !publishable?.review && !outputRepairAttempted) {
+			const error = publishable?.error ?? "final review JSON is invalid";
+			if (loopCoordinator.suspendToolsForRepair()) {
+				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" },
+				);
+				return;
+			}
+			ctx.ui.notify("Automatic PR review output correction was skipped because tools could not be disabled", "warning");
+		}
+
+		// A valid response, or a failed single correction, consumes authority.
 		// Persist timing before publication so network/write latency is never coupled to review wall time.
 		const invocation = active ? loopCoordinator.consume() : undefined;
-		if (invocation) persistTelemetry("terminal_response");
-		if (!text.trim()) return;
-		const review = parseReview(text);
-		if (!review) return; // not a /pr-review JSON payload — leave untouched
 		if (invocation) {
-			const publishable = parsePublishableReview(text);
+			outputRepairAttempted = false;
+			outputRepairCancelled = false;
+			persistTelemetry("terminal_response");
+		}
+		const review = text.trim() ? parseReview(text) : null;
+		if (invocation) {
+			publishable ??= parsePublishableReview(text);
 			let repository: RepositoryBinding | undefined;
 			let record: CompletedReviewRecord | undefined;
 			let session: CompletedReviewSessionIdentity | undefined;
@@ -775,6 +835,7 @@ export default function registerReviewTable(
 			}
 			pendingCompletion = { text, invocation, repository, record, session };
 		}
+		if (!review) return; // not a renderable /pr-review JSON payload — leave untouched
 
 		// Keep raw JSON for automation; only prettify for interactive terminals.
 		if (ctx.mode !== "tui") return;

package/lib/pr-review-loop.ts

@@ -76,11 +76,13 @@ export class ReviewLoopCoordinator {
 	private readonly invocationGate = new ReviewInvocationGate();
 	private readonly focusRegistry = new ReviewFocusRegistry();
 	private binding?: ReviewLoopBinding;
+	private suspendedTools?: string[];
 	private nextGeneration = 1;
 
 	constructor(private readonly pi: Pick<ExtensionAPI, "getActiveTools" | "setActiveTools">) {}
 
 	private setToolsEnabled(enabled: boolean): void {
+		if (this.suspendedTools !== undefined) return;
 		try {
 			const current = this.pi.getActiveTools();
 			const next = enabled
@@ -150,7 +152,9 @@ export class ReviewLoopCoordinator {
 
 	acquire(ctx: Pick<ExtensionContext, "cwd" | "sessionManager">): ReviewLoopLease | undefined {
 		const phase = this.invocationGate.phase();
-		if ((phase !== "reviewing" && phase !== "confirmed") || !this.binding) return undefined;
+		if (this.suspendedTools !== undefined || (phase !== "reviewing" && phase !== "confirmed") || !this.binding) {
+			return undefined;
+		}
 		if (!sameBinding(this.binding, ctx) || this.binding.controller.signal.aborted) {
 			this.clear();
 			return undefined;
@@ -165,6 +169,7 @@ export class ReviewLoopCoordinator {
 		lease: ReviewLoopLease,
 		ctx: Pick<ExtensionContext, "cwd" | "sessionManager">,
 	): boolean {
+		if (this.suspendedTools !== undefined) return false;
 		const active = !!this.binding &&
 			this.binding.generation === lease.generation &&
 			!lease.signal.aborted &&
@@ -219,11 +224,48 @@ export class ReviewLoopCoordinator {
 		this.setToolsEnabled(false);
 	}
 
+	/** Hide every tool for a format-only repair turn while retaining invocation authority. */
+	suspendToolsForRepair(): boolean {
+		const phase = this.invocationGate.phase();
+		if (
+			this.suspendedTools !== undefined ||
+			!this.binding ||
+			(phase !== "reviewing" && phase !== "confirmed")
+		) {
+			return false;
+		}
+		let baseTools: string[] = [];
+		try {
+			baseTools = this.pi.getActiveTools().filter((name) => !REVIEW_LOOP_TOOL_SET.has(name));
+			this.suspendedTools = baseTools;
+			this.pi.setActiveTools([]);
+			return true;
+		} catch {
+			this.suspendedTools = undefined;
+			try {
+				this.pi.setActiveTools(baseTools);
+			} catch {
+				// Failure to restore remains fail-closed with no repair turn started.
+			}
+			return false;
+		}
+	}
+
 	private revokeBinding(): void {
 		const generation = this.binding?.generation;
 		if (generation !== undefined) this.focusRegistry.close(generation);
 		this.binding?.controller.abort();
 		this.binding = undefined;
+		const suspendedTools = this.suspendedTools;
+		this.suspendedTools = undefined;
+		if (suspendedTools !== undefined) {
+			try {
+				this.pi.setActiveTools(suspendedTools);
+			} catch {
+				// Keep tools fail-closed if the extension runtime is shutting down.
+			}
+			return;
+		}
 		this.setToolsEnabled(false);
 	}
 }

package/lib/pr-review-publish.ts

@@ -837,6 +837,7 @@ function isInlineSeverity(finding: ReviewFindingLike): boolean {
 export interface CommentValidationResult {
 	comments: PublishComment[];
 	errors: string[];
+	warnings?: string[];
 }
 
 export function validateInlineComments(
@@ -844,6 +845,7 @@ export function validateInlineComments(
 	changedFiles: ChangedFileLike[],
 ): CommentValidationResult {
 	const errors: string[] = [];
+	const warnings: string[] = [];
 	const comments: PublishComment[] = [];
 	const files = new Map<string, ChangedFileLike>();
 	for (const file of changedFiles) {
@@ -876,7 +878,9 @@ export function validateInlineComments(
 			continue;
 		}
 		if (!file.patch) {
-			errors.push(`${label}: diff patch is unavailable for anchor validation`);
+			// GitHub legitimately omits patch metadata for some large, binary, or transiently unavailable diffs.
+			// Keep the complete finding in the review summary rather than sending an unvalidated inline anchor.
+			warnings.push(`${label}: diff patch is unavailable; kept in the review summary`);
 			continue;
 		}
 		const sideKey = side === "LEFT" ? "left" : "right";
@@ -913,7 +917,7 @@ export function validateInlineComments(
 	if (comments.length > MAX_INLINE_COMMENTS) {
 		errors.push(`too many inline comments (${comments.length}; max ${MAX_INLINE_COMMENTS})`);
 	}
-	return { comments, errors };
+	return { comments, errors, warnings };
 }
 
 export function collectFoldedComments(review: ReviewLike): CommentValidationResult {
@@ -954,7 +958,7 @@ export function collectFoldedComments(review: ReviewLike): CommentValidationResu
 			...(Number(start) < Number(end) ? { start_line: Number(start), start_side: side } : {}),
 		});
 	}
-	return { comments, errors };
+	return { comments, errors, warnings: [] };
 }
 
 export function foldInlineComments(summary: string, comments: PublishComment[]): string {
@@ -1244,6 +1248,7 @@ export async function publishPullReview(input: {
 		if (!lifecycle.lifecycle) return { status: "failed", message: lifecycle.error ?? "invalid PR lifecycle" };
 		const isOpen = lifecycle.lifecycle === "open";
 		let comments: PublishComment[] = [];
+		let inlineWarningCount = 0;
 		if (!isOpen) {
 			const candidates = collectFoldedComments(review);
 			if (candidates.errors.length > 0) {
@@ -1270,6 +1275,7 @@ export async function publishPullReview(input: {
 					return { status: "failed", message: `inline validation failed: ${validated.errors.join("; ")}` };
 				}
 				comments = validated.comments;
+				inlineWarningCount = validated.warnings?.length ?? 0;
 			}
 		}
 
@@ -1316,6 +1322,10 @@ export async function publishPullReview(input: {
 			return { status: "failed", message: `final head check failed: ${String(error)}` };
 		}
 
+		const inlineWarning = inlineWarningCount > 0
+			? `; ${inlineWarningCount} inline finding${inlineWarningCount === 1 ? "" : "s"} kept in the summary because GitHub omitted diff patch metadata`
+			: "";
+		const degraded = !isOpen || headPlan.stale || inlineWarningCount > 0;
 		const post = await runGh(
 			githubApiArgs(hostname, "--method", "POST", `repos/${repository}/pulls/${prNumber}/reviews`, "--input", "-"),
 			cwd,
@@ -1328,13 +1338,12 @@ export async function publishPullReview(input: {
 			} catch {
 				/* accepted response without parseable metadata */
 			}
-			const degraded = !isOpen || headPlan.stale;
 			return {
 				status: degraded ? "posted_degraded" : "posted",
 				message: headPlan.stale
 					? `body-only stale COMMENT review posted (${headPlan.reviewedHeadSha} -> ${headPlan.currentHeadSha})`
 					: isOpen
-						? "GitHub COMMENT review posted"
+						? `GitHub COMMENT review posted${inlineWarning}`
 						: "body-only COMMENT review posted for non-open PR",
 				reviewId: response.id,
 				url: response.html_url,
@@ -1344,8 +1353,8 @@ export async function publishPullReview(input: {
 		try {
 			if (await hasExistingMarker(cwd, hostname, repository, prNumber, identity, normalizedHeadSha)) {
 				return {
-					status: !isOpen || headPlan.stale ? "posted_degraded" : "posted",
-					message: "GitHub review found during failure reconciliation",
+					status: degraded ? "posted_degraded" : "posted",
+					message: `GitHub review found during failure reconciliation${inlineWarning}`,
 					reconciled: true,
 				};
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-pr-review",
-  "version": "1.10.2",
+  "version": "1.10.4",
   "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",

package/prompts/pr-review.md

@@ -194,7 +194,7 @@ The orchestrator must never call `gh` to post comments or reviews. Always finish
 - `--comment` → force publication for this run, but never bypass validation, stale-head checks, or duplicate checks
 - `--no-comment` → suppress publication for this run
 
-When enabled, the extension creates exactly one formal GitHub pull-request review. Its top-level body contains the overview, verification, strengths, suggested verdict, counts, nits, and findings that cannot be attached inline. Eligible P0–P3 diff-anchored findings are attached as inline comments within that same review and are omitted from the top-level issue list to avoid duplication. If multiple findings share one diff anchor, the first is attached inline and later findings remain in the top-level body instead of failing publication or dropping content. The API event is hardcoded to `COMMENT`: publication never sends `APPROVE` or `REQUEST_CHANGES`, even when the suggested verdict is `request_changes`. It appends the same-head marker, verifies the current head, validates every inline anchor against GitHub diff metadata, and refuses partial open-PR publication. For a known closed/merged PR it requires either trusted `--include-closed`/`--review-closed` invocation authority or the one-shot affirmative confirmation flow, then posts one body-only `COMMENT` review with each inline finding folded into the body exactly once. Unknown lifecycle states and unconfirmed non-open writes fail without posting or falling back to an issue comment.
+When enabled, the extension creates exactly one formal GitHub pull-request review. Its top-level body contains the overview, verification, strengths, suggested verdict, counts, nits, and findings that cannot be attached inline. Eligible P0–P3 diff-anchored findings are attached as inline comments within that same review and are omitted from the top-level issue list to avoid duplication. If GitHub omits patch metadata needed to validate an anchor, that finding remains in the top-level body instead of blocking publication. If multiple findings share one diff anchor, the first is attached inline and later findings remain in the top-level body instead of failing publication or dropping content. The API event is hardcoded to `COMMENT`: publication never sends `APPROVE` or `REQUEST_CHANGES`, even when the suggested verdict is `request_changes`. It appends the same-head marker, verifies the current head, validates every attempted inline anchor against GitHub diff metadata, and refuses partial open-PR publication. For a known closed/merged PR it requires either trusted `--include-closed`/`--review-closed` invocation authority or the one-shot affirmative confirmation flow, then posts one body-only `COMMENT` review with each inline finding folded into the body exactly once. Unknown lifecycle states and unconfirmed non-open writes fail without posting or falling back to an issue comment.
 
 The extension caches the latest valid completed review per repository and PR before publication preflight in the current Pi session. The session-backed cache survives extension reloads and session resumes but is bound to the originating session instance and repository. On a later turn, the extension intercepts that direct input before an agent turn, publishes only extension-cached content, permits stale publication, and cannot rerun review agents. Stale publication is also enabled by default through the invocation-captured `allowStalePublish` setting. Every stale review is body-only, displays a warning with the reviewed and preflight-observed commit hashes, and omits potentially invalid inline anchors. If the captured setting disabled stale publication, the user can still run `/pr-review-publish <PR-NUM> --allow-stale`. Never rerun the review merely to change posting intent, and never attempt a direct GitHub write yourself.
 

package/tests/pr-review-extension-lifecycle.test.ts

@@ -69,6 +69,7 @@ interface Harness {
 	tools: Map<string, any>;
 	branch: any[];
 	notifications: string[];
+	sentMessages: Array<{ message: any; options: any }>;
 	activeTools(): string[];
 	abortCount(): number;
 	selfReviewCoordinator: SelfReviewPermitCoordinator;
@@ -117,11 +118,12 @@ fi
 	return dir;
 }
 
-function installFakePublishingGh(currentHead = "a".repeat(40)): string {
+function installFakePublishingGh(currentHead = "a".repeat(40), patchless = false): string {
 	const dir = mkdtempSync(join(tmpdir(), "pi-pr-review-publish-tool-"));
 	tempDirs.push(dir);
 	const gh = join(dir, "gh");
 	const payloadPath = join(dir, "payload.json");
+	const changedFiles = patchless ? '[[{"filename":"src/parser.ts","status":"modified"}]]' : "[[]]";
 	writeFileSync(
 		gh,
 		`#!/usr/bin/env bash
@@ -136,6 +138,8 @@ elif [[ "$args" == *"pulls/7/reviews?per_page=100"* || "$args" == *"issues/7/com
 elif [[ "$args" == *"--method POST"* ]]; then
   cat > '${payloadPath}'
   echo '{"id":42,"html_url":"https://github.com/owner/repo/pull/7#pullrequestreview-42"}'
+elif [[ "$args" == *"pulls/7/files?per_page=100"* ]]; then
+  echo '${changedFiles}'
 elif [[ "$args" == *"repos/owner/repo/pulls/7"* ]]; then
   printf '{"state":"open","draft":false,"merged_at":null,"head":{"sha":"%s"}}\n' '${currentHead}'
 else
@@ -156,6 +160,7 @@ function createHarness(initialBranch: any[] = [], identity = session): Harness {
 	const tools = new Map<string, any>();
 	const branch = [...initialBranch];
 	const notifications: string[] = [];
+	const sentMessages: Array<{ message: any; options: any }> = [];
 	let activeTools = ["read", "bash", ...REVIEW_LOOP_TOOL_NAMES];
 	let aborts = 0;
 	let promptPath = ownPromptPath;
@@ -191,6 +196,9 @@ function createHarness(initialBranch: any[] = [], identity = session): Harness {
 		appendEntry: (customType: string, data: unknown) => {
 			branch.push({ type: "custom", id: `custom-${nextId++}`, customType, data });
 		},
+		sendMessage: (message: any, options: any) => {
+			sentMessages.push({ message, options });
+		},
 		getActiveTools: () => [...activeTools],
 		setActiveTools: (next: string[]) => {
 			activeTools = [...next];
@@ -210,6 +218,7 @@ function createHarness(initialBranch: any[] = [], identity = session): Harness {
 		tools,
 		branch,
 		notifications,
+		sentMessages,
 		activeTools: () => [...activeTools],
 		abortCount: () => aborts,
 		selfReviewCoordinator,
@@ -241,6 +250,132 @@ function persistedInlineReview(identity = session, allowStalePublish = true): an
 }
 
 describe("completed review extension lifecycle", () => {
+	test("automatically corrects invalid final JSON once and attempts publication", async () => {
+		const harness = createHarness();
+		await harness.emit("input", { text: "/pr-review 7 --comment", source: "interactive" });
+		const wrapped = {
+			role: "assistant",
+			stopReason: "stop",
+			content: [{ type: "text", text: `\`\`\`json\n${JSON.stringify(review)}\n\`\`\`` }],
+		};
+		await harness.emit("message_end", { message: wrapped });
+		expect(harness.sentMessages).toHaveLength(1);
+		expect(harness.sentMessages[0]?.message).toMatchObject({
+			customType: "pr-review-output-repair",
+			display: false,
+		});
+		expect(harness.sentMessages[0]?.message.content).toContain("exactly one JSON object");
+		expect(harness.sentMessages[0]?.options).toEqual({ triggerTurn: true, deliverAs: "followUp" });
+		expect(harness.notifications.some((message) => message.includes("automatically correcting"))).toBeTrue();
+		expect(harness.activeTools()).toEqual([]);
+
+		harness.appendMessage(wrapped, "wrapped-review");
+		await harness.emit("turn_end", { message: wrapped, toolResults: [] });
+		expect(harness.notifications.some((message) => message.includes("was not posted"))).toBeFalse();
+
+		const payloadPath = installFakePublishingGh();
+		const corrected = {
+			role: "assistant",
+			stopReason: "stop",
+			content: [{ type: "text", text: JSON.stringify(review) }],
+		};
+		await harness.emit("message_end", { message: corrected });
+		harness.appendMessage(corrected, "corrected-review");
+		await harness.emit("turn_end", { message: corrected, toolResults: [] });
+
+		expect(harness.sentMessages).toHaveLength(1);
+		expect(harness.notifications.some((message) => message.includes("PR review posted"))).toBeTrue();
+		expect(JSON.parse(readFileSync(payloadPath, "utf8")).body).toContain("Checks lifecycle persistence");
+		expect(harness.activeTools()).toEqual(BASE_ACTIVE_TOOLS);
+	});
+
+	test("aborts and revokes repair authority when the correction attempts a tool call", async () => {
+		const harness = createHarness();
+		await harness.emit("input", { text: "/pr-review 7 --comment", source: "interactive" });
+		const invalid = {
+			role: "assistant",
+			stopReason: "stop",
+			content: [{ type: "text", text: "not json" }],
+		};
+		await harness.emit("message_end", { message: invalid });
+		expect(harness.activeTools()).toEqual([]);
+
+		await harness.emit("message_end", {
+			message: {
+				role: "assistant",
+				stopReason: "toolUse",
+				content: [{ type: "toolCall", id: "repair-bash", name: "bash", arguments: { command: "echo unsafe" } }],
+			},
+		});
+
+		expect(harness.abortCount()).toBe(1);
+		expect(harness.sentMessages).toHaveLength(1);
+		expect(harness.notifications.some((message) => message.includes("correction attempted to call tools"))).toBeTrue();
+		expect(harness.activeTools()).toEqual(BASE_ACTIVE_TOOLS);
+	});
+
+	test("keeps tools suspended until a cancelled repair definitively settles", async () => {
+		const harness = createHarness();
+		await harness.emit("input", { text: "/pr-review 7 --comment", source: "interactive" });
+		const invalid = {
+			role: "assistant",
+			stopReason: "stop",
+			content: [{ type: "text", text: "not json" }],
+		};
+		await harness.emit("message_end", { message: invalid });
+		expect(harness.activeTools()).toEqual([]);
+
+		const overlap = await harness.emit("input", {
+			text: "do something unrelated",
+			source: "interactive",
+			streamingBehavior: "steer",
+		});
+		expect(overlap).toContainEqual({ action: "handled" });
+		expect(harness.abortCount()).toBe(1);
+		expect(harness.activeTools()).toEqual([]);
+		expect(harness.notifications.some((message) => message.includes("was not queued"))).toBeTrue();
+
+		const staleCorrection = {
+			role: "assistant",
+			stopReason: "stop",
+			content: [{ type: "text", text: JSON.stringify(review) }],
+		};
+		await harness.emit("message_end", { message: staleCorrection });
+		harness.appendMessage(staleCorrection, "stale-correction");
+		await harness.emit("turn_end", { message: staleCorrection, toolResults: [] });
+		expect(harness.notifications.some((message) => message.includes("PR review posted"))).toBeFalse();
+		expect(harness.activeTools()).toEqual([]);
+
+		await harness.emit("agent_settled", {});
+		expect(harness.activeTools()).toEqual(BASE_ACTIVE_TOOLS);
+	});
+
+	test("stops after one automatic correction attempt", async () => {
+		const harness = createHarness();
+		await harness.emit("input", { text: "/pr-review 7 --comment", source: "interactive" });
+		const invalid = {
+			role: "assistant",
+			stopReason: "stop",
+			content: [{ type: "text", text: "not json" }],
+		};
+		await harness.emit("message_end", { message: invalid });
+		expect(harness.sentMessages).toHaveLength(1);
+		expect(harness.activeTools()).toEqual([]);
+		await harness.emit("turn_end", { message: invalid, toolResults: [] });
+
+		await harness.emit("message_end", { message: invalid });
+		harness.appendMessage(invalid, "invalid-retry");
+		await harness.emit("turn_end", { message: invalid, toolResults: [] });
+
+		expect(harness.sentMessages).toHaveLength(1);
+		expect(
+			harness.notifications.some((message) =>
+				message.includes("PR review was not posted: final response is not exactly one JSON object"),
+			),
+		).toBeTrue();
+		expect(harness.activeTools()).toEqual(BASE_ACTIVE_TOOLS);
+	});
+
 	test("persists a reference before publishing after Pi stores exact assistant JSON", async () => {
 		const harness = createHarness();
 		await harness.emit("input", { text: "/pr-review 7 --comment", source: "interactive" });
@@ -423,6 +558,41 @@ describe("completed review extension lifecycle", () => {
 		expect(payload.body).toContain(currentHead);
 	});
 
+	test("surfaces patchless inline fallback in the posted notification", async () => {
+		const patchlessReview: ReviewLike = {
+			...review,
+			findings: [
+				{
+					title: "[P2] Patchless finding",
+					severity: "P2",
+					blocking: false,
+					body: "This finding must remain visible in the summary.",
+					confidence_score: 0.9,
+					code_location: {
+						absolute_file_path: "src/parser.ts",
+						line_range: { start: 2, end: 2 },
+						side: "RIGHT",
+						commentable: true,
+					},
+				},
+			],
+		};
+		const cache = new CompletedReviewCache();
+		const record = cache.remember(patchlessReview, invocation, repository);
+		const persisted = cache.persist(record, session);
+		const cacheEntry = { type: "custom", id: "cache", customType: COMPLETED_REVIEW_ENTRY_TYPE, data: persisted };
+		const harness = createHarness([cacheEntry]);
+		await harness.emit("session_start", { reason: "reload" });
+		const payloadPath = installFakePublishingGh("a".repeat(40), true);
+
+		await harness.commands.get("pr-review-publish")!("7", harness.ctx);
+
+		expect(harness.notifications.some((message) => message.includes("1 inline finding kept in the summary"))).toBeTrue();
+		const payload = JSON.parse(readFileSync(payloadPath, "utf8"));
+		expect(payload.comments).toBeUndefined();
+		expect(payload.body).toContain("[P2] Patchless finding");
+	});
+
 	test("rejects extension-generated, queued, and steering publish requests", async () => {
 		const persisted = persistedInlineReview();
 		const cacheEntry = { type: "custom", id: "cache", customType: COMPLETED_REVIEW_ENTRY_TYPE, data: persisted };

package/tests/pr-review-loop.test.ts

@@ -55,6 +55,29 @@ describe("review-loop authority", () => {
 		expect(h.coordinator.acquire(h.ctx as any)).toBeDefined();
 	});
 
+	test("suspends every tool for output repair and restores only base tools", () => {
+		const h = harness();
+		h.coordinator.begin(parsePublishMode("/pr-review 7"), autoOff, "interactive", h.ctx as any);
+		const lease = h.coordinator.acquire(h.ctx as any)!;
+
+		expect(h.coordinator.suspendToolsForRepair()).toBeTrue();
+		expect(h.activeTools()).toEqual([]);
+		expect(h.coordinator.acquire(h.ctx as any)).toBeUndefined();
+		expect(h.coordinator.isLeaseActive(lease, h.ctx as any)).toBeFalse();
+		expect(lease.signal.aborted).toBeFalse();
+		expect(h.coordinator.suspendToolsForRepair()).toBeFalse();
+
+		expect(h.coordinator.consume()?.prNumber).toBe(7);
+		expect(lease.signal.aborted).toBeTrue();
+		expect(h.activeTools()).toEqual(["read", "bash"]);
+
+		h.coordinator.begin(parsePublishMode("/pr-review 8"), autoOff, "interactive", h.ctx as any);
+		expect(h.coordinator.suspendToolsForRepair()).toBeTrue();
+		h.coordinator.clear();
+		expect(h.activeTools()).toEqual(["read", "bash"]);
+		expect(h.coordinator.suspendToolsForRepair()).toBeFalse();
+	});
+
 	test("never authorizes extension-originated commands", () => {
 		const h = harness();
 		h.coordinator.hideTools();

package/tests/pr-review-publish.test.ts

@@ -536,6 +536,68 @@ fi
 		}
 	});
 
+	test("publishes a current review with patchless findings in the summary", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "pi-pr-review-gh-"));
+		const gh = join(dir, "gh");
+		const payloadPath = join(dir, "payload.json");
+		writeFileSync(
+			gh,
+			`#!/usr/bin/env bash
+set -euo pipefail
+args="$*"
+if [[ "$args" == "repo view --json nameWithOwner,url" ]]; then
+  echo '{"nameWithOwner":"owner/repo","url":"https://github.com/owner/repo"}'
+elif [[ "$args" == *" user --jq .login"* ]]; then
+  echo 'reviewer'
+elif [[ "$args" == *"--method POST"* ]]; then
+  cat > "$GH_FAKE_PAYLOAD"
+  echo '{"id":43,"html_url":"https://github.com/owner/repo/pull/7#pullrequestreview-43"}'
+elif [[ "$args" == *"pulls/7/reviews?per_page=100"* || "$args" == *"issues/7/comments?per_page=100"* ]]; then
+  echo '[]'
+elif [[ "$args" == *"pulls/7/files?per_page=100"* ]]; then
+  echo '[[{"filename":"src/parser.ts","status":"modified"}]]'
+elif [[ "$args" == *"repos/owner/repo/pulls/7"* ]]; then
+  printf '{"state":"open","draft":false,"merged_at":null,"head":{"sha":"%s"}}\n' "$GH_FAKE_CURRENT"
+else
+  echo "unexpected gh args: $args" >&2
+  exit 1
+fi
+`,
+		);
+		chmodSync(gh, 0o755);
+		const previousPath = process.env.PATH;
+		const previousPayload = process.env.GH_FAKE_PAYLOAD;
+		const previousCurrent = process.env.GH_FAKE_CURRENT;
+		const current = "a".repeat(40);
+		process.env.PATH = `${dir}:${previousPath ?? ""}`;
+		process.env.GH_FAKE_PAYLOAD = payloadPath;
+		process.env.GH_FAKE_CURRENT = current;
+		try {
+			const posted = await publishPullReview({
+				cwd: dir,
+				prNumber: 7,
+				headSha: current,
+				allowNonOpen: false,
+				expectedRepository: { hostname: "github.com", repository: "owner/repo" },
+				review,
+			});
+			expect(posted.status).toBe("posted_degraded");
+			expect(posted.message).toContain("1 inline finding kept in the summary");
+			const payload = JSON.parse(readFileSync(payloadPath, "utf8"));
+			expect(payload.comments).toBeUndefined();
+			expect(payload.body).toContain("[P2] Handle empty input");
+			expect(payload.body).toContain("Empty input currently returns the wrong value.");
+		} finally {
+			if (previousPath === undefined) delete process.env.PATH;
+			else process.env.PATH = previousPath;
+			if (previousPayload === undefined) delete process.env.GH_FAKE_PAYLOAD;
+			else process.env.GH_FAKE_PAYLOAD = previousPayload;
+			if (previousCurrent === undefined) delete process.env.GH_FAKE_CURRENT;
+			else process.env.GH_FAKE_CURRENT = previousCurrent;
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
 	test("preserves inline publication when the reviewed head is still current", () => {
 		const head = "a".repeat(40);
 		expect(planHeadPublication(head, head.toUpperCase(), false).plan).toMatchObject({
@@ -553,6 +615,7 @@ fi
 		expect(extension).toContain("Publishing never starts or reruns a review");
 		expect(extension).toContain("review was cancelled");
 		expect(readme).toContain("handles that request directly");
+		expect(readme).toContain("automatically asks the same agent to correct its completed output once");
 		expect(readme).toContain("`allowStalePublish: true`");
 		expect(readme).toContain("/pr-review-publish 123 --allow-stale");
 		expect(readme).toContain("Inline comments are always disabled for stale reviews");
@@ -684,6 +747,18 @@ describe("atomic COMMENT review payload", () => {
 		expect(result.errors[0]).toContain("not inside one diff hunk");
 	});
 
+	test("keeps findings in the summary when GitHub omits patch metadata", () => {
+		const result = validateInlineComments(review, [{ filename: "src/parser.ts" }]);
+		expect(result.errors).toEqual([]);
+		expect(result.comments).toEqual([]);
+		expect(result.warnings).toEqual([
+			"finding 1: diff patch is unavailable; kept in the review summary",
+		]);
+		const summary = buildReviewSummary(review, result.comments);
+		expect(summary).toContain("2 total (0 inline, 2 summary-only)");
+		expect(summary).toContain("[P2] Handle empty input");
+	});
+
 	test("folds inline findings exactly once into a body-only non-open review", () => {
 		const folded = collectFoldedComments(review);
 		expect(folded.errors).toEqual([]);