pi-pr-review 1.10.6 → 1.11.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.11.0](https://github.com/10ego/pi-pr-review/compare/v1.10.7...v1.11.0) (2026-07-17)
+
+
+### Features
+
+* submit APPROVE review event with configurable priority gate ([#35](https://github.com/10ego/pi-pr-review/issues/35)) ([ec47045](https://github.com/10ego/pi-pr-review/commit/ec47045245541c9182ac7e1b120765bbc5e77696))
+
+## [1.10.7](https://github.com/10ego/pi-pr-review/compare/v1.10.6...v1.10.7) (2026-07-17)
+
+
+### Bug Fixes
+
+* **publish:** auto-heal a Markdown-fenced review JSON object ([#37](https://github.com/10ego/pi-pr-review/issues/37)) ([9ecdd05](https://github.com/10ego/pi-pr-review/commit/9ecdd05e8f00b56176c52f5ca50fcf55698bd2b8))
+
 ## [1.10.6](https://github.com/10ego/pi-pr-review/compare/v1.10.5...v1.10.6) (2026-07-17)
 
 

package/README.md

@@ -8,7 +8,7 @@ Give it a PR number and it will:
 - run focused review passes in parallel using models you choose;
 - validate candidate findings before reporting them;
 - render a structured review with severity, location, confidence, and verdict;
-- optionally publish one safe GitHub `COMMENT` review with inline comments.
+- optionally publish one safe GitHub review with inline comments (`COMMENT` by default; gated `APPROVE` when configured).
 
 The default review prioritizes P0–P2 defects and allows up to three minor findings. Use `--full` for exhaustive convention, maintainability, and minor coverage.
 
@@ -114,6 +114,8 @@ Common settings:
 /pr-review-config tools=read,bash,grep,find,ls
 /pr-review-config auto_post_reviews=true
 /pr-review-config allow_stale_publish=false
+/pr-review-config allow_stale_approvals=true
+/pr-review-config approve_max_priority_level=P2
 /pr-review-config medium=unset
 ```
 
@@ -152,7 +154,9 @@ Example:
   },
   "tools": ["read", "bash", "grep", "find", "ls"],
   "autoPostReviews": false,
-  "allowStalePublish": true
+  "allowStalePublish": true,
+  "allowStaleApprovals": false,
+  "approveMaxPriorityLevel": "off"
 }
 ```
 
@@ -188,7 +192,7 @@ If the agent's final review is not valid exact-contract JSON, the extension logs
 
 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 `COMMENT` payload and sends at most one GitHub review `POST`; it never submits `APPROVE` or `REQUEST_CHANGES` and never retries a rejected write with a fallback POST. For a current, open PR, the first 50 eligible P0–P3 findings with valid, unique diff anchors are inline. All other findings that pass content validation stay in the top-level review body, including nits, off-diff findings, unavailable diff metadata, duplicate anchors, and overflow. Stale or authorized non-open reviews are body-only.
+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. It emits `COMMENT` by default, or a gated `APPROVE` when configured below. For a current, open PR, the first 50 eligible P0–P3 findings with valid, unique diff anchors are inline. All other findings that pass content validation stay in the top-level review body, including nits, off-diff findings, unavailable diff metadata, duplicate anchors, and overflow. Stale or authorized non-open reviews are body-only. A stale review additionally requires `allowStaleApprovals: true` before it may record `APPROVE`.
 
 The same safety gates apply to every path: 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 or invalid states fail closed before a write.
 
@@ -198,7 +202,7 @@ Stale publication is enabled by default through `allowStalePublish: true`; disab
 /pr-review-publish 123 --allow-stale
 ```
 
-A matching direct request permits stale publication. Inline comments are always disabled for stale reviews because the original anchors may no longer be valid; the body identifies both the reviewed and current commit. The session-backed cache survives extension reloads and session resumes and remains bound to the originating session instance and repository.
+A matching direct request permits stale publication. Inline comments are always disabled for stale reviews because the original anchors may no longer be valid; the body identifies both the reviewed and current commit. A stale publication remains `COMMENT` by default even when `approveMaxPriorityLevel` qualifies it; set trusted `allowStaleApprovals: true` before starting the review to permit its eligible `APPROVE`. Authorized non-open publications may record `APPROVE` when the priority gate qualifies the review. The session-backed cache survives extension reloads and session resumes and remains bound to the originating session instance and repository.
 
 ## Optional verification
 
@@ -247,7 +251,16 @@ Each finding includes:
 | `P3` | Low-priority improvement. |
 | `nit` | Trivial or optional. |
 
-The verdict is `request_changes` only when a validated P0 or P1 finding exists. Otherwise it is `approve` or `comment`. The displayed verdict is advisory even when the review is published, because publication always uses the GitHub `COMMENT` event.
+The verdict is `request_changes` only when a validated P0 or P1 finding exists. Otherwise it is `approve` or `comment`. By default, publication uses the GitHub `COMMENT` event. When `approveMaxPriorityLevel` is set to `P2`, `P3`, or `nit`, a review whose verdict is `approve` and whose findings are all at or below that level is published as a GitHub `APPROVE` event instead. A stale publication additionally requires `allowStaleApprovals: true`; authorized non-open publications do not.
+
+| Setting | Behavior |
+|---|---|
+| `off` (default) | Always `COMMENT`; never auto-approve. |
+| `P2` | `APPROVE` if verdict is `approve` and all findings are P2/P3/nit. |
+| `P3` | `APPROVE` if verdict is `approve` and all findings are P3/nit. |
+| `nit` | `APPROVE` only if verdict is `approve` and all findings are nits. |
+
+Configure it with `/pr-review-config approve_max_priority_level=P2`. To permit an eligible stale review to approve, also set `/pr-review-config allow_stale_approvals=true` before starting the review. Both settings follow the same user/project overlay pattern as `autoPostReviews`.
 
 ## Safety and cost
 

package/extensions/pr-review-subagent.ts

@@ -75,8 +75,11 @@ import {
 	type ToolPolicy,
 } from "../lib/pr-review-policy.ts";
 import {
+	resolveAllowStaleApprovalsSetting,
 	resolveAllowStalePublishSetting,
 	resolveAutoPostSetting,
+	resolveApproveMaxPriorityLevelSetting,
+	type ApproveMaxPriorityLevel,
 } from "../lib/pr-review-publish.ts";
 import { monotonicNow } from "../lib/pr-review-telemetry.ts";
 import {
@@ -131,6 +134,10 @@ interface PrReviewConfig {
 	autoPostReviews: boolean;
 	/** Permit stale publication as body-only with reviewed/current SHAs disclosed. Enabled by default. */
 	allowStalePublish: boolean;
+	/** Permit otherwise-qualified stale reviews to record APPROVE. Disabled by default. */
+	allowStaleApprovals: boolean;
+	/** Maximum severity finding that permits an APPROVE event (off disables auto-approve). */
+	approveMaxPriorityLevel: ApproveMaxPriorityLevel;
 	/** Trusted user-level named verification profiles. Project config never overlays these. */
 	verificationBaselines: VerificationBaselines;
 	/** Tools granted to review subagents whose effective policy is configured. */
@@ -218,6 +225,28 @@ function resolveAllowStaleForContext(ctx: Pick<ExtensionContext, "cwd" | "isProj
 	return resolveAllowStalePublishSetting(user, project);
 }
 
+function resolveAllowStaleApprovalsForContext(ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted">) {
+	const user = readConfigFile(userConfigPath());
+	let project: Partial<PrReviewConfig> | undefined;
+	try {
+		if (ctx.isProjectTrusted()) project = readConfigFile(projectConfigPath(ctx.cwd));
+	} catch {
+		/* user config only */
+	}
+	return resolveAllowStaleApprovalsSetting(user, project);
+}
+
+function resolveApproveMaxPriorityForContext(ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted">) {
+	const user = readConfigFile(userConfigPath());
+	let project: Partial<PrReviewConfig> | undefined;
+	try {
+		if (ctx.isProjectTrusted()) project = readConfigFile(projectConfigPath(ctx.cwd));
+	} catch {
+		/* user config only */
+	}
+	return resolveApproveMaxPriorityLevelSetting(user, project);
+}
+
 /** User config overlaid by a trusted project, except user-only verification profiles. */
 function loadConfig(ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted">): PrReviewConfig {
 	const user = readConfigFile(userConfigPath());
@@ -229,6 +258,8 @@ function loadConfig(ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted">): Pr
 	}
 	const autoPost = resolveAutoPostSetting(user, project);
 	const allowStale = resolveAllowStalePublishSetting(user, project);
+	const allowStaleApprovals = resolveAllowStaleApprovalsSetting(user, project);
+	const approveMaxPriority = resolveApproveMaxPriorityLevelSetting(user, project);
 	return {
 		tiers: { ...(user.tiers ?? {}), ...(project.tiers ?? {}) },
 		fallbacks: { ...normalizeFallbacks(user.fallbacks, true), ...normalizeFallbacks(project.fallbacks, true) },
@@ -242,6 +273,8 @@ function loadConfig(ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted">): Pr
 		},
 		autoPostReviews: autoPost.valid ? autoPost.value : false,
 		allowStalePublish: allowStale.valid ? allowStale.value : false,
+		allowStaleApprovals: allowStaleApprovals.valid ? allowStaleApprovals.value : false,
+		approveMaxPriorityLevel: approveMaxPriority.valid ? approveMaxPriority.value : "off",
 		// Verification is intentionally user-owned. Never accept a profile from
 		// the repository-controlled project overlay, even for trusted projects.
 		verificationBaselines: resolveUserVerificationBaselines(user, project),
@@ -254,6 +287,8 @@ function readUserConfig(): PrReviewConfig {
 	const raw = readConfigFile(userConfigPath());
 	const autoPost = resolveAutoPostSetting(raw);
 	const allowStale = resolveAllowStalePublishSetting(raw);
+	const allowStaleApprovals = resolveAllowStaleApprovalsSetting(raw);
+	const approveMaxPriority = resolveApproveMaxPriorityLevelSetting(raw);
 	return {
 		tiers: { ...(raw.tiers ?? {}) },
 		fallbacks: normalizeFallbacks(raw.fallbacks),
@@ -261,6 +296,8 @@ function readUserConfig(): PrReviewConfig {
 		toolPolicies: normalizeToolPolicies(raw.toolPolicies),
 		autoPostReviews: autoPost.valid ? autoPost.value : false,
 		allowStalePublish: allowStale.valid ? allowStale.value : false,
+		allowStaleApprovals: allowStaleApprovals.valid ? allowStaleApprovals.value : false,
+		approveMaxPriorityLevel: approveMaxPriority.valid ? approveMaxPriority.value : "off",
 		verificationBaselines: resolveUserVerificationBaselines(raw),
 		tools: raw.tools ?? [...DEFAULT_TOOLS],
 	};
@@ -1682,6 +1719,8 @@ interface ConfigPatch {
 	toolPolicies: Partial<Record<Tier, ToolPolicy | null>>;
 	autoPostReviews?: boolean;
 	allowStalePublish?: boolean;
+	allowStaleApprovals?: boolean;
+	approveMaxPriorityLevel?: ApproveMaxPriorityLevel;
 	tools?: string[];
 }
 
@@ -1726,11 +1765,30 @@ function parseConfigArgs(args: string): { patch: ConfigPatch; hasChanges: boolea
 			if (value === "true") patch.allowStalePublish = true;
 			else if (value === "false") patch.allowStalePublish = false;
 			else errors.push(`invalid ${key} "${value}" (expected true|false)`);
+		} else if (key === "allow_stale_approvals" || key === "allowstaleapprovals" || key === "allow-stale-approvals") {
+			if (value === "true") patch.allowStaleApprovals = true;
+			else if (value === "false") patch.allowStaleApprovals = false;
+			else errors.push(`invalid ${key} "${value}" (expected true|false)`);
+		} else if (
+			key === "approve_max_priority_level" ||
+			key === "approvemaxprioritylevel" ||
+			key === "approve-max-priority-level"
+		) {
+			const normalized = value.toLowerCase();
+			if (normalized === "off") {
+				patch.approveMaxPriorityLevel = "off";
+			} else if (["p2", "p3"].includes(normalized)) {
+				patch.approveMaxPriorityLevel = normalized.toUpperCase() as ApproveMaxPriorityLevel;
+			} else if (normalized === "nit") {
+				patch.approveMaxPriorityLevel = "nit";
+			} else {
+				errors.push(`invalid ${key} "${value}" (expected off|P2|P3|nit)`);
+			}
 		} else if (key === "tools") {
 			patch.tools = splitCommaList(value);
 		} else {
 			errors.push(
-				`unknown key "${key}" (expected light|medium|heavy|<tier>_fallbacks|<tier>_thinking|<tier>_tool_policy|auto_post_reviews|allow_stale_publish|tools)`,
+				`unknown key "${key}" (expected light|medium|heavy|<tier>_fallbacks|<tier>_thinking|<tier>_tool_policy|auto_post_reviews|allow_stale_publish|allow_stale_approvals|approve_max_priority_level|tools)`,
 			);
 		}
 	}
@@ -1741,6 +1799,8 @@ function parseConfigArgs(args: string): { patch: ConfigPatch; hasChanges: boolea
 		Object.keys(patch.toolPolicies).length > 0 ||
 		patch.autoPostReviews !== undefined ||
 		patch.allowStalePublish !== undefined ||
+		patch.allowStaleApprovals !== undefined ||
+		patch.approveMaxPriorityLevel !== undefined ||
 		patch.tools !== undefined;
 	return { patch, hasChanges, errors };
 }
@@ -1753,6 +1813,8 @@ function applyConfigPatch(base: PrReviewConfig, patch: ConfigPatch): PrReviewCon
 		toolPolicies: normalizeToolPolicies(base.toolPolicies),
 		autoPostReviews: base.autoPostReviews,
 		allowStalePublish: base.allowStalePublish,
+		allowStaleApprovals: base.allowStaleApprovals,
+		approveMaxPriorityLevel: base.approveMaxPriorityLevel,
 		verificationBaselines: { ...base.verificationBaselines },
 		tools: [...base.tools],
 	};
@@ -1780,6 +1842,8 @@ function applyConfigPatch(base: PrReviewConfig, patch: ConfigPatch): PrReviewCon
 	}
 	if (patch.autoPostReviews !== undefined) next.autoPostReviews = patch.autoPostReviews;
 	if (patch.allowStalePublish !== undefined) next.allowStalePublish = patch.allowStalePublish;
+	if (patch.allowStaleApprovals !== undefined) next.allowStaleApprovals = patch.allowStaleApprovals;
+	if (patch.approveMaxPriorityLevel !== undefined) next.approveMaxPriorityLevel = patch.approveMaxPriorityLevel;
 	if (patch.tools) next.tools = patch.tools;
 	return next;
 }
@@ -1805,6 +1869,8 @@ function summarizeConfig(
 	}
 	const autoPost = resolveAutoPostForContext(ctx);
 	const allowStale = resolveAllowStaleForContext(ctx);
+	const allowStaleApprovals = resolveAllowStaleApprovalsForContext(ctx);
+	const approveMaxPriority = resolveApproveMaxPriorityForContext(ctx);
 	const lines = [
 		`# PR review config${changed ? " updated" : ""}`,
 		"",
@@ -1814,8 +1880,10 @@ function summarizeConfig(
 			(t) =>
 				`| \`${t}\` | ${user.tiers[t] ? `\`${user.tiers[t]}\`` : "_unset_"} | ${effective.tiers[t] ? `\`${effective.tiers[t]}\`` : "_pi default_"} | ${TIER_PURPOSE[t]} |`,
 		),
-		`| \`autoPostReviews\` | \`${user.autoPostReviews}\` | \`${effective.autoPostReviews}\` (${autoPost.source}) | automatically post one GitHub \`COMMENT\` review; default \`false\` |`,
+		`| \`autoPostReviews\` | \`${user.autoPostReviews}\` | \`${effective.autoPostReviews}\` (${autoPost.source}) | automatically post one GitHub review; default \`false\` |`,
 		`| \`allowStalePublish\` | \`${user.allowStalePublish}\` | \`${effective.allowStalePublish}\` (${allowStale.source}) | permit body-only stale publication with reviewed/current SHAs; default \`true\` |`,
+		`| \`allowStaleApprovals\` | \`${user.allowStaleApprovals}\` | \`${effective.allowStaleApprovals}\` (${allowStaleApprovals.source}) | permit qualified stale reviews to record APPROVE; default \`false\` |`,
+		`| \`approveMaxPriorityLevel\` | \`${user.approveMaxPriorityLevel}\` | \`${effective.approveMaxPriorityLevel}\` (${approveMaxPriority.source}) | max severity for auto-APPROVE; \`off\` posts COMMENT only; default \`off\` |`,
 		`| \`verificationBaselines\` | \`${Object.keys(user.verificationBaselines).length} configured\` | user scope only | strict named argv profiles; project overlays ignored |`,
 		`| \`tools\` | \`${user.tools.join(",")}\` | \`${effective.tools.join(",")}\` | allowlist used when policy is \`configured\` |`,
 		"",
@@ -1839,6 +1907,14 @@ function summarizeConfig(
 	else if (allowStale.source === "project") {
 		lines.push("Stale publication is controlled by the trusted project overlay; this command edits user config only.");
 	}
+	if (!allowStaleApprovals.valid) lines.push(`Stale approval config error: ${allowStaleApprovals.error}`);
+	else if (allowStaleApprovals.source === "project") {
+		lines.push("Stale approval is controlled by the trusted project overlay; this command edits user config only.");
+	}
+	if (!approveMaxPriority.valid) lines.push(`Auto-approve priority config error: ${approveMaxPriority.error}`);
+	else if (approveMaxPriority.source === "project") {
+		lines.push("Auto-approve priority is controlled by the trusted project overlay; this command edits user config only.");
+	}
 	lines.push(
 		"",
 		"## Usage",
@@ -1851,6 +1927,10 @@ function summarizeConfig(
 		"- Disable automatic GitHub review posting: `/pr-review-config auto_post_reviews=false`",
 		"- Disable stale publication: `/pr-review-config allow_stale_publish=false`",
 		"- Enable stale publication (default): `/pr-review-config allow_stale_publish=true`",
+		"- Permit qualified stale reviews to record APPROVE: `/pr-review-config allow_stale_approvals=true`",
+		"- Keep stale reviews as COMMENT (default): `/pr-review-config allow_stale_approvals=false`",
+		"- Enable auto-approve for low-severity reviews: `/pr-review-config approve_max_priority_level=P2`",
+		"- Disable auto-approve (default): `/pr-review-config approve_max_priority_level=off`",
 		"- Set tier tool policy: `/pr-review-config light_tool_policy=none`",
 		"- Clear a tier: `/pr-review-config medium=unset`",
 		"- Clear fallback chain: `/pr-review-config heavy_fallbacks=unset`",
@@ -1987,6 +2067,20 @@ function configMenuItems(cfg: PrReviewConfig, available: string[]): SettingItem[
 			currentValue: String(cfg.allowStalePublish),
 			values: ["true", "false"],
 		},
+		{
+			id: "allow_stale_approvals",
+			label: "stale approval setting",
+			description: "Permit otherwise-qualified stale reviews to record APPROVE. Disabled by default.",
+			currentValue: String(cfg.allowStaleApprovals),
+			values: ["false", "true"],
+		},
+		{
+			id: "approve_max_priority_level",
+			label: "auto-approve priority gate",
+			description: "Maximum severity that permits an APPROVE event (off = COMMENT only). Enter/Space cycles values.",
+			currentValue: String(cfg.approveMaxPriorityLevel),
+			values: ["off", "P2", "P3", "nit"],
+		},
 		{
 			id: "tools",
 			label: "configured tool allowlist",
@@ -2021,6 +2115,7 @@ async function showConfigMenu(
 				}
 				settingsList.updateValue("auto_post_reviews", String(draft.autoPostReviews));
 				settingsList.updateValue("allow_stale_publish", String(draft.allowStalePublish));
+				settingsList.updateValue("allow_stale_approvals", String(draft.allowStaleApprovals));
 				settingsList.updateValue("tools", draft.tools.join(","));
 			};
 
@@ -2054,6 +2149,17 @@ async function showConfigMenu(
 					draft.autoPostReviews = newValue === "true";
 				} else if (id === "allow_stale_publish") {
 					draft.allowStalePublish = newValue === "true";
+				} else if (id === "allow_stale_approvals") {
+					draft.allowStaleApprovals = newValue === "true";
+				} else if (id === "approve_max_priority_level") {
+					const normalized = newValue.toLowerCase();
+					if (normalized === "off") {
+						draft.approveMaxPriorityLevel = "off";
+					} else if (["p2", "p3"].includes(normalized)) {
+						draft.approveMaxPriorityLevel = normalized.toUpperCase() as ApproveMaxPriorityLevel;
+					} else if (normalized === "nit") {
+						draft.approveMaxPriorityLevel = "nit";
+					}
 				} else if (id === "tools") {
 					draft.tools = splitCommaList(newValue);
 				} else {
@@ -2068,7 +2174,11 @@ async function showConfigMenu(
 							? String(draft.autoPostReviews)
 							: id === "allow_stale_publish"
 								? String(draft.allowStalePublish)
-								: isFallbackKey(id)
+								: id === "allow_stale_approvals"
+									? String(draft.allowStaleApprovals)
+									: id === "approve_max_priority_level"
+									? String(draft.approveMaxPriorityLevel)
+									: isFallbackKey(id)
 								? (draft.fallbacks[tierFromCompoundKey(id)]?.join(",") ?? "(none)")
 								: isThinkingKey(id)
 									? (draft.thinkingLevels[tierFromCompoundKey(id)] ?? INHERIT_THINKING)
@@ -2095,6 +2205,26 @@ async function showConfigMenu(
 						} else {
 							ctx.ui.notify(`PR review config: ${id} = ${shown} (effective ${effective.value})`, "info");
 						}
+					} else if (id === "allow_stale_approvals") {
+						const effective = resolveAllowStaleApprovalsForContext(ctx);
+						if (effective.source === "project") {
+							ctx.ui.notify(
+								`User allowStaleApprovals saved as ${shown}, but trusted project config remains effective at ${effective.value}. Edit ${projectConfigPath(ctx.cwd)}.`,
+								"warning",
+							);
+						} else {
+							ctx.ui.notify(`PR review config: ${id} = ${shown} (effective ${effective.value})`, "info");
+						}
+					} else if (id === "approve_max_priority_level") {
+						const effective = resolveApproveMaxPriorityForContext(ctx);
+						if (effective.source === "project") {
+							ctx.ui.notify(
+								`User approveMaxPriorityLevel saved as ${shown}, but trusted project config remains effective at ${effective.value}. Edit ${projectConfigPath(ctx.cwd)}.`,
+								"warning",
+							);
+						} else {
+							ctx.ui.notify(`PR review config: ${id} = ${shown} (effective ${effective.value})`, "info");
+						}
 					} else {
 						ctx.ui.notify(`PR review config: ${id} = ${shown}`, "info");
 					}

package/extensions/review-table.ts

@@ -30,13 +30,16 @@ import {
 	parsePublishMode,
 	parsePublishableReview,
 	publishPullReview,
+	resolveAllowStaleApprovalsSetting,
 	resolveAllowStalePublishSetting,
 	resolveAutoPostSetting,
+	resolveApproveMaxPriorityLevelSetting,
 	resolveRepositoryBinding,
 	restoreCompletedReviewBranch,
 	shouldPublishReview,
 	validateReviewInvocation,
 	type AutoPostResolution,
+	type ApproveMaxPriorityLevelResolution,
 	type CompletedReviewRecord,
 	type CompletedReviewSessionIdentity,
 	type ReviewInvocation,
@@ -336,11 +339,14 @@ function readJsonObject(filePath: string): ConfigReadResult {
 interface PublishingConfigResolution {
 	autoPost: AutoPostResolution;
 	allowStale: AutoPostResolution;
+	allowStaleApprovals: AutoPostResolution;
+	approveMaxPriority: ApproveMaxPriorityLevelResolution;
 }
 
 function invalidPublishingConfig(source: "user" | "project", error: string): PublishingConfigResolution {
 	const invalid = { value: false, valid: false, source, error } as const;
-	return { autoPost: invalid, allowStale: invalid };
+	const invalidLevel = { value: "off" as const, valid: false, source, error } as const;
+	return { autoPost: invalid, allowStale: invalid, allowStaleApprovals: invalid, approveMaxPriority: invalidLevel };
 }
 
 function resolvePublishingConfig(ctx: ExtensionContext): PublishingConfigResolution {
@@ -358,6 +364,8 @@ function resolvePublishingConfig(ctx: ExtensionContext): PublishingConfigResolut
 	return {
 		autoPost: resolveAutoPostSetting(user.value, project?.value),
 		allowStale: resolveAllowStalePublishSetting(user.value, project?.value),
+		allowStaleApprovals: resolveAllowStaleApprovalsSetting(user.value, project?.value),
+		approveMaxPriority: resolveApproveMaxPriorityLevelSetting(user.value, project?.value),
 	};
 }
 
@@ -367,7 +375,8 @@ function notifyPublishResult(
 	ctx: ExtensionContext,
 ): void {
 	if (result.status === "posted") {
-		ctx.ui.notify(`PR review posted as COMMENT (${source})${result.url ? `: ${result.url}` : ""}`, "info");
+		const label = result.event === "APPROVE" ? "APPROVE" : "COMMENT";
+		ctx.ui.notify(`PR review posted as ${label} (${source})${result.url ? `: ${result.url}` : ""}`, "info");
 	} else if (result.status === "posted_degraded") {
 		ctx.ui.notify(`PR review posted (${source}): ${result.message}${result.url ? ` ${result.url}` : ""}`, "warning");
 	} else if (result.status === "skipped_duplicate") {
@@ -415,6 +424,8 @@ async function publishCompletedReview(
 		headSha,
 		allowNonOpen: record.invocation.allowNonOpen,
 		allowStale,
+		allowStaleApprovals: record.invocation.allowStaleApprovals,
+		approveMaxPriorityLevel: record.invocation.approveMaxPriorityLevel,
 		expectedRepository: record.repository,
 		review: record.review,
 	});
@@ -674,6 +685,8 @@ export default function registerReviewTable(
 			source,
 			ctx,
 			publishingConfig.allowStale.valid && publishingConfig.allowStale.value,
+			publishingConfig.allowStaleApprovals.valid && publishingConfig.allowStaleApprovals.value,
+			publishingConfig.approveMaxPriority.valid ? publishingConfig.approveMaxPriority.value : "off",
 		);
 		if (!gate.accepted) {
 			ctx.ui.notify(`Invalid /pr-review invocation: ${gate.error}`, "error");

package/lib/pr-review-loop.ts

@@ -2,6 +2,7 @@ import * as path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
 	ReviewInvocationGate,
+	type ApproveMaxPriorityLevel,
 	type AutoPostResolution,
 	type PublishModeParseResult,
 	type ReviewInvocation,
@@ -103,11 +104,19 @@ export class ReviewLoopCoordinator {
 		source: ReviewLoopInputSource,
 		ctx: Pick<ExtensionContext, "cwd" | "sessionManager">,
 		allowStalePublish = true,
+		allowStaleApprovals = false,
+		approveMaxPriorityLevel: ApproveMaxPriorityLevel = "off",
 	): { accepted: boolean; error?: string } {
 		if (source !== "interactive" && source !== "rpc") {
 			return { accepted: false, error: "/pr-review must be initiated directly by an interactive or RPC user" };
 		}
-		const started = this.invocationGate.begin(parsed, autoPost, allowStalePublish);
+		const started = this.invocationGate.begin(
+			parsed,
+			autoPost,
+			allowStalePublish,
+			allowStaleApprovals,
+			approveMaxPriorityLevel,
+		);
 		if (!started.accepted) return started;
 		const current = sessionBinding(ctx);
 		this.binding = {

package/lib/pr-review-publish.ts

@@ -6,6 +6,88 @@ export type PublishMode = "auto" | "force" | "disabled";
 export type AutoPostSource = "default" | "user" | "project";
 export type CompletionAction = "continue_tools" | "accept_final" | "clear_invocation";
 
+/** Maximum severity that may appear in a review for auto-APPROVE to be granted. */
+export type ApproveMaxPriorityLevel = "off" | "P2" | "P3" | "nit";
+
+const APPROVE_PRIORITY_LEVELS = ["P2", "P3", "nit"] as const;
+const APPROVE_PRIORITY_RANK: Record<string, number> = {
+	P0: 4,
+	P1: 3,
+	P2: 2,
+	P3: 1,
+	nit: 0,
+	NIT: 0,
+};
+
+export interface ApproveMaxPriorityLevelResolution {
+	readonly value: ApproveMaxPriorityLevel;
+	readonly valid: boolean;
+	readonly source: AutoPostSource;
+	readonly error?: string;
+}
+
+function isValidApproveLevel(value: unknown): value is ApproveMaxPriorityLevel {
+	return value === "off" || (typeof value === "string" && APPROVE_PRIORITY_LEVELS.includes(value as (typeof APPROVE_PRIORITY_LEVELS)[number]));
+}
+
+/** Resolve the auto-approve priority gate with trusted project config overlaying user config. */
+export function resolveApproveMaxPriorityLevelSetting(
+	user: unknown,
+	trustedProject?: unknown,
+): ApproveMaxPriorityLevelResolution {
+	if (hasOwn(trustedProject, "approveMaxPriorityLevel")) {
+		const value = (trustedProject as { approveMaxPriorityLevel?: unknown }).approveMaxPriorityLevel;
+		return isValidApproveLevel(value)
+			? { value, valid: true, source: "project" }
+			: {
+					value: "off",
+					valid: false,
+					source: "project",
+					error: `project approveMaxPriorityLevel must be one of: off, ${APPROVE_PRIORITY_LEVELS.join(", ")}`,
+				};
+	}
+	if (hasOwn(user, "approveMaxPriorityLevel")) {
+		const value = (user as { approveMaxPriorityLevel?: unknown }).approveMaxPriorityLevel;
+		return isValidApproveLevel(value)
+			? { value, valid: true, source: "user" }
+			: {
+					value: "off",
+					valid: false,
+					source: "user",
+					error: `user approveMaxPriorityLevel must be one of: off, ${APPROVE_PRIORITY_LEVELS.join(", ")}`,
+				};
+	}
+	return { value: "off", valid: true, source: "default" };
+}
+
+/** Whether all findings in a review are at or below the configured maximum priority. */
+export function findingsWithinApproveMaxPriority(
+	review: ReviewLike,
+	level: ApproveMaxPriorityLevel,
+): boolean {
+	if (level === "off") return false;
+	const maxRank = APPROVE_PRIORITY_RANK[level];
+	if (maxRank === undefined) return false;
+	const findings = Array.isArray(review.findings) ? review.findings : [];
+	return findings.every(
+		(finding) => (APPROVE_PRIORITY_RANK[String(finding.severity ?? "").toUpperCase()] ?? Infinity) <= maxRank,
+	);
+}
+
+/** Decide whether a review should be published as APPROVE instead of COMMENT. */
+export function shouldApproveReview(
+	review: ReviewLike,
+	approveMaxPriorityLevel: ApproveMaxPriorityLevel,
+): boolean {
+	const findings = Array.isArray(review.findings) ? review.findings : [];
+	return (
+		review.verdict === "approve" &&
+		approveMaxPriorityLevel !== "off" &&
+		findings.every((finding) => !finding.blocking) &&
+		findingsWithinApproveMaxPriority(review, approveMaxPriorityLevel)
+	);
+}
+
 export function classifyAssistantCompletion(
 	stopReason: string | undefined,
 	hasToolCall: boolean,
@@ -83,6 +165,36 @@ export function resolveAllowStalePublishSetting(
 	return { value: true, valid: true, source: "default" };
 }
 
+/** Resolve whether an otherwise-qualified stale review may record APPROVE. Disabled by default. */
+export function resolveAllowStaleApprovalsSetting(
+	user: unknown,
+	trustedProject?: unknown,
+): AutoPostResolution {
+	if (hasOwn(trustedProject, "allowStaleApprovals")) {
+		const value = (trustedProject as { allowStaleApprovals?: unknown }).allowStaleApprovals;
+		return typeof value === "boolean"
+			? { value, valid: true, source: "project" }
+			: {
+					value: false,
+					valid: false,
+					source: "project",
+					error: "project allowStaleApprovals must be a boolean",
+				};
+	}
+	if (hasOwn(user, "allowStaleApprovals")) {
+		const value = (user as { allowStaleApprovals?: unknown }).allowStaleApprovals;
+		return typeof value === "boolean"
+			? { value, valid: true, source: "user" }
+			: {
+					value: false,
+					valid: false,
+					source: "user",
+					error: "user allowStaleApprovals must be a boolean",
+				};
+	}
+	return { value: false, valid: true, source: "default" };
+}
+
 export interface PublishModeParseResult {
 	matched: boolean;
 	mode?: PublishMode;
@@ -125,8 +237,12 @@ export interface ReviewInvocation {
 	readonly allowNonOpen: boolean;
 	/** Trusted stale-publication setting captured before review execution begins. */
 	readonly allowStalePublish: boolean;
+	/** Trusted stale-approval setting captured before review execution begins. */
+	readonly allowStaleApprovals: boolean;
 	/** Trusted automatic-posting decision captured before review execution begins. */
 	readonly autoPost: Readonly<AutoPostResolution>;
+	/** Trusted auto-approve priority gate captured before review execution begins. */
+	readonly approveMaxPriorityLevel: ApproveMaxPriorityLevel;
 }
 
 export interface ReviewPublicationDecision {
@@ -222,6 +338,8 @@ export class ReviewInvocationGate {
 		parsed: PublishModeParseResult,
 		autoPost: AutoPostResolution,
 		allowStalePublish = true,
+		allowStaleApprovals = false,
+		approveMaxPriorityLevel: ApproveMaxPriorityLevel = "off",
 	): { accepted: boolean; error?: string } {
 		if (!parsed.matched) return { accepted: false, error: "not a pr-review invocation" };
 		if (this.active) {
@@ -241,7 +359,9 @@ export class ReviewInvocationGate {
 			prNumber: parsed.prNumber,
 			allowNonOpen: parsed.allowNonOpen === true,
 			allowStalePublish,
+			allowStaleApprovals,
 			autoPost: snapshot,
+			approveMaxPriorityLevel,
 		});
 		this.currentPhase = "reviewing";
 		return { accepted: true };
@@ -297,6 +417,8 @@ export function githubApiArgs(hostname: string, ...args: string[]): string[] {
 }
 
 export const REVIEW_EVENT = "COMMENT" as const;
+export const APPROVE_EVENT = "APPROVE" as const;
+export type ReviewEventType = typeof REVIEW_EVENT | typeof APPROVE_EVENT;
 export const MAX_INLINE_COMMENTS = 50;
 const MAX_BODY_BYTES = 65_536;
 const MAX_PAYLOAD_BYTES = 900_000;
@@ -315,20 +437,21 @@ export interface PublishComment {
 
 export interface PullReviewPayload {
 	commit_id: string;
-	event: typeof REVIEW_EVENT;
+	event: ReviewEventType;
 	body: string;
 	comments?: PublishComment[];
 }
 
-/** Build the only GitHub review payload this package can emit. */
+/** Build the GitHub review payload, optionally with an APPROVE event. */
 export function buildPullReviewPayload(
 	headSha: string,
 	body: string,
 	comments: PublishComment[],
+	event: ReviewEventType = REVIEW_EVENT,
 ): PullReviewPayload {
 	return {
 		commit_id: headSha,
-		event: REVIEW_EVENT,
+		event,
 		body,
 		...(comments.length > 0 ? { comments } : {}),
 	};
@@ -438,7 +561,8 @@ function parsePersistedInvocation(value: unknown): ReviewInvocation | undefined
 		!Number.isInteger(value.prNumber) ||
 		Number(value.prNumber) <= 0 ||
 		typeof value.allowNonOpen !== "boolean" ||
-		(value.allowStalePublish !== undefined && typeof value.allowStalePublish !== "boolean")
+		(value.allowStalePublish !== undefined && typeof value.allowStalePublish !== "boolean") ||
+		(value.allowStaleApprovals !== undefined && typeof value.allowStaleApprovals !== "boolean")
 	) {
 		return undefined;
 	}
@@ -459,12 +583,18 @@ function parsePersistedInvocation(value: unknown): ReviewInvocation | undefined
 		// Schema v2 records created before this setting existed inherit the new
 		// safe default: stale publication is body-only with both SHAs disclosed.
 		allowStalePublish: typeof value.allowStalePublish === "boolean" ? value.allowStalePublish : true,
+		// Legacy records never opt into merge-relevant stale approvals.
+		allowStaleApprovals: typeof value.allowStaleApprovals === "boolean" ? value.allowStaleApprovals : false,
 		autoPost: {
 			value: autoPost.value,
 			valid: autoPost.valid,
 			source: autoPost.source as AutoPostSource,
 			...(typeof autoPost.error === "string" ? { error: autoPost.error } : {}),
 		},
+		// Schema v2 records created before this setting existed inherit the safe
+		// default: auto-approve is disabled (publication uses COMMENT only).
+		approveMaxPriorityLevel:
+			isValidApproveLevel(value.approveMaxPriorityLevel) ? value.approveMaxPriorityLevel : "off",
 	};
 }
 
@@ -619,11 +749,26 @@ function isConfidence(value: unknown): value is number {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
 }
 
-/** Publication accepts only one complete JSON object, never fenced/prose-wrapped drafts. */
+/**
+ * Strip a single surrounding Markdown fenced code block (```lang … ```) so a model
+ * response that wraps the review object in a code fence — despite the instruction
+ * to emit exactly one JSON object — can still be parsed without a repair round-trip.
+ * Prose-wrapped or mixed drafts are intentionally left untouched (still rejected).
+ * Returns the original text when there is no recognizable outer fence.
+ */
+function stripMarkdownCodeFence(text: string): string {
+	const match = text.trim().match(/^```[^\n]*\n([\s\S]*)\n```[ \t]*$/);
+	return match ? match[1] : text;
+}
+
+/**
+ * Publication accepts one complete JSON object. A single surrounding Markdown code
+ * fence is tolerated and stripped; prose-wrapped or partial drafts are rejected.
+ */
 export function parsePublishableReview(text: string): PublishableReviewParseResult {
 	let value: unknown;
 	try {
-		value = JSON.parse(text.trim());
+		value = JSON.parse(stripMarkdownCodeFence(text).trim());
 	} catch {
 		return { error: "final response is not exactly one JSON object" };
 	}
@@ -1062,6 +1207,7 @@ function buildLosslessReviewPayload(input: {
 	changedFiles?: readonly ChangedFileLike[];
 	bodyPreamble?: string;
 	diagnostics?: readonly string[];
+	event?: ReviewEventType;
 }): { payload?: PullReviewPayload; diagnostics: string[]; errors: string[] } {
 	const diagnostics = [...(input.diagnostics ?? [])];
 	if (!/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/i.test(input.commitId)) {
@@ -1094,7 +1240,12 @@ function buildLosslessReviewPayload(input: {
 	if (Buffer.byteLength(body, "utf8") > MAX_BODY_BYTES) {
 		return { diagnostics, errors: ["final review body exceeds 65536 UTF-8 bytes"] };
 	}
-	const payload = buildPullReviewPayload(input.commitId.toLowerCase(), body, selected.comments);
+	const payload = buildPullReviewPayload(
+		input.commitId.toLowerCase(),
+		body,
+		selected.comments,
+		input.event ?? REVIEW_EVENT,
+	);
 	if (Buffer.byteLength(JSON.stringify(payload), "utf8") > MAX_PAYLOAD_BYTES) {
 		return { diagnostics, errors: ["review payload is too large"] };
 	}
@@ -1324,6 +1475,7 @@ export type PublishStatus =
 export interface PublishResult {
 	status: PublishStatus;
 	message: string;
+	event?: ReviewEventType;
 	reviewId?: number;
 	url?: string;
 	reconciled?: boolean;
@@ -1354,10 +1506,22 @@ export async function publishPullReview(input: {
 	headSha: string;
 	allowNonOpen: boolean;
 	allowStale?: boolean;
+	allowStaleApprovals?: boolean;
+	approveMaxPriorityLevel?: ApproveMaxPriorityLevel;
 	expectedRepository?: RepositoryBinding;
 	review: ReviewLike;
 }): Promise<PublishResult> {
-	const { cwd, prNumber, headSha, allowNonOpen, allowStale = false, expectedRepository, review } = input;
+	const {
+		cwd,
+		prNumber,
+		headSha,
+		allowNonOpen,
+		allowStale = false,
+		allowStaleApprovals = false,
+		approveMaxPriorityLevel = "off",
+		expectedRepository,
+		review,
+	} = input;
 	if (!Number.isInteger(prNumber) || prNumber <= 0) return { status: "failed", message: "invalid PR number" };
 	if (!/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/i.test(headSha)) return { status: "failed", message: "invalid head SHA" };
 	const normalizedHeadSha = headSha.toLowerCase();
@@ -1437,12 +1601,18 @@ export async function publishPullReview(input: {
 				changedFileLookupFailed = true;
 			}
 		}
+		// Stale publication authorization is independent from merge-relevant stale
+		// approval. The latter requires its own explicit frozen config opt-in.
+		const isApprove =
+			(!headPlan.stale || allowStaleApprovals) &&
+			shouldApproveReview(validatedReview, approveMaxPriorityLevel);
 		const built = buildLosslessReviewPayload({
 			review: validatedReview,
 			commitId: headPlan.commitId,
 			markerHeadSha: normalizedHeadSha,
 			allowInlineComments,
 			changedFiles,
+			...(isApprove ? { event: APPROVE_EVENT } : {}),
 			...(changedFileLookupFailed ? { diagnostics: [CHANGED_FILE_LOOKUP_DIAGNOSTIC] } : {}),
 			...(headPlan.stale
 				? { bodyPreamble: buildStaleReviewNotice(headPlan.reviewedHeadSha, headPlan.currentHeadSha) }
@@ -1482,6 +1652,7 @@ export async function publishPullReview(input: {
 				? `; ${CHANGED_FILE_LOOKUP_DIAGNOSTIC}`
 				: `; ${built.diagnostics.length} inline finding${built.diagnostics.length === 1 ? "" : "s"} kept in the summary: ${built.diagnostics.join("; ")}`;
 		const degraded = !isOpen || headPlan.stale || built.diagnostics.length > 0;
+		const eventLabel = payload.event === APPROVE_EVENT ? "APPROVE" : "COMMENT";
 		const post = await runGh(
 			githubApiArgs(hostname, "--method", "POST", `repos/${repository}/pulls/${prNumber}/reviews`, "--input", "-"),
 			cwd,
@@ -1497,10 +1668,11 @@ export async function publishPullReview(input: {
 			return {
 				status: degraded ? "posted_degraded" : "posted",
 				message: headPlan.stale
-					? `body-only stale COMMENT review posted (${headPlan.reviewedHeadSha} -> ${headPlan.currentHeadSha})`
+					? `body-only stale ${eventLabel} review posted (${headPlan.reviewedHeadSha} -> ${headPlan.currentHeadSha})`
 					: isOpen
-						? `GitHub COMMENT review posted${inlineWarning}`
-						: "body-only COMMENT review posted for non-open PR",
+						? `GitHub ${eventLabel} review posted${inlineWarning}`
+						: `body-only ${eventLabel} review posted for non-open PR`,
+				event: payload.event,
 				reviewId: response.id,
 				url: response.html_url,
 			};
@@ -1510,7 +1682,8 @@ export async function publishPullReview(input: {
 			if (await hasExistingMarker(cwd, hostname, repository, prNumber, identity, normalizedHeadSha)) {
 				return {
 					status: degraded ? "posted_degraded" : "posted",
-					message: `GitHub review found during failure reconciliation${inlineWarning}`,
+					message: `GitHub ${eventLabel} review found during failure reconciliation${inlineWarning}`,
+					event: payload.event,
 					reconciled: true,
 				};
 			}

package/package.json

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

@@ -53,7 +53,7 @@ Tier→model mapping is set with `/pr-review-config`; if a tier is unset the sub
 
 Arguments for this run: `$@`
 - `$1` is the PR number (required).
-- `--comment` explicitly requests one GitHub `COMMENT` review for this run, even when automatic posting is disabled.
+- `--comment` explicitly requests one GitHub review for this run, even when automatic posting is disabled. It is `COMMENT` by default and may be a gated `APPROVE` when approval configuration qualifies the final review.
 - `--no-comment` suppresses posting for this run, even when automatic posting is enabled.
 - With no review-mode flag, use the balanced five-pass default.
 - `--balanced` explicitly selects the same balanced default for backward compatibility.
@@ -99,7 +99,7 @@ gh api --hostname "$repo_host" user --jq .login
 
 **Duplicate-review reconciliation.** Prior issue comments and formal review bodies are authoritative only when authored by the current `gh` identity and containing the exact marker form `<!-- pi-pr-review: {"schema":1,"headRefOid":"<full-head-SHA>"} -->`. If the marker SHA differs from the current `headRefOid`, the PR has new commits since the previous review, so continue and review the current diff. If prior content is unmarked, treat it as unknown/stale and continue; it cannot prove the current head was reviewed. The publishing extension performs an additional identity-scoped, paginated duplicate check immediately before any write.
 
-Otherwise continue and set final `disposition: "reviewed"`. For closed/merged PRs that were explicitly confirmed or allowed with `--include-closed`/`--review-closed`, review the fetched base↔head diff normally. If publication is enabled, the extension folds inline findings into one body-only formal `COMMENT` review; the orchestrator still emits only JSON.
+Otherwise continue and set final `disposition: "reviewed"`. For closed/merged PRs that were explicitly confirmed or allowed with `--include-closed`/`--review-closed`, review the fetched base↔head diff normally. If publication is enabled, the extension folds inline findings into one body-only formal review; it is `COMMENT` by default and may be a gated `APPROVE`. The orchestrator still emits only JSON.
 
 ## Step 2 — Gather project convention files
 
@@ -196,7 +196,7 @@ The orchestrator must never call `gh` to post comments or reviews. Always finish
 
 After exact-contract validation, the extension 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. `/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 `COMMENT` payload and sends at most one GitHub review `POST`. The event is always `COMMENT`, never `APPROVE` or `REQUEST_CHANGES`. For a current, open PR, the first 50 eligible P0–P3 findings with valid, unique diff anchors are inline. All other findings that pass content validation stay in the top-level review body, including nits, off-diff findings, unavailable diff metadata, duplicate anchors, and overflow. Stale reviews and authorized closed or merged reviews are body-only. A failed write never triggers a fallback POST.
+Every authorized publish path builds one GitHub review payload and sends at most one review `POST`. It is `COMMENT` by default, or `APPROVE` only when the trusted approval configuration qualifies an `approve` verdict; it never submits `REQUEST_CHANGES`. For a current, open PR, the first 50 eligible P0–P3 findings with valid, unique diff anchors are inline. All other findings that pass content validation stay in the top-level review body, including nits, off-diff findings, unavailable diff metadata, duplicate anchors, and overflow. 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.