pi-pr-review 1.12.2 → 1.12.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.12.3](https://github.com/10ego/pi-pr-review/compare/v1.12.2...v1.12.3) (2026-08-19)
+
+
+### Bug Fixes
+
+* **review:** make host lane truth authoritative for completeness ([#67](https://github.com/10ego/pi-pr-review/issues/67)) ([ad70fc3](https://github.com/10ego/pi-pr-review/commit/ad70fc3b6376f215bf045b980fef06bd87036bd1))
+
 ## [1.12.2](https://github.com/10ego/pi-pr-review/compare/v1.12.1...v1.12.2) (2026-08-19)
 
 

package/README.md

@@ -176,7 +176,7 @@ Every invocation has a host-owned monotonic 15-minute hard cap, including the tw
 
 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 lens/shard, and remain eligible for the safe 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.
+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 lens/shard, and remain eligible for the safe 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.
 
 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 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.
 
@@ -212,7 +212,7 @@ Review semantics are Markdown-first. A deterministic tolerant parser normalizes
 
 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.
 
-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 and a standalone visible `All requested lanes completed.` disclosure (matched case-insensitively, with an optional final period) may emit a gated `APPROVE` through the same host binding, priority, lifecycle, self-author, and stale checks as strict JSON. Verdict fields outside the document preamble, hidden in CommonMark code/HTML blocks, or inside lazy container continuations, severity-tagged headings outside `Findings`, partial or contradictory lane disclosures, malformed or unsafe output, and lane-fallback artifacts remain body-only `COMMENT` reviews. 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 remains retained internally; if the concise body plus its canonical marker exceeds GitHub's limit, the host uses its sanitized, size-bounded Markdown projection instead of dropping the review. Stale or authorized non-open reviews are body-only. A stale approval additionally requires `allowStaleApprovals: true`.
+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 body-only `COMMENT` reviews. 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 remains retained internally; if the concise body plus its canonical marker exceeds GitHub's limit, the host uses its sanitized, size-bounded Markdown projection instead of dropping the review. Stale or authorized non-open reviews are body-only. A stale approval additionally requires `allowStaleApprovals: true`.
 
 All publication paths apply host-enforced safety gates: captured posting authority, repository and requested-PR binding, reviewed/current-head and stale policy, bounded bodies and payloads, draft and lifecycle checks, non-open authorization, authenticated-identity same-head duplicate detection, and a final head check. Fully or partially parsed review paths additionally enforce safe inline locations. Raw and lane-assembled fallbacks are body-only and `COMMENT`-only; assistant text cannot select event, commit, repository, hostname, API path, or inline anchors. Unknown or invalid host states fail closed before a write.
 

package/lib/pr-review-markdown.ts

@@ -654,16 +654,37 @@ export function synthesizeReviewArtifact(input: {
 	const verification = section(raw, "Verification");
 	const laneDisclosure = section(raw, "Lane completeness");
 	const laneDisclosureClaimsComplete = /^all requested lanes completed\.?$/i.test(laneDisclosure?.trim() ?? "");
+	const exactLaneCoverage = expectedLaneCount > 0 && lanes.length === expectedLaneCount &&
+		new Set(lanes.map((lane) => lane.key)).size === expectedLaneCount &&
+		new Set(expectedLaneDescriptors.map((lane) => lane.key)).size === expectedLaneCount &&
+		lanes.every((lane) => expectedLaneDescriptors.some((expected) =>
+			expected.key === lane.key && expected.tier === lane.tier &&
+			expected.minorHygiene === !!lane.minorHygiene));
+	// Host lane artifacts are authoritative whenever a batch ran: they already
+	// stop a false complete claim from upgrading incomplete lanes, and they must
+	// equally stop a paraphrased or omitted disclosure line from downgrading a
+	// host-complete batch to body-only publication. Completeness additionally
+	// requires the retained lanes to cover every expected dispatch, so an
+	// expected-but-unretained artifact cannot make an incomplete batch look
+	// complete through vacuous satisfaction.
+	const batchEvidencePresent = lanes.length > 0 || expectedLaneCount > 0;
+	const laneTruthClaimsComplete = batchEvidencePresent
+		? lanes.every((lane) => lane.lifecycle === "complete") &&
+			(expectedLaneCount === 0 || exactLaneCoverage)
+		: laneDisclosureClaimsComplete;
 	const preamble = documentPreamble(raw);
 	const verdictField = field(preamble, "Verdict");
 	const verdict = verdictField?.toLowerCase().replace(/[ -]+/g, "_");
-	const extractedControlsSafe = publicationSafeText(overview) && publicationSafeText(verification) &&
-		publicationSafeText(laneDisclosure) && publicationSafeText(verdictField) &&
+	// A missing section is a structural gap handled by hasStructure and
+	// diagnostics; only present-but-unsafe text disables inline extraction.
+	const safeIfPresent = (value: string | undefined) => value === undefined || publicationSafeText(value);
+	const extractedControlsSafe = safeIfPresent(overview) && safeIfPresent(verification) &&
+		safeIfPresent(laneDisclosure) && safeIfPresent(verdictField) &&
 		new Set(["approve", "request_changes", "comment"]).has(verdict ?? "") &&
 		fieldCount(preamble, "Verdict") === 1 && fieldCount(raw, "Verdict") === 1;
 	const canonicalParsed = parsed.unsafe ? parsed : { ...parsed, unsafe: !extractedControlsSafe };
-	const completeness = synthesisCompleteness(raw, lanes, laneDisclosureClaimsComplete);
-	const hasStructure = !!overview && !!verification && laneDisclosureClaimsComplete && extractedControlsSafe;
+	const completeness = synthesisCompleteness(raw, lanes, laneTruthClaimsComplete);
+	const hasStructure = !!overview && !!verification && laneTruthClaimsComplete && extractedControlsSafe;
 	const quality: ReviewSynthesisQuality = canonicalParsed.unsafe
 		? "raw"
 		: hasStructure && canonicalParsed.complete && completeness === "complete"
@@ -675,12 +696,6 @@ export function synthesizeReviewArtifact(input: {
 	const bodySource = quality === "fully_parsed" ? raw : synthesisWithRetainedLaneEvidence(raw, lanes);
 	const body = safeReviewBodyWithLaneDisclosure(bodySource, lanes);
 	const safeFindings = canonicalParsed.unsafe ? [] : canonicalParsed.findings;
-	const exactLaneCoverage = expectedLaneCount > 0 && lanes.length === expectedLaneCount &&
-		new Set(lanes.map((lane) => lane.key)).size === expectedLaneCount &&
-		new Set(expectedLaneDescriptors.map((lane) => lane.key)).size === expectedLaneCount &&
-		lanes.every((lane) => expectedLaneDescriptors.some((expected) =>
-			expected.key === lane.key && expected.tier === lane.tier &&
-			expected.minorHygiene === !!lane.minorHygiene));
 	return Object.freeze({
 		quality,
 		rawText: input.rawText,
@@ -701,12 +716,33 @@ export function synthesizeReviewArtifact(input: {
 		// Markdown approval requires exact host evidence for every registered
 		// dispatch; a nonempty subset cannot establish requested coverage.
 		mergeApprovalEligible: quality === "fully_parsed" && completeness === "complete" && exactLaneCoverage,
-		diagnostics: Object.freeze(canonicalParsed.unsafe
-			? ["unsafe Markdown fields were preserved in the sanitized body and inline extraction was disabled"]
-			: quality === "partially_parsed"
-				? [completeness === "incomplete"
-					? "incomplete lane disclosure or evidence forced sanitized body-only publication"
-					: `${parsed.count - parsed.findings.length} finding section(s) could not be parsed and remain in the body`]
-				: quality === "raw" ? ["terminal synthesis was not structurally parseable; preserved as body-only Markdown"] : []),
+		diagnostics: Object.freeze((() => {
+			if (canonicalParsed.unsafe) {
+				return ["unsafe Markdown fields were preserved in the sanitized body and inline extraction was disabled"];
+			}
+			if (quality === "fully_parsed") return [];
+			const reasons: string[] = [];
+			if (!overview) reasons.push("Overview section missing or empty");
+			if (!verification) reasons.push("Verification section missing or empty");
+			if (!laneTruthClaimsComplete) {
+				if (lanes.length > 0 && !lanes.every((lane) => lane.lifecycle === "complete")) {
+					reasons.push("host lane evidence contains incomplete lanes");
+				} else if (expectedLaneCount > 0 && !exactLaneCoverage) {
+					reasons.push("retained lane evidence does not cover every expected lane dispatch");
+				} else {
+					reasons.push("Lane completeness section absent or did not state the canonical completion line");
+				}
+			}
+			if (verdictField !== undefined && !new Set(["approve", "request_changes", "comment"]).has(verdict ?? "")) {
+				reasons.push("Verdict field outside the canonical set");
+			}
+			if (fieldCount(preamble, "Verdict") !== 1 || fieldCount(raw, "Verdict") !== 1) {
+				reasons.push("Verdict field count is not exactly one");
+			}
+			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`);
+			}
+			return reasons.length > 0 ? reasons : ["terminal synthesis was not structurally parseable; preserved as body-only Markdown"];
+		})()),
 	});
 }

package/package.json

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

package/prompts/pr-review.md

@@ -196,7 +196,7 @@ The orchestrator must never call `gh` to post comments or reviews. Always finish
 
 After host synthesis, the extension caches one validated completed review as a canonical host-owned 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. `/pr-review-publish` and a matching direct request publish only the cache and never start or rerun review agents. On a later turn, the extension intercepts that direct input before an agent turn and permits stale publication without asking the orchestrator to recreate the review.
 
-Every authorized publish path builds one GitHub review payload and sends at most one review `POST`; the extension never submits `REQUEST_CHANGES`. Fully parsed Markdown with one complete retained artifact for every host-registered dispatch, a standalone visible `All requested lanes completed.` disclosure (matched case-insensitively, with an optional final period), and retained strict host-bound JSON share the same gated `APPROVE` path. Verdict fields outside the document preamble, hidden in CommonMark code/HTML blocks, or inside lazy container continuations, severity-tagged headings outside `Findings`, contradictory lane disclosures, and partial, malformed, unsafe, or lane-fallback Markdown remain body-only `COMMENT`. Restored cache entries must reclassify retained lane output, reproduce the exact host-recorded artifact key set, and bind every complete artifact to the frozen invocation generation, tier, and minor-hygiene contract and re-synthesize the retained raw text under that frozen binding before preserving approval eligibility. For a current, open PR, the first 50 eligible P0–P3 findings with valid, unique diff anchors are inline. The public body contains the verdict, an inline-review cue when applicable, and `Other Notes` for nits and every finding that cannot be inline; overview, verification, strengths, and transport diagnostics remain only in the retained internal artifact. If that concise body plus its canonical marker exceeds GitHub's limit, the host publishes the sanitized, size-bounded original Markdown projection instead of dropping the review. Stale reviews and authorized closed or merged reviews are body-only. A stale review may record a qualified `APPROVE` only with the separate trusted `allowStaleApprovals: true` opt-in captured before review execution. A failed write never triggers a fallback POST.
+Every authorized publish path builds one GitHub review payload and sends at most one review `POST`; the extension never submits `REQUEST_CHANGES`. Fully parsed Markdown with one complete retained artifact for every host-registered dispatch and retained strict host-bound JSON share the same gated `APPROVE` path. 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, and partial, malformed, unsafe, or lane-fallback Markdown remain body-only `COMMENT`. Restored cache entries must reclassify retained lane output, reproduce the exact host-recorded artifact key set, and bind every complete artifact to the frozen invocation generation, tier, and minor-hygiene contract and re-synthesize the retained raw text under that frozen binding before preserving approval eligibility. For a current, open PR, the first 50 eligible P0–P3 findings with valid, unique diff anchors are inline. The public body contains the verdict, an inline-review cue when applicable, and `Other Notes` for nits and every finding that cannot be inline; overview, verification, strengths, and transport diagnostics remain only in the retained internal artifact. If that concise body plus its canonical marker exceeds GitHub's limit, the host publishes the sanitized, size-bounded original Markdown projection instead of dropping the review. Stale reviews and authorized closed or merged reviews are body-only. A stale review may record a qualified `APPROVE` only with the separate trusted `allowStaleApprovals: true` opt-in captured before review execution. A failed write never triggers a fallback POST.
 
 Every path retains the same safety gates: captured posting authority, exact repository/PR/review binding, safe locations, no reserved review markers, bounded bodies and payloads, current-head and stale policy, draft and lifecycle checks, non-open authorization, same-head duplicate detection, and a final head check. Unknown lifecycle states and unconfirmed non-open writes fail closed. The session-backed cache survives extension reloads and session resumes but remains bound to the originating session instance and repository. If the captured stale setting disabled publication, the user may explicitly 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.