pi-pr-review 1.6.5 → 1.6.6

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "1.6.5"
+  ".": "1.6.6"
 }

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.6.6](https://github.com/10ego/pi-pr-review/compare/v1.6.5...v1.6.6) (2026-07-13)
+
+
+### Bug Fixes
+
+* **publish:** persist completed review cache ([#10](https://github.com/10ego/pi-pr-review/issues/10)) ([e5a1f33](https://github.com/10ego/pi-pr-review/commit/e5a1f333ce6a4bbf624d889a0954bdd251e7d902))
+
 ## [1.6.5](https://github.com/10ego/pi-pr-review/compare/v1.6.4...v1.6.5) (2026-07-13)
 
 

package/README.md

@@ -150,7 +150,7 @@ If a new commit makes a completed review stale, publish the cached result withou
 /pr-review-publish 123 --allow-stale
 ```
 
-Inline comments are intentionally disabled for stale reviews because the original anchors may no longer be valid. The stale review is body-only and identifies both the reviewed and current SHAs. The cache lasts for the current Pi session.
+Inline comments are intentionally disabled for stale reviews because the original anchors may no longer be valid. The stale review is body-only and identifies both the reviewed and current SHAs. The cache is stored in the current Pi session, survives extension reloads and session resumes, and is bound to that session instance's ID and creation metadata as well as the repository.
 
 ## Optional verification
 

package/extensions/review-table.ts

@@ -19,6 +19,8 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import {
 	classifyAssistantCompletion,
+	COMPLETED_REVIEW_BRANCH_ANCHOR_TYPE,
+	COMPLETED_REVIEW_ENTRY_TYPE,
 	CompletedReviewCache,
 	decideReviewPublication,
 	isNonOpenConfirmationPrompt,
@@ -28,10 +30,13 @@ import {
 	publishPullReview,
 	resolveAutoPostSetting,
 	resolveRepositoryBinding,
+	restoreCompletedReviewBranch,
 	ReviewInvocationGate,
 	shouldPublishReview,
 	validateReviewInvocation,
 	type AutoPostResolution,
+	type CompletedReviewRecord,
+	type CompletedReviewSessionIdentity,
 	type RepositoryBinding,
 	type ReviewInvocation,
 	type ReviewLike,
@@ -363,6 +368,13 @@ async function maybePublishReview(
 		ctx.ui.notify("PR review was not posted: final JSON is missing pr.head_sha", "error");
 		return;
 	}
+	if (!expectedRepository) {
+		ctx.ui.notify(
+			"PR review was not posted because its repository identity could not be established before caching; no publish-only cache is available. Rerun /pr-review when GitHub repository lookup is working.",
+			"error",
+		);
+		return;
+	}
 	const result = await publishPullReview({
 		cwd: ctx.cwd,
 		prNumber: invocation.prNumber,
@@ -377,6 +389,30 @@ async function maybePublishReview(
 export default function (pi: ExtensionAPI) {
 	const invocationGate = new ReviewInvocationGate();
 	const completedReviews = new CompletedReviewCache();
+	const sessionIdentity = (ctx: ExtensionContext): CompletedReviewSessionIdentity | undefined => {
+		const header = ctx.sessionManager.getHeader();
+		const id = ctx.sessionManager.getSessionId();
+		return header?.id === id && typeof header.timestamp === "string"
+			? { id, startedAt: header.timestamp }
+			: undefined;
+	};
+	const restoreCompletedReviews = (ctx: ExtensionContext) => {
+		const session = sessionIdentity(ctx);
+		if (!session) {
+			completedReviews.clear();
+			return;
+		}
+		restoreCompletedReviewBranch(completedReviews, ctx.sessionManager.getBranch(), session);
+	};
+	let pendingCompletion:
+		| {
+				text: string;
+				invocation: ReviewInvocation;
+				repository?: RepositoryBinding;
+				record?: CompletedReviewRecord;
+				session?: CompletedReviewSessionIdentity;
+		  }
+		| undefined;
 	const telemetryTracker = new ReviewTelemetryTracker();
 	const persistTelemetry = (completion: ReviewPerformanceTelemetry["completion"]) => {
 		const telemetry = telemetryTracker.finish(completion);
@@ -444,12 +480,28 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.on("session_start", () => {
+	pi.on("session_start", (_event, ctx) => {
 		invocationGate.clear();
-		completedReviews.clear();
+		pendingCompletion = undefined;
+		restoreCompletedReviews(ctx);
 		telemetryTracker.clear();
 	});
 
+	pi.on("session_tree", (event, ctx) => {
+		invocationGate.clear();
+		pendingCompletion = undefined;
+		restoreCompletedReviews(ctx);
+		telemetryTracker.clear();
+		const session = sessionIdentity(ctx);
+		if (event.summaryEntry || !session) return;
+		try {
+			// Pi otherwise resumes at the JSONL tail, not a no-summary /tree selection.
+			pi.appendEntry(COMPLETED_REVIEW_BRANCH_ANCHOR_TYPE, { schemaVersion: 2, session });
+		} catch (error) {
+			ctx.ui.notify(`PR review cache branch selection will not survive session resume: ${String(error)}`, "warning");
+		}
+	});
+
 	pi.on("input", (event, ctx) => {
 		if (invocationGate.phase() === "awaiting_confirmation") {
 			const confirmation = invocationGate.resolveConfirmationInput(event.text);
@@ -486,6 +538,41 @@ export default function (pi: ExtensionAPI) {
 		telemetryTracker.toolEnded(event.toolCallId);
 	});
 
+	pi.on("turn_end", async (_event, ctx) => {
+		const pending = pendingCompletion;
+		pendingCompletion = undefined;
+		if (!pending) return;
+		if (pending.record && pending.session) {
+			const currentSession = sessionIdentity(ctx);
+			if (
+				!currentSession ||
+				currentSession.id !== pending.session.id ||
+				currentSession.startedAt !== pending.session.startedAt
+			) {
+				ctx.ui.notify("Completed review was not persisted or posted because the session identity changed", "warning");
+				return;
+			}
+			const leaf = ctx.sessionManager.getLeafEntry();
+			const leafText = leaf?.type === "message" && leaf.message.role === "assistant"
+				? assistantText(leaf.message as { content?: MessagePart[] })
+				: "";
+			const leafReview = parsePublishableReview(leafText).review;
+			const reviewEntryId = leaf?.type === "message" && leaf.message.role === "assistant" && leafReview
+				? leaf.id
+				: undefined;
+			try {
+				// Persist before any GitHub preflight so a failed post always remains retryable.
+				pi.appendEntry(
+					COMPLETED_REVIEW_ENTRY_TYPE,
+					completedReviews.persist(pending.record, pending.session, reviewEntryId, leafReview),
+				);
+			} catch (error) {
+				ctx.ui.notify(`Completed review cache will not survive an extension reload: ${String(error)}`, "warning");
+			}
+		}
+		await maybePublishReview(pending.text, pending.invocation, ctx, pending.repository);
+	});
+
 	pi.on("message_end", async (event, ctx) => {
 		if (event.message.role !== "assistant") return;
 		const completion = classifyAssistantCompletion(event.message.stopReason, hasToolCall(event.message));
@@ -517,6 +604,8 @@ export default function (pi: ExtensionAPI) {
 		if (invocation) {
 			const publishable = parsePublishableReview(text);
 			let repository: RepositoryBinding | undefined;
+			let record: CompletedReviewRecord | undefined;
+			let session: CompletedReviewSessionIdentity | undefined;
 			if (
 				publishable.review &&
 				!validateReviewInvocation(publishable.review, invocation) &&
@@ -524,13 +613,17 @@ export default function (pi: ExtensionAPI) {
 			) {
 				try {
 					repository = await resolveRepositoryBinding(ctx.cwd);
-					// Cache before publication preflight so a stale failure remains directly publishable.
-					completedReviews.remember(publishable.review, invocation, repository);
+					// Cache before publication preflight; persist after Pi stores the assistant message.
+					record = completedReviews.remember(publishable.review, invocation, repository);
+					session = sessionIdentity(ctx);
+					if (!session) {
+						ctx.ui.notify("Completed review cache will not survive reload: session identity is unavailable", "warning");
+					}
 				} catch (error) {
 					ctx.ui.notify(`Completed review is not available to publish-only: ${String(error)}`, "warning");
 				}
 			}
-			await maybePublishReview(text, invocation, ctx, repository);
+			pendingCompletion = { text, invocation, repository, record, session };
 		}
 
 		// Keep raw JSON for automation; only prettify for interactive terminals.

package/lib/pr-review-publish.ts

@@ -1,5 +1,6 @@
 import { Buffer } from "node:buffer";
 import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
 
 export type PublishMode = "auto" | "force" | "disabled";
 export type AutoPostSource = "default" | "user" | "project";
@@ -313,20 +314,164 @@ export interface CompletedReviewRecord {
 	repository: RepositoryBinding;
 }
 
+export const COMPLETED_REVIEW_ENTRY_TYPE = "pr-review-completed";
+export const COMPLETED_REVIEW_BRANCH_ANCHOR_TYPE = "pr-review-cache-branch";
+
+export interface CompletedReviewSessionIdentity {
+	id: string;
+	startedAt: string;
+}
+
+export interface PersistedCompletedReview {
+	schemaVersion: 2;
+	session: CompletedReviewSessionIdentity;
+	invocation: ReviewInvocation;
+	repository: RepositoryBinding;
+	reviewHash: string;
+	reviewEntryId?: string;
+	review?: ReviewLike;
+}
+
+export interface CompletedReviewSessionEntryLike {
+	type: string;
+	id?: string;
+	customType?: string;
+	data?: unknown;
+	message?: unknown;
+}
+
 function completedReviewKey(repository: RepositoryBinding, prNumber: number): string {
 	return `${repository.hostname.toLowerCase()}:${repository.repository.toLowerCase()}:${prNumber}`;
 }
 
+export function validRepositoryBinding(value: unknown): value is RepositoryBinding {
+	if (!isObject(value)) return false;
+	return (
+		typeof value.repository === "string" &&
+		/^[^/\s]+\/[^/\s]+$/.test(value.repository) &&
+		typeof value.hostname === "string" &&
+		/^[a-z0-9.-]+$/i.test(value.hostname)
+	);
+}
+
+function validSessionIdentity(value: unknown): value is CompletedReviewSessionIdentity {
+	return (
+		isObject(value) &&
+		typeof value.id === "string" &&
+		value.id.length > 0 &&
+		typeof value.startedAt === "string" &&
+		value.startedAt.length > 0
+	);
+}
+
+function sameSessionIdentity(left: CompletedReviewSessionIdentity, right: CompletedReviewSessionIdentity): boolean {
+	return left.id === right.id && left.startedAt === right.startedAt;
+}
+
+function reviewHash(review: ReviewLike): string {
+	return createHash("sha256").update(JSON.stringify(review)).digest("hex");
+}
+
+function parsePersistedInvocation(value: unknown): ReviewInvocation | undefined {
+	if (!isObject(value)) return undefined;
+	if (!new Set(["auto", "force", "disabled"]).has(String(value.mode))) return undefined;
+	if (!Number.isInteger(value.prNumber) || Number(value.prNumber) <= 0 || typeof value.allowNonOpen !== "boolean") {
+		return undefined;
+	}
+	const autoPost = value.autoPost;
+	if (
+		!isObject(autoPost) ||
+		typeof autoPost.value !== "boolean" ||
+		typeof autoPost.valid !== "boolean" ||
+		!new Set(["default", "user", "project"]).has(String(autoPost.source)) ||
+		(autoPost.error !== undefined && typeof autoPost.error !== "string")
+	) {
+		return undefined;
+	}
+	return {
+		mode: value.mode as PublishMode,
+		prNumber: Number(value.prNumber),
+		allowNonOpen: value.allowNonOpen,
+		autoPost: {
+			value: autoPost.value,
+			valid: autoPost.valid,
+			source: autoPost.source as AutoPostSource,
+			...(typeof autoPost.error === "string" ? { error: autoPost.error } : {}),
+		},
+	};
+}
+
 /** Session-scoped latest completed review per repository and PR. */
 export class CompletedReviewCache {
 	private readonly reviews = new Map<string, CompletedReviewRecord>();
 
-	remember(review: ReviewLike, invocation: ReviewInvocation, repository: RepositoryBinding): void {
-		this.reviews.set(completedReviewKey(repository, invocation.prNumber), {
+	remember(review: ReviewLike, invocation: ReviewInvocation, repository: RepositoryBinding): CompletedReviewRecord {
+		const record = {
 			review,
-			invocation: { ...invocation },
+			invocation: { ...invocation, autoPost: { ...invocation.autoPost } },
 			repository: { ...repository },
-		});
+		};
+		this.reviews.set(completedReviewKey(repository, invocation.prNumber), record);
+		return record;
+	}
+
+	persist(
+		record: CompletedReviewRecord,
+		session: CompletedReviewSessionIdentity,
+		reviewEntryId?: string,
+		referencedReview?: ReviewLike,
+	): PersistedCompletedReview {
+		const digest = reviewHash(record.review);
+		const useReference = !!reviewEntryId && !!referencedReview && reviewHash(referencedReview) === digest;
+		return {
+			schemaVersion: 2,
+			session: { ...session },
+			invocation: { ...record.invocation, autoPost: { ...record.invocation.autoPost } },
+			repository: { ...record.repository },
+			reviewHash: digest,
+			...(useReference ? { reviewEntryId } : { review: record.review }),
+		};
+	}
+
+	/** Restore only strictly validated state created by this exact Pi session instance. */
+	restore(
+		value: unknown,
+		session: CompletedReviewSessionIdentity,
+		referencedReview?: ReviewLike,
+	): boolean {
+		if (
+			!isObject(value) ||
+			value.schemaVersion !== 2 ||
+			!validSessionIdentity(value.session) ||
+			!sameSessionIdentity(value.session, session) ||
+			!validRepositoryBinding(value.repository)
+		) {
+			return false;
+		}
+		const invocation = parsePersistedInvocation(value.invocation);
+		if (!invocation || typeof value.reviewHash !== "string" || !/^[0-9a-f]{64}$/.test(value.reviewHash)) {
+			return false;
+		}
+		const hasReference = typeof value.reviewEntryId === "string" && value.reviewEntryId.length > 0;
+		const hasInlineReview = Object.prototype.hasOwnProperty.call(value, "review");
+		if (hasReference === hasInlineReview) return false;
+		const candidate = hasReference ? referencedReview : value.review;
+		let parsed: PublishableReviewParseResult;
+		try {
+			parsed = parsePublishableReview(JSON.stringify(candidate));
+		} catch {
+			return false;
+		}
+		if (
+			!parsed.review ||
+			reviewHash(parsed.review) !== value.reviewHash ||
+			!shouldPublishReview(parsed.review) ||
+			validateReviewInvocation(parsed.review, invocation)
+		) {
+			return false;
+		}
+		this.remember(parsed.review, invocation, value.repository);
+		return true;
 	}
 
 	get(prNumber: number, repository: RepositoryBinding): CompletedReviewRecord | undefined {
@@ -338,6 +483,45 @@ export class CompletedReviewCache {
 	}
 }
 
+function reviewFromSessionMessage(entry: CompletedReviewSessionEntryLike | undefined): ReviewLike | undefined {
+	if (!entry || entry.type !== "message" || !isObject(entry.message) || entry.message.role !== "assistant") {
+		return undefined;
+	}
+	const content = entry.message.content;
+	const text = typeof content === "string"
+		? content
+		: Array.isArray(content)
+			? content
+					.filter((part) => isObject(part) && part.type === "text" && typeof part.text === "string")
+					.map((part) => String(part.text))
+					.join("")
+			: "";
+	return parsePublishableReview(text).review;
+}
+
+/** Rebuild cache state after session load, reload, resume, or tree navigation. */
+export function restoreCompletedReviewBranch(
+	cache: CompletedReviewCache,
+	entries: CompletedReviewSessionEntryLike[],
+	session: CompletedReviewSessionIdentity,
+): number {
+	cache.clear();
+	const seenEntries = new Map<string, CompletedReviewSessionEntryLike>();
+	let restored = 0;
+	for (const entry of entries) {
+		if (typeof entry.id === "string") seenEntries.set(entry.id, entry);
+		if (entry.type !== "custom" || entry.customType !== COMPLETED_REVIEW_ENTRY_TYPE) continue;
+		const reviewEntryId = isObject(entry.data) && typeof entry.data.reviewEntryId === "string"
+			? entry.data.reviewEntryId
+			: undefined;
+		const referencedReview = reviewEntryId
+			? reviewFromSessionMessage(seenEntries.get(reviewEntryId))
+			: undefined;
+		if (cache.restore(entry.data, session, referencedReview)) restored++;
+	}
+	return restored;
+}
+
 export interface PublishableReviewParseResult {
 	review?: ReviewLike;
 	error?: string;
@@ -764,10 +948,9 @@ export async function resolveRepositoryBinding(cwd: string): Promise<RepositoryB
 	);
 	const repository = String(repoInfo.nameWithOwner ?? "");
 	const hostname = new URL(String(repoInfo.url ?? "")).hostname;
-	if (!/^[^/\s]+\/[^/\s]+$/.test(repository) || !/^[a-z0-9.-]+$/i.test(hostname)) {
-		throw new Error("invalid GitHub repository or hostname");
-	}
-	return { repository, hostname };
+	const binding = { repository, hostname };
+	if (!validRepositoryBinding(binding)) throw new Error("invalid GitHub repository or hostname");
+	return binding;
 }
 
 function flattenPages<T>(value: unknown): T[] {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-pr-review",
-  "version": "1.6.5",
+  "version": "1.6.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 safe COMMENT-only 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
 
 When enabled, the extension creates exactly one formal GitHub pull-request review. Its top-level body contains the overview, verification, strengths, suggested verdict, counts, nits, and findings that cannot be attached inline. Eligible P0–P3 diff-anchored findings are attached as inline comments within that same review and are omitted from the top-level issue list to avoid duplication. The API event is hardcoded to `COMMENT`: publication never sends `APPROVE` or `REQUEST_CHANGES`, even when the suggested verdict is `request_changes`. It appends the same-head marker, verifies the current head, validates every inline anchor against GitHub diff metadata, and refuses partial open-PR publication. For a known closed/merged PR it requires either trusted `--include-closed`/`--review-closed` invocation authority or the one-shot affirmative confirmation flow, then posts one body-only `COMMENT` review with each inline finding folded into the body exactly once. Unknown lifecycle states and unconfirmed non-open writes fail without posting or falling back to an issue comment.
 
-The extension caches the latest valid completed review per repository and PR before publication preflight for the current extension session. If publication reports that the PR head changed, the user can run `/pr-review-publish <PR-NUM> --allow-stale` to post that cached result without another model turn. This explicit stale override produces a body-only `COMMENT` review with the reviewed and preflight-observed SHAs disclosed and no potentially invalid inline anchors. Never rerun the review merely to change posting intent, and never attempt the GitHub write yourself.
+The extension caches the latest valid completed review per repository and PR before publication preflight in the current Pi session. The session-backed cache survives extension reloads and session resumes but is bound to the originating session instance and repository. If publication reports that the PR head changed, the user can run `/pr-review-publish <PR-NUM> --allow-stale` to post that cached result without another model turn. This explicit stale override produces a body-only `COMMENT` review with the reviewed and preflight-observed SHAs disclosed and no potentially invalid inline anchors. Never rerun the review merely to change posting intent, and never attempt the GitHub write yourself.
 
 ---
 

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

@@ -0,0 +1,197 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	COMPLETED_REVIEW_BRANCH_ANCHOR_TYPE,
+	COMPLETED_REVIEW_ENTRY_TYPE,
+	CompletedReviewCache,
+	resolveAutoPostSetting,
+	type CompletedReviewSessionIdentity,
+	type ReviewLike,
+} from "../lib/pr-review-publish.ts";
+
+mock.module("@earendil-works/pi-coding-agent", () => ({
+	CONFIG_DIR_NAME: ".pi",
+	getAgentDir: () => join(tmpdir(), "pi-pr-review-empty-agent-dir"),
+}));
+
+const reviewTable = (await import("../extensions/review-table.ts")).default;
+
+const review: ReviewLike = {
+	pr: { number: 7, title: "Lifecycle review", head_sha: "a".repeat(40) },
+	disposition: "reviewed",
+	verification: "Not run.",
+	overview: "Checks lifecycle persistence.",
+	strengths: [],
+	findings: [],
+	notes: { correctness: "", security: "", performance: "" },
+	verdict: "approve",
+	overall_correctness: "patch is correct",
+	overall_explanation: "No issues found.",
+	overall_confidence_score: 0.9,
+};
+
+const session: CompletedReviewSessionIdentity = {
+	id: "shared-explicit-id",
+	startedAt: "2026-07-13T00:00:00.000Z",
+};
+const repository = { hostname: "github.com", repository: "owner/repo" };
+const invocation = {
+	mode: "disabled" as const,
+	prNumber: 7,
+	allowNonOpen: false,
+	autoPost: resolveAutoPostSetting({ autoPostReviews: false }),
+};
+
+interface Harness {
+	handlers: Map<string, Array<(event: any, ctx: any) => any>>;
+	commands: Map<string, (args: string, ctx: any) => Promise<void>>;
+	branch: any[];
+	notifications: string[];
+	ctx: any;
+	appendMessage(message: any, id?: string): any;
+	emit(name: string, event: any): Promise<any[]>;
+}
+
+const tempDirs: string[] = [];
+let previousPath: string | undefined;
+
+afterEach(() => {
+	if (previousPath !== undefined) process.env.PATH = previousPath;
+	previousPath = undefined;
+	for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+function installFakeGh(): string {
+	const dir = mkdtempSync(join(tmpdir(), "pi-pr-review-lifecycle-"));
+	tempDirs.push(dir);
+	const gh = join(dir, "gh");
+	writeFileSync(
+		gh,
+		`#!/usr/bin/env bash
+set -euo pipefail
+if [[ "$*" == "repo view --json nameWithOwner,url" ]]; then
+  echo '{"nameWithOwner":"owner/repo","url":"https://github.com/owner/repo"}'
+else
+  echo 'intentional lifecycle-test stop' >&2
+  exit 1
+fi
+`,
+	);
+	chmodSync(gh, 0o755);
+	if (previousPath === undefined) previousPath = process.env.PATH;
+	process.env.PATH = `${dir}:${process.env.PATH ?? ""}`;
+	return dir;
+}
+
+function createHarness(initialBranch: any[] = [], identity = session): Harness {
+	let nextId = 1;
+	const handlers = new Map<string, Array<(event: any, ctx: any) => any>>();
+	const commands = new Map<string, (args: string, ctx: any) => Promise<void>>();
+	const branch = [...initialBranch];
+	const notifications: string[] = [];
+	const sessionManager = {
+		getBranch: () => [...branch],
+		getSessionId: () => identity.id,
+		getHeader: () => ({ type: "session", id: identity.id, timestamp: identity.startedAt, cwd: "/tmp" }),
+		getLeafEntry: () => branch.at(-1),
+	};
+	const ctx = {
+		cwd: installFakeGh(),
+		mode: "json",
+		isProjectTrusted: () => false,
+		sessionManager,
+		ui: { notify: (message: string) => notifications.push(message) },
+	};
+	const pi = {
+		on: (name: string, handler: (event: any, ctx: any) => any) => {
+			const registered = handlers.get(name) ?? [];
+			registered.push(handler);
+			handlers.set(name, registered);
+		},
+		registerCommand: (name: string, options: { handler: (args: string, ctx: any) => Promise<void> }) => {
+			commands.set(name, options.handler);
+		},
+		appendEntry: (customType: string, data: unknown) => {
+			branch.push({ type: "custom", id: `custom-${nextId++}`, customType, data });
+		},
+	};
+	reviewTable(pi as any);
+	return {
+		handlers,
+		commands,
+		branch,
+		notifications,
+		ctx,
+		appendMessage(message: any, id = `message-${nextId++}`) {
+			const entry = { type: "message", id, message };
+			branch.push(entry);
+			return entry;
+		},
+		async emit(name: string, event: any) {
+			const results = [];
+			for (const handler of handlers.get(name) ?? []) results.push(await handler(event, ctx));
+			return results;
+		},
+	};
+}
+
+function persistedInlineReview(identity = session): any {
+	const cache = new CompletedReviewCache();
+	const record = cache.remember(review, invocation, repository);
+	return cache.persist(record, identity);
+}
+
+describe("completed review extension lifecycle", () => {
+	test("persists a reference before publishing after Pi stores exact assistant JSON", async () => {
+		const harness = createHarness();
+		await harness.emit("input", { text: "/pr-review 7 --comment" });
+		const message = {
+			role: "assistant",
+			stopReason: "stop",
+			content: [{ type: "text", text: JSON.stringify(review) }],
+		};
+		await harness.emit("message_end", { message });
+		const assistantEntry = harness.appendMessage(message, "assistant-review");
+		await harness.emit("turn_end", { message, toolResults: [] });
+
+		const persisted = harness.branch.findLast(
+			(entry) => entry.type === "custom" && entry.customType === COMPLETED_REVIEW_ENTRY_TYPE,
+		);
+		expect(persisted?.data.reviewEntryId).toBe(assistantEntry.id);
+		expect(persisted?.data.review).toBeUndefined();
+		expect(harness.notifications.some((message) => message.includes("PR review publish failed"))).toBeTrue();
+	});
+
+	test("restores on session_start, clears on tree navigation, and scopes reused IDs by header", async () => {
+		const persisted = persistedInlineReview();
+		const cacheEntry = { type: "custom", id: "cache", customType: COMPLETED_REVIEW_ENTRY_TYPE, data: persisted };
+		const harness = createHarness([cacheEntry]);
+		await harness.emit("session_start", { reason: "reload" });
+		await harness.commands.get("pr-review-publish")!("7 --allow-stale", harness.ctx);
+		expect(harness.notifications.some((message) => message.includes("No completed review"))).toBeFalse();
+
+		harness.branch.splice(0);
+		harness.notifications.splice(0);
+		await harness.emit("session_tree", { newLeafId: null, oldLeafId: "cache" });
+		expect(harness.branch.at(-1)?.customType).toBe(COMPLETED_REVIEW_BRANCH_ANCHOR_TYPE);
+		await harness.commands.get("pr-review-publish")!("7 --allow-stale", harness.ctx);
+		expect(harness.notifications.some((message) => message.includes("No completed review"))).toBeTrue();
+
+		const reusedId = createHarness([cacheEntry], { id: session.id, startedAt: "2026-07-14T00:00:00.000Z" });
+		await reusedId.emit("session_start", { reason: "fork" });
+		await reusedId.commands.get("pr-review-publish")!("7 --allow-stale", reusedId.ctx);
+		expect(reusedId.notifications.some((message) => message.includes("No completed review"))).toBeTrue();
+	});
+
+	test("does not append a redundant anchor for summarized tree navigation", async () => {
+		const harness = createHarness();
+		await harness.emit("session_tree", {
+			newLeafId: "summary",
+			oldLeafId: "old",
+			summaryEntry: { type: "branch_summary", id: "summary" },
+		});
+		expect(harness.branch.some((entry) => entry.customType === COMPLETED_REVIEW_BRANCH_ANCHOR_TYPE)).toBeFalse();
+	});
+});

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

@@ -11,6 +11,7 @@ import {
 	classifyAssistantCompletion,
 	canonicalReviewMarker,
 	collectFoldedComments,
+	COMPLETED_REVIEW_ENTRY_TYPE,
 	CompletedReviewCache,
 	decideReviewPublication,
 	containsReservedReviewMarker,
@@ -24,6 +25,7 @@ import {
 	planHeadPublication,
 	publishPullReview,
 	resolveAutoPostSetting,
+	restoreCompletedReviewBranch,
 	ReviewInvocationGate,
 	shouldPublishReview,
 	validateInlineComments,
@@ -80,6 +82,7 @@ const changedFiles = [
 ];
 
 const autoOff = resolveAutoPostSetting({ autoPostReviews: false });
+const sessionA = { id: "session-a", startedAt: "2026-07-13T00:00:00.000Z" };
 
 describe("automatic posting configuration", () => {
 	test("defaults to disabled", () => {
@@ -292,7 +295,7 @@ describe("publish-only completed review command", () => {
 
 	test("retains the latest completed review under its repository and PR", () => {
 		const cache = new CompletedReviewCache();
-		const invocation = { mode: "force" as const, prNumber: 7, allowNonOpen: false };
+		const invocation = { mode: "force" as const, prNumber: 7, allowNonOpen: false, autoPost: autoOff };
 		const repository = { hostname: "github.com", repository: "owner/repo" };
 		cache.remember(review, invocation, repository);
 		expect(cache.get(7, repository)).toEqual({ review, invocation, repository });
@@ -302,6 +305,76 @@ describe("publish-only completed review command", () => {
 		expect(cache.get(7, repository)).toBeUndefined();
 	});
 
+	test("restores only validated state from the same Pi session instance", () => {
+		const cache = new CompletedReviewCache();
+		const invocation = { mode: "force" as const, prNumber: 7, allowNonOpen: false, autoPost: autoOff };
+		const repository = { hostname: "github.com", repository: "owner/repo" };
+		const record = cache.remember(review, invocation, repository);
+		const persisted = cache.persist(record, sessionA);
+		const restored = new CompletedReviewCache();
+		expect(restored.restore(persisted, sessionA)).toBeTrue();
+		expect(restored.get(7, repository)).toEqual({ review, invocation, repository });
+		expect(
+			restored.restore(persisted, { id: sessionA.id, startedAt: "2026-07-14T00:00:00.000Z" }),
+		).toBeFalse();
+		expect(restored.restore({ ...persisted, schemaVersion: 1 }, sessionA)).toBeFalse();
+		expect(
+			restored.restore(
+				{ ...persisted, repository: { hostname: "invalid host", repository: "owner/repo" } },
+				sessionA,
+			),
+		).toBeFalse();
+	});
+
+	test("restores referenced reviews without duplicating raw JSON", () => {
+		const cache = new CompletedReviewCache();
+		const invocation = { mode: "force" as const, prNumber: 7, allowNonOpen: false, autoPost: autoOff };
+		const repository = { hostname: "github.com", repository: "owner/repo" };
+		const record = cache.remember(review, invocation, repository);
+		const persisted = cache.persist(record, sessionA, "review-message", review);
+		expect(persisted.review).toBeUndefined();
+		expect(cache.persist(record, sessionA, "wrong-message", { ...review, overview: "Different" }).review).toEqual(review);
+		const branch = [
+			{
+				type: "message",
+				id: "review-message",
+				message: { role: "assistant", content: [{ type: "text", text: JSON.stringify(review) }] },
+			},
+			{ type: "custom", id: "cache-entry", customType: COMPLETED_REVIEW_ENTRY_TYPE, data: persisted },
+		];
+		const restored = new CompletedReviewCache();
+		expect(restoreCompletedReviewBranch(restored, branch, sessionA)).toBe(1);
+		expect(restored.get(7, repository)).toEqual({ review, invocation, repository });
+	});
+
+	test("rebuilds cache state for reloads and session-tree navigation", () => {
+		const cache = new CompletedReviewCache();
+		const invocation = { mode: "force" as const, prNumber: 7, allowNonOpen: false, autoPost: autoOff };
+		const repository = { hostname: "github.com", repository: "owner/repo" };
+		const record = cache.remember(review, invocation, repository);
+		const persisted = cache.persist(record, sessionA);
+		const branch = [{ type: "custom", customType: COMPLETED_REVIEW_ENTRY_TYPE, data: persisted }];
+
+		expect(restoreCompletedReviewBranch(cache, branch, sessionA)).toBe(1);
+		expect(cache.get(7, repository)).toBeDefined();
+		expect(restoreCompletedReviewBranch(cache, [], sessionA)).toBe(0);
+		expect(cache.get(7, repository)).toBeUndefined();
+		expect(
+			restoreCompletedReviewBranch(cache, branch, { id: sessionA.id, startedAt: "different-instance" }),
+		).toBe(0);
+		expect(cache.get(7, repository)).toBeUndefined();
+	});
+
+	test("does not retry publication without the repository binding used for caching", () => {
+		const extension = readFileSync(new URL("../extensions/review-table.ts", import.meta.url), "utf8");
+		const publisher = extension.slice(
+			extension.indexOf("async function maybePublishReview"),
+			extension.indexOf("export default function"),
+		);
+		expect(publisher).toContain("if (!expectedRepository)");
+		expect(publisher).toContain("no publish-only cache is available");
+	});
+
 	test("keeps stale protection by default and degrades an explicit override", () => {
 		const reviewed = "a".repeat(40);
 		const current = "b".repeat(40);

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

@@ -166,8 +166,14 @@ describe("extension telemetry boundaries", () => {
 		expect(renderer).toContain('pi.appendEntry("pr-review-telemetry", telemetry)');
 		expect(renderer).toContain("telemetryTracker.pauseForConfirmation()");
 		expect(renderer).toContain("telemetryTracker.resumeAfterConfirmation()");
-		expect(renderer.indexOf('persistTelemetry("terminal_response")')).toBeLessThan(
-			renderer.indexOf("await maybePublishReview"),
+		const turnEnd = renderer.slice(
+			renderer.indexOf('pi.on("turn_end"'),
+			renderer.indexOf('pi.on("message_end"'),
 		);
+		const messageEnd = renderer.slice(renderer.indexOf('pi.on("message_end"'));
+		expect(messageEnd.indexOf('persistTelemetry("terminal_response")')).toBeLessThan(
+			messageEnd.indexOf("pendingCompletion ="),
+		);
+		expect(turnEnd.indexOf("pi.appendEntry(")).toBeLessThan(turnEnd.indexOf("await maybePublishReview"));
 	});
 });