pi-pr-review 1.17.4 → 1.17.6

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.17.6](https://github.com/10ego/pi-pr-review/compare/v1.17.5...v1.17.6) (2026-09-01)
+
+
+### Bug Fixes
+
+* **review:** retain findings from timed-out lanes ([#134](https://github.com/10ego/pi-pr-review/issues/134)) ([78de3e6](https://github.com/10ego/pi-pr-review/commit/78de3e6c0941292e9de3d8243c1fee88987168b5))
+
+## [1.17.5](https://github.com/10ego/pi-pr-review/compare/v1.17.4...v1.17.5) (2026-09-01)
+
+
+### Bug Fixes
+
+* **review:** intercept manual publish requests ([#132](https://github.com/10ego/pi-pr-review/issues/132)) ([d251827](https://github.com/10ego/pi-pr-review/commit/d251827485de78deea93fbb4d5b90adedb5e5423))
+
 ## [1.17.4](https://github.com/10ego/pi-pr-review/compare/v1.17.3...v1.17.4) (2026-09-01)
 
 

package/README.md

@@ -191,11 +191,11 @@ Example:
 }
 ```
 
-Every invocation has a host-owned monotonic 15-minute hard cap, including the two GitHub identity/lifecycle preflights, parent orchestration, synthesis, termination grace, and reserved cleanup. The dependent preflight calls share the one invocation budget, so they cannot each add an independent command timeout before review timing begins. The reviewer batch window activates once, at the first reviewer dispatch: preflight and diff capture remain charged to the total cap but cannot exhaust `batchMs` before any reviewer starts. The activated batch is still truncated by the original total deadline and its synthesis/termination/cleanup reserves. Defaults bound light/medium/heavy attempts to 3/6/12 minutes, a fallback attempt to 3 minutes, and the concurrent batch to 12 minutes. The complete `deadlines` object may be replaced at user scope or by a trusted project; partial, malformed, non-integer, out-of-range, or internally inconsistent objects are rejected as a unit and the last valid/default finite budget remains active. Supported inclusive ranges are: attempts 30–720 seconds, fallback 30–360 seconds, batch 60–840 seconds, synthesis 10–120 seconds, total 120–1200 seconds, TERM grace 0.1–15 seconds, cleanup reserve 1–30 seconds, and minimum useful fallback 10–120 seconds. Minimum fallback must not exceed its attempt cap, and batch + synthesis + termination grace + cleanup must fit inside total.
+Every invocation has a host-owned monotonic 15-minute hard cap, including the two GitHub identity/lifecycle preflights, parent orchestration, synthesis, termination grace, and reserved cleanup. The dependent preflight calls share the one invocation budget, so they cannot each add an independent command timeout before review timing begins. The reviewer batch window activates once, at the first reviewer dispatch: preflight and diff capture remain charged to the total cap but cannot exhaust `batchMs` before any reviewer starts. The activated batch is still truncated by the original total deadline and its synthesis/termination/cleanup reserves. Defaults bound light/medium/heavy attempts to 3/6/12 minutes, a fallback attempt to 3 minutes, and the concurrent batch to 12 minutes. The complete `deadlines` object may be replaced at user scope or by a trusted project; partial, malformed, non-integer, out-of-range, or internally inconsistent objects are rejected as a unit and the last valid/default finite budget remains active. Supported inclusive ranges are: attempts 30–900 seconds, fallback 30–360 seconds, batch 60–900 seconds, synthesis 10–120 seconds, total 120–1200 seconds, TERM grace 0.1–15 seconds, cleanup reserve 1–30 seconds, and minimum useful fallback 10–120 seconds. Minimum fallback must not exceed its attempt cap, and batch + synthesis + termination grace + cleanup must fit inside total.
 
 A timed-out or retryable quota/rate-limit/capacity lane may start at most one configured fallback attempt. It starts only when at least `minimumFallbackMs` plus cleanup reserve remains; the host never changes the configured model, thinking level, or tool policy to save time. If a tier is unset, its existing nearest-configured-tier/Pi-default behavior is unchanged.
 
-On an attempt deadline the host records timeout separately from user cancellation, sends TERM to the original child, waits only `terminationGraceMs`, then sends KILL if no exit was observed and stops draining after the cleanup reserve. Partial assistant text and telemetry survive this lifecycle. The synthesis cap arms only once review work goes quiet: any turn that starts or any review tool that runs again while the cap is armed defers it, and it re-arms from the next turn end, so early review-tool turns (for example verification discovery) cannot starve later heavy lanes. Batch/total expiry stops queued work and waiting lanes; completed and partial artifacts proceed to Markdown synthesis or deterministic lane assembly, identify every incomplete reviewer, and remain eligible for the concise body-only `COMMENT` publication path. A timed-out lane is never reported as `NO FINDINGS` or full coverage, and a lane ended by the host total or synthesis deadline is disclosed with that kind (`deadline_expired`) instead of being mistaken for its own attempt deadline expiring. Host lane artifacts are authoritative for completeness in both directions: a false assistant completion claim cannot upgrade incomplete lanes, and a paraphrased or omitted `Lane completeness` line cannot downgrade a host-complete batch away from the concise renderer.
+On an attempt deadline the host records timeout separately from user cancellation, sends TERM to the original child, waits only `terminationGraceMs`, then sends KILL if no exit was observed and stops draining after the cleanup reserve. Partial assistant text and telemetry survive this lifecycle. The synthesis cap arms only once review work goes quiet: any turn that starts or any review tool that runs again while the cap is armed defers it, and it re-arms from the next turn end, so early review-tool turns (for example verification discovery) cannot starve later heavy lanes. Batch/total expiry stops queued work and waiting lanes; completed and partial artifacts proceed to Markdown synthesis or deterministic lane assembly, identify every incomplete reviewer, and remain eligible for concise `COMMENT` publication. Complete contract-valid candidate blocks retained before a timeout are deterministically recovered as canonical findings, including when terminal synthesis is absent; a truncated final block and arbitrary lane prose remain private. A timed-out lane is never reported as `NO FINDINGS` or full coverage, and a lane ended by the host total or synthesis deadline is disclosed with that kind (`deadline_expired`) instead of being mistaken for its own attempt deadline expiring. Host lane artifacts are authoritative for completeness in both directions: a false assistant completion claim cannot upgrade incomplete lanes, and a paraphrased or omitted `Lane completeness` line cannot downgrade a host-complete batch away from the concise renderer.
 
 Initial operating targets are ordinary-review p50 ≤ 6 minutes and p95 ≤ 12 minutes, and large-review p50 ≤ 10 minutes and p95 ≤ 14 minutes, with the 15-minute hard cap authoritative. Invocation telemetry starts before GitHub preflight and records configured deadline source/caps, termination grace, cleanup reserve, and active wall time; batch details record invocation time consumed before each attempt, batch/total time remaining at dispatch, first event/output timing, lifecycle counts, configured and effective batch-truncated attempt deadlines, fallback starts/budget rejections, external total/synthesis deadline expiries per lane, and termination grace/escalation data. These are initial production targets, not a promise that every provider completes before its host deadline.
 
@@ -227,9 +227,9 @@ Publishing is off by default.
 
 The extension owns normal publishing. Before review execution it captures repository, hostname, PR number/title, reviewed head, lifecycle state, posting/stale authority, and invocation identity independently of assistant text. After synthesis, it caches one validated completed review (the host-owned canonical artifact) 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.
 
-Review semantics are Markdown-first. A deterministic tolerant parser normalizes line endings, extracts complete findings when possible, and ignores heading-like text inside CommonMark fenced-code and HTML-block contexts. Every degraded synthesis — ambiguous, partially parsed, incomplete lane coverage, or absent terminal synthesis — is retained internally as one deterministic host-rendered artifact with generic code-review labels: a `Coverage` section with the exact lane lifecycle disclosure, a `Findings` section with host-formatted parsed findings (never a clean-review claim when nothing parsed), and the complete original synthesis plus every retained lane artifact preserved under `Retained synthesis` / `Retained lane output`. GitHub publication never dumps that artifact: it emits a concise `COMMENT` with a short incomplete-coverage or unstructured-output warning, validated inline findings, and summary-only `Other Notes`. Reserved markers are sanitized, size limits are enforced, and the canonical marker is appended only by host code. Optional formatting repair is never required and can never suppress the degraded fallback.
+Review semantics are Markdown-first. A deterministic tolerant parser normalizes line endings, extracts complete findings when possible, and ignores heading-like text inside CommonMark fenced-code and HTML-block contexts. Every degraded synthesis — ambiguous, partially parsed, incomplete lane coverage, or absent terminal synthesis — is retained internally as one deterministic host-rendered artifact with generic code-review labels: a `Coverage` section with the exact lane lifecycle disclosure, a `Findings` section with host-formatted parsed or contract-valid retained-lane findings (never a clean-review claim when nothing parsed), and the complete original synthesis plus every retained lane artifact preserved under `Retained synthesis` / `Retained lane output`. GitHub publication never dumps that artifact: it emits a concise `COMMENT` with a short incomplete-coverage or unstructured-output warning, validated inline findings, and summary-only `Other Notes`. Reserved markers are sanitized, size limits are enforced, and the canonical marker is appended only by host code. Optional formatting repair is never required and can never suppress the degraded fallback.
 
-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.
+You can publish the cache later with `/pr-review-publish 123`, or directly ask the agent to “post the inline review,” “manually post the review comments,” “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.
 
 Every authorized publish path builds one GitHub review payload and sends at most one review `POST`; it never submits `REQUEST_CHANGES` or retries a rejected write with a fallback POST. Fully parsed Markdown with one complete retained artifact for every host-registered dispatch may emit a gated `APPROVE` through the same host binding, priority, lifecycle, self-author, and stale checks as strict JSON. Host lane evidence is authoritative for completeness: a paraphrased or omitted `All requested lanes completed.` disclosure cannot downgrade a host-complete batch, and a false disclosure cannot upgrade incomplete or missing lane coverage; the assistant's canonical line is consulted only when no batch evidence exists. Verdict fields outside the document preamble, hidden in CommonMark code/HTML blocks, or inside lazy container continuations, severity-tagged headings outside `Findings`, incomplete or missing host lane coverage, malformed or unsafe output, and lane-fallback artifacts remain `COMMENT` reviews; their safely parsed findings keep inline placement, while unparsable output publishes body-only. Cache restore reclassifies persisted lane output and requires the exact host-recorded artifact key set, with every complete artifact matching the frozen invocation generation, tier, and minor-hygiene contract, and re-synthesizes the retained raw text under that frozen binding before retaining approval eligibility. For a current, open PR, the first 50 eligible P0–P3 findings with valid, unique diff anchors are inline. The concise top-level body starts with the verdict, points readers to inline findings, and places nits, off-diff findings, unavailable diff metadata, duplicate anchors, and overflow under `Other Notes`; overview, verification, strengths, and transport diagnostics stay out of the public summary. The complete original Markdown and retained lane evidence remain internal and are never substituted for a concise GitHub review, including degraded, incomplete, cached, direct, and stale `COMMENT` publication. If the concise body plus its canonical marker exceeds GitHub's limit, publication fails closed rather than dumping the full report. Stale or authorized non-open reviews are body-only. A stale approval additionally requires `allowStaleApprovals: true`.
 

package/lib/pr-review-artifacts.ts

@@ -186,6 +186,17 @@ interface CandidateBlock {
 	readonly fields: ReadonlyMap<string, string>;
 }
 
+export interface ValidatedReviewLaneCandidate {
+	readonly title: string;
+	readonly severity: "P0" | "P1" | "P2" | "P3" | "nit";
+	readonly why: string;
+	readonly location: string;
+	readonly side: "RIGHT" | "LEFT";
+	readonly inDiff: boolean;
+	readonly prRelated: boolean;
+	readonly confidence: number;
+}
+
 function normalizeReviewText(text: string): string {
 	// Only CRLF is transport normalization. In particular, do not trim or
 	// rewrite line-leading whitespace before applying the grammar.
@@ -380,6 +391,50 @@ function contradictoryFraming(values: readonly string[]): boolean {
  * exactly one nonempty value line per field. Candidate `why` may have
  * indented continuation lines; reserved productions cannot be continuations.
  */
+function parseCandidatePrefix(
+	lines: readonly string[],
+	startCursor: number,
+): { candidates: CandidateBlock[]; consumedAll: boolean } {
+	let cursor = startCursor;
+	const candidates: CandidateBlock[] = [];
+	while (cursor < lines.length) {
+		while (cursor < lines.length && !lines[cursor]!.trim()) cursor++;
+		if (cursor >= lines.length) return { candidates, consumedAll: true };
+		const start = cursor;
+		const fields = new Map<string, string>();
+		for (const expected of CANDIDATE_FIELDS) {
+			while (cursor < lines.length && !lines[cursor]!.trim()) cursor++;
+			const fieldLine = lines[cursor] ?? "";
+			if (fieldLine.trim() && /[ \t]+$/.test(fieldLine)) return { candidates, consumedAll: false };
+			const field = candidateLabel(fieldLine);
+			if (!field || canonicalField(field.field) !== expected || fields.has(expected)) {
+				return { candidates, consumedAll: false };
+			}
+			if (hasReservedCandidateProduction(expected, field.value)) return { candidates, consumedAll: false };
+			fields.set(expected, field.value);
+			cursor++;
+			if (expected !== "why") continue;
+			const whyLines = [field.value];
+			while (cursor < lines.length) {
+				const continuation = lines[cursor]!;
+				if (!continuation.trim()) break;
+				if (/[ \t]+$/.test(continuation)) return { candidates, consumedAll: false };
+				if (isReservedContractLine(continuation)) break;
+				if (!/^ {2}\S/.test(continuation) || /^ {2}(?:[-*+>]|#{1,6})[ \t]+/.test(continuation)) {
+					return { candidates, consumedAll: false };
+				}
+				if (hasReservedCandidateProduction("why", continuation.slice(2))) return { candidates, consumedAll: false };
+				whyLines.push(continuation.slice(2));
+				cursor++;
+			}
+			fields.set("why", whyLines.join("\n"));
+		}
+		if (!validCandidateFields(fields)) return { candidates, consumedAll: false };
+		candidates.push({ start, end: cursor, fields });
+	}
+	return { candidates, consumedAll: true };
+}
+
 function parseIntegratedCompletion(text: string): boolean {
 	if (hasTrailingHorizontalWhitespace(text) || CODE_FENCE.test(text) || hasHtmlContainer(text)) return false;
 	const lines = text.split("\n");
@@ -416,38 +471,70 @@ function parseIntegratedCompletion(text: string): boolean {
 		return cursor === lines.length;
 	}
 
-	const candidates: CandidateBlock[] = [];
-	while (cursor < lines.length) {
-		while (cursor < lines.length && !lines[cursor]!.trim()) cursor++;
-		if (cursor >= lines.length) break;
-		const start = cursor;
-		const first = candidateLabel(lines[cursor]!);
-		if (!first || canonicalField(first.field) !== "title") return false;
-		const fields = new Map<string, string>();
-		for (const expected of CANDIDATE_FIELDS) {
+	const parsed = parseCandidatePrefix(lines, cursor);
+	return parsed.consumedAll && parsed.candidates.length > 0;
+}
+
+/**
+ * Recover only complete, contract-valid candidate blocks from retained lane
+ * output. A timed-out final block may be truncated; earlier complete blocks
+ * remain usable, while arbitrary prose and unsafe containers recover nothing.
+ */
+export function extractValidatedReviewLaneCandidates(
+	rawText: string,
+	expectedOutput: "review_lane" | "nonempty" = "review_lane",
+): readonly ValidatedReviewLaneCandidate[] {
+	const text = normalizeReviewText(rawText);
+	if (
+		!text.trim() || CODE_FENCE.test(text) ||
+		hasHtmlContainer(text) || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(text) ||
+		/<!--\s*pi-pr-review:/i.test(text)
+	) return [];
+	const lines = text.split("\n");
+	let cursor = 0;
+	while (cursor < lines.length && !lines[cursor]!.trim()) cursor++;
+	if (expectedOutput === "nonempty") {
+		if (lines[cursor] !== "Review status: COMPLETE") return [];
+		const statusIndex = cursor++;
+		if (lines.some((line, index) => index !== statusIndex && hasReservedStatusProduction(line))) return [];
+		const framingValues: string[] = [];
+		for (const expected of FRAMING_LABELS) {
 			while (cursor < lines.length && !lines[cursor]!.trim()) cursor++;
-			const field = candidateLabel(lines[cursor] ?? "");
-			if (!field || canonicalField(field.field) !== expected || fields.has(expected)) return false;
-			if (hasReservedCandidateProduction(expected, field.value)) return false;
-			fields.set(expected, field.value);
+			const framingLine = lines[cursor] ?? "";
+			if (framingLine.trim() && /[ \t]+$/.test(framingLine)) return [];
+			const label = framingLabel(framingLine);
+			if (!label || canonicalField(label.field) !== expected.toLowerCase()) return [];
 			cursor++;
-			if (expected !== "why") continue;
-			const whyLines = [field.value];
-			while (cursor < lines.length) {
-				const continuation = lines[cursor]!;
-				if (!continuation.trim()) break;
-				if (isReservedContractLine(continuation)) break;
-				if (!/^ {2}\S/.test(continuation) || /^ {2}(?:[-*+>]|#{1,6})[ \t]+/.test(continuation)) return false;
-				if (hasReservedCandidateProduction("why", continuation.slice(2))) return false;
-				whyLines.push(continuation.slice(2));
+			let value = label.value;
+			if (label.kind === "heading") {
+				const valueLine = lines[cursor] ?? "";
+				if (!valueLine || !valueLine.trim() || /[ \t]+$/.test(valueLine) || /^[ \t]/.test(valueLine) || CONTAINER_PREFIX.test(valueLine) || isReservedContractLine(valueLine)) return [];
+				value = valueLine;
 				cursor++;
 			}
-			fields.set("why", whyLines.join("\n"));
+			if (!meaningfulValue(value) || framingValueHasReservedProduction(value)) return [];
+			framingValues.push(value);
 		}
-		if (!validCandidateFields(fields)) return false;
-		candidates.push({ start, end: cursor, fields });
+		if (topLevelFailure(framingValues.join("\n")) || contradictoryFraming(framingValues)) return [];
+	} else if (lines.some((line) => hasReservedStatusProduction(line))) {
+		return [];
 	}
-	return candidates.length > 0;
+	while (cursor < lines.length && !lines[cursor]!.trim()) cursor++;
+	if (lines.some((line) => line.trim() === NO_FINDINGS_SENTINEL || line.trim() === "NO FINDINGS")) return [];
+	const parsed = parseCandidatePrefix(lines, cursor);
+	return parsed.candidates.map((candidate) => {
+		const fields = candidate.fields;
+		return Object.freeze({
+			title: fields.get("title")!.trim(),
+			severity: fields.get("severity")!.trim() as ValidatedReviewLaneCandidate["severity"],
+			why: fields.get("why")!.trim(),
+			location: fields.get("location")!.trim(),
+			side: fields.get("side")!.trim() as ValidatedReviewLaneCandidate["side"],
+			inDiff: fields.get("in_diff")!.trim() === "yes",
+			prRelated: fields.get("pr_related")!.trim() === "yes",
+			confidence: Number(fields.get("confidence")!.trim()),
+		});
+	});
 }
 
 function hasMeaningfulField(text: string, field: string): boolean {

package/lib/pr-review-deadlines.ts

@@ -29,9 +29,9 @@ export const DEFAULT_REVIEW_DEADLINES: Readonly<ReviewDeadlineConfig> = Object.f
 });
 
 const LIMITS = {
-	attemptMs: [30_000, 720_000],
+	attemptMs: [30_000, 900_000],
 	fallbackAttemptMs: [30_000, 360_000],
-	batchMs: [60_000, 840_000],
+	batchMs: [60_000, 900_000],
 	synthesisMs: [10_000, 120_000],
 	totalMs: [120_000, 1_200_000],
 	terminationGraceMs: [100, 15_000],

package/lib/pr-review-markdown.ts

@@ -1,6 +1,10 @@
 import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
-import type { ExpectedReviewLane, ReviewLaneArtifact } from "./pr-review-artifacts.ts";
+import {
+	extractValidatedReviewLaneCandidates,
+	type ExpectedReviewLane,
+	type ReviewLaneArtifact,
+} from "./pr-review-artifacts.ts";
 import type { ReviewFindingLike, ReviewLike } from "./pr-review-publish.ts";
 
 export type ReviewSynthesisQuality = "fully_parsed" | "partially_parsed" | "raw" | "lane_fallback";
@@ -488,6 +492,76 @@ function retainedLaneText(lane: ReviewLaneArtifact): string {
 	return "";
 }
 
+function retainedLaneFindings(
+	lanes: readonly ReviewLaneArtifact[],
+	expected: readonly ExpectedReviewLane[],
+): ReviewFindingLike[] {
+	const findings: ReviewFindingLike[] = [];
+	const seen = new Set<string>();
+	for (const lane of lanes) {
+		const contract = expected.find((descriptor) => descriptor.key === lane.key)?.expectedOutput ?? "review_lane";
+		for (const candidate of extractValidatedReviewLaneCandidates(retainedLaneText(lane), contract)) {
+			if (!candidate.prRelated) continue;
+			const parsedLocation = candidate.location === "repo-wide"
+				? { status: "absent" as const, location: null }
+				: parseLocation(`${candidate.location} ${candidate.side}`);
+			if (parsedLocation.status === "unsafe") continue;
+			const codeLocation = parsedLocation.location
+				? { ...parsedLocation.location, commentable: candidate.inDiff }
+				: null;
+			const key = JSON.stringify([
+				candidate.severity,
+				candidate.title,
+				candidate.why,
+				candidate.location,
+				candidate.side,
+			]);
+			if (seen.has(key)) continue;
+			seen.add(key);
+			findings.push({
+				title: candidate.title,
+				severity: candidate.severity,
+				blocking: candidate.severity === "P0" || candidate.severity === "P1",
+				body: candidate.why,
+				confidence_score: candidate.confidence,
+				code_location: codeLocation,
+			});
+		}
+	}
+	return findings;
+}
+
+function mergeUniqueFindings(
+	primary: readonly ReviewFindingLike[],
+	additional: readonly ReviewFindingLike[],
+): ReviewFindingLike[] {
+	const merged = [...primary];
+	const keys = new Set(merged.map((finding) => JSON.stringify([
+		finding.severity,
+		finding.title,
+		finding.body,
+		finding.code_location?.absolute_file_path,
+		finding.code_location?.line_range?.start,
+		finding.code_location?.line_range?.end,
+		finding.code_location?.side,
+	])));
+	for (const finding of additional) {
+		const key = JSON.stringify([
+			finding.severity,
+			finding.title,
+			finding.body,
+			finding.code_location?.absolute_file_path,
+			finding.code_location?.line_range?.start,
+			finding.code_location?.line_range?.end,
+			finding.code_location?.side,
+		]);
+		if (keys.has(key)) continue;
+		keys.add(key);
+		merged.push(finding);
+	}
+	return merged;
+}
+
 function disclosedPassId(passId: string): string {
 	const normalized = passId.replace(new RegExp(UNSAFE_TEXT_CONTROL.source, "g"), "_").replace(/[\r\n]/g, "_").trim();
 	const sanitized = normalized.replace(/[^A-Za-z0-9._:@/-]+/g, "_") || "unnamed-pass";
@@ -704,6 +778,7 @@ export function synthesizeReviewArtifact(input: {
 		lanes.every((lane) => expectedLaneDescriptors.some((expected) =>
 			expected.key === lane.key && expected.tier === lane.tier &&
 			expected.minorHygiene === !!lane.minorHygiene));
+	const validatedLaneFindings = retainedLaneFindings(lanes, expectedLaneDescriptors);
 	if (input.strictJsonReview) {
 		// Strict JSON carries no assistant disclosure line; host lane evidence is
 		// the only completeness authority whenever a batch ran.
@@ -715,7 +790,10 @@ export function synthesizeReviewArtifact(input: {
 		);
 		const safe = publicationSafeStrictReview(input.strictJsonReview);
 		const bodyFallback = !safe || completeness === "incomplete";
-		const strictFindings = safe ? (input.strictJsonReview.findings ?? []) : [];
+		const strictFindings = mergeUniqueFindings(
+			safe ? (input.strictJsonReview.findings ?? []) : [],
+			bodyFallback ? validatedLaneFindings : [],
+		);
 		const body = bodyFallback
 			? buildDegradedReviewBody({
 				rawText: input.rawText,
@@ -761,7 +839,7 @@ export function synthesizeReviewArtifact(input: {
 		const body = buildDegradedReviewBody({
 			rawText: "",
 			lanes,
-			findings: [],
+			findings: validatedLaneFindings,
 			expectedLaneCount,
 			exactCoverage: exactLaneCoverage,
 			reason: "terminal synthesis was absent",
@@ -770,13 +848,18 @@ export function synthesizeReviewArtifact(input: {
 			quality: "lane_fallback" as const,
 			rawText: input.rawText,
 			body,
-			review: syntheticReview(input.prNumber, input.prTitle, input.headSha, body),
+			review: syntheticReview(input.prNumber, input.prTitle, input.headSha, body, validatedLaneFindings),
 			laneArtifacts: lanes,
 			expectedLaneDescriptors,
 			expectedLaneCount,
 			completeness,
 			mergeApprovalEligible: false,
-			diagnostics: Object.freeze(["terminal synthesis was absent; body assembled deterministically from retained lanes"]),
+			diagnostics: Object.freeze([
+				"terminal synthesis was absent; body assembled deterministically from retained lanes",
+				...(validatedLaneFindings.length > 0
+					? [`recovered ${validatedLaneFindings.length} complete contract-valid finding(s) from retained lane output`]
+					: []),
+			]),
 		});
 	}
 	const parsed = parseFindings(raw);
@@ -814,7 +897,9 @@ export function synthesizeReviewArtifact(input: {
 		: hasStructure && canonicalParsed.complete && completeness === "complete"
 			? "fully_parsed"
 			: canonicalParsed.findings.length > 0 ? "partially_parsed" : "raw";
-	const safeFindings = canonicalParsed.unsafe ? [] : canonicalParsed.findings;
+	const parsedSynthesisFindings = canonicalParsed.unsafe ? [] : canonicalParsed.findings;
+	const recoveredLaneFindings = quality === "fully_parsed" ? [] : validatedLaneFindings;
+	const safeFindings = mergeUniqueFindings(parsedSynthesisFindings, recoveredLaneFindings);
 	const degradationReasons = (() => {
 		if (canonicalParsed.unsafe) {
 			return ["unsafe Markdown fields were preserved in the sanitized body and inline extraction was disabled"];
@@ -841,6 +926,9 @@ export function synthesizeReviewArtifact(input: {
 		if (parsed.count > parsed.findings.length) {
 			reasons.push(`${parsed.count - parsed.findings.length} finding section(s) could not be parsed and remain in the body`);
 		}
+		if (recoveredLaneFindings.length > 0) {
+			reasons.push(`recovered ${recoveredLaneFindings.length} complete contract-valid finding(s) from retained lane output`);
+		}
 		return reasons.length > 0 ? reasons : ["terminal synthesis was not structurally parseable; preserved as body-only Markdown"];
 	})();
 	// Markdown is the durable semantic product. Keep the complete deterministic

package/lib/pr-review-publish.ts

@@ -349,7 +349,7 @@ export function parseDirectPublishRequest(input: string): DirectPublishRequestPa
 	const trimmed = input.trim();
 	if (!trimmed || /[\r\n]/.test(trimmed)) return { matched: false };
 	const match = trimmed.match(
-		/^(?:(?:please|kindly)\s+|(?:(?:can|could|would|will)\s+you\s+))?(?:post|publish|submit)\s+(?:(?:(?:the|this|that|these|those|my|our)\s+)?(?:(?:cached|completed|current|latest|inline|github|pr|pull[\s-]?request|review)\s+)*(?:reviews?|comments|(?:inline|review)\s+comment)|(?:it|this|that)\s+as\s+(?:(?:an?|the)\s+)?(?:(?:cached|completed|current|latest|inline|github|pr|pull[\s-]?request|review)\s+)*(?:reviews?|comments|(?:inline|review)\s+comment))(?:\s+(?:for|on|to)\s+(?:(?:the\s+)?(?:pull\s+request|pr)\s*)?#?(\d+))?(?:\s+please)?[.!?]*$/i,
+		/^(?:(?:please|kindly)\s+|(?:(?:can|could|would|will)\s+you\s+))?(?:(?:manually|manualy|manuall)\s+)?(?:post|publish|submit)\s+(?:(?:(?:the|this|that|these|those|my|our)\s+)?(?:(?:cached|completed|current|latest|inline|github|pr|pull[\s-]?request|review)\s+)*(?:reviews?|comments|(?:inline|review)\s+comment)|(?:it|this|that)\s+as\s+(?:(?:an?|the)\s+)?(?:(?:cached|completed|current|latest|inline|github|pr|pull[\s-]?request|review)\s+)*(?:reviews?|comments|(?:inline|review)\s+comment))(?:\s+(?:for|on|to)\s+(?:(?:the\s+)?(?:pull\s+request|pr)\s*)?#?(\d+))?(?:\s+(?:manually|manualy|manuall))?(?:\s+please)?[.!?]*$/i,
 	);
 	if (!match) return { matched: false };
 	if (match[1] === undefined) return { matched: true };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-pr-review",
-  "version": "1.17.4",
+  "version": "1.17.6",
   "description": "Parallel AI code review for GitHub pull requests in the Pi coding agent, with model-agnostic tiered subagents, structured findings, optional verification, and host-gated COMMENT or qualified APPROVE publishing.",
   "keywords": [
     "pi-package",