pi-plans 0.7.0 → 0.8.1

package/src/exec.ts

@@ -9,15 +9,16 @@
  * live progress (compact aboveEditor widget; Ctrl+Shift+T expands the full
  * tree), a stall watchdog pauses the run when consecutive rounds produce no
  * task-state change, and when every task reaches a terminal state an
- * independent completion auditor verifies the plan's verification checks —
- * failed checks roll their covered tasks back to pending (audit-flow-only
- * channel), and three failed rounds pause for the user (bounded stopped
- * termination under auto-approve/headless).
+ * independent execution reviewer verifies the plan's verification checks in
+ * a detached, overlay-visible loop — failed checks roll their covered tasks
+ * back to pending (audit-flow-only channel), and five committed rounds pause
+ * the run for the user in every mode (fail-closed, never a silent stop).
  */
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { execSync } from "node:child_process";
 import type {
 	CompactionResult,
 	ExtensionAPI,
@@ -44,7 +45,7 @@ import {
 	type VccCompactionBuildResult,
 	type VccCompactionStats,
 } from "./compaction.ts";
-import { TERMINAL_RUN_STATUSES, getRun, latestRun, lintPlanIntoNotices, loadConfig, readActive, resolveStateRootOrNull, setRunStatus, StateError, utcNow } from "./state.ts";
+import { TERMINAL_RUN_STATUSES, getRun, latestRun, lintPlanIntoNotices, loadConfig, readActive, resolveStateRootOrNull, runDirPath, setRunStatus, StateError, utcNow } from "./state.ts";
 import { resolveUiLanguage, type UiLanguage } from "./ui-language.ts";
 import { bindRun, resolveActiveRun } from "./run-context.ts";
 import type { SubagentProgressEvent } from "./subagent.ts";
@@ -56,6 +57,7 @@ import {
 	applyExecutionProgress,
 	applyExecutionStopped,
 	createCheckpoint,
+	applyExecutionPlanAmended,
 	loadCheckpoint,
 	mutateCheckpoint,
 	planIdentityOf,
@@ -71,6 +73,7 @@ import { resolveGraphMode } from "./code-graph/mode.ts";
 import {
 	parseChecklist,
 	parsePlanTasks,
+	CHECKLIST_HEADERS,
 	flattenTasks,
 	type CheckItem,
 	type PlanTasks,
@@ -81,7 +84,10 @@ import {
 	auditableChecks,
 	buildTaskView,
 	currentTask,
+	findingsRollbackSet,
 	flattenTaskViews,
+	invalidateChecksForRolledBackTasks,
+	maxWave,
 	taskIsTerminal,
 	taskProgress,
 	taskProgressMap,
@@ -97,8 +103,15 @@ import {
 	renderDashboardLines,
 	renderDashboardTreeLines,
 } from "./dashboard.ts";
-import { AUDIT_MAX_ROUNDS, presolvedCheckIds, runCompletionAudit } from "./auditor.ts";
+import { REVIEW_MAX_ROUNDS, presolvedCheckIds, runCompletionAudit, writeReviewRoundReport, type AuditOutcome, type AuditRoundResult, type ReviewFinding } from "./auditor.ts";
+import type { ReviewFindingRecord } from "./workflow-state.ts";
+import { staleReloadHint as probeStaleReload } from "./staleness.ts";
 import { messaging } from "./messaging.ts";
+import { RefineOverlayController, refineOverlayContext } from "./refine-ui.ts";
+import { applyRefineProgress, applyRefineResult, type RefineLaneState } from "./refine-ui-state.ts";
+import { resolveReviewerSpawn } from "./thinking-levels.ts";
+import { loadGlobalConfig, reviewerReady } from "./global-state.ts";
+import { matchesTerminalKey } from "./terminal-keys.ts";
 
 export interface ExecState {
 	planPath: string;
@@ -117,8 +130,14 @@ export interface ExecState {
 	/** Stall watchdog (v0.6.1): consecutive settled rounds without a task
 	 * status change; auto-pause at the cap. */
 	stall: { rounds: number; lastSnapshot: string | null; paused: boolean; pausedReason?: string };
-	/** Completion-audit bookkeeping. */
-	audit: { rounds: number; failed: string[]; running: boolean };
+	/** Completion-audit bookkeeping. `rounds` is the BUDGET counter — charged
+	 * only when a round outcome commits (never on discard/cancel) — and is the
+	 * only piece persisted. */
+	audit: { rounds: number; failed: string[]; undeterminable: string[]; running: boolean; findings: ReviewFinding[] };
+	/** Execution-review loop (v0.8), memory-only: the attempt index names the
+	 * per-round report files; consecutiveDiscards bounds the fingerprint
+	 * re-run loop; inFlight owns the round's abort lifecycle. */
+	review: { attempts: number; consecutiveDiscards: number; inFlight: InFlightReview | null };
 	/** Per-settle audit latch (v0.7.1): a settled round fires the completion
 	 * audit at most once, so the turn_end / agent_before_settle / resume entry
 	 * points cannot double-consume a round when several land in one settle.
@@ -126,6 +145,18 @@ export interface ExecState {
 	auditLatch?: { auditedThisSettle: boolean; activity: number };
 }
 
+/** One in-flight review round: owns its abort lifecycle, its fingerprint of
+ * the audited subject, and the per-round one-shot wake token (v0.8). */
+interface InFlightReview {
+	controller: AbortController;
+	/** Budget round this attempt belongs to (audit.rounds + 1 at spawn). */
+	budgetRound: number;
+	/** Monotonic attempt ordinal; names the round report file. */
+	attempt: number;
+	fingerprint: string;
+	wakeSent: boolean;
+}
+
 /**
  * D-008 (issue #3): re-resolve the chrome language and repaint the dashboard
  * and status bar right after a `set-language` change.
@@ -204,6 +235,10 @@ export interface CheckpointExecutionLoad {
 	/** v0.6.1 (D-020): true when an orphaned v0.6.0 delegated executor was
 	 * detected — resume requires a fresh handoff approval. */
 	legacyDelegate?: boolean;
+	/** v0.9.1 (F-005): unresolved findings from the newest committed round,
+	 * so the /resume-plans brief can surface outstanding highs before the
+	 * per-turn injection ever runs. */
+	findings?: ReviewFinding[];
 	error?: string;
 }
 
@@ -253,9 +288,12 @@ export function loadExecutionFromCheckpoint(
 	const reverifyAll = cp.execution.reverifyAll === true || headChanged || headUnverifiable;
 	const progress: TaskProgressMap = reverifyAll ? {} : (cp.execution.tasks ?? {});
 	const tasks = buildTaskView(planTasks, progress);
-	// An audit-cap pause grants a fresh audit budget on restore (mirrors
-	// resumeGoalWaitIfPaused) so the first turn can actually re-audit.
-	const wasAuditCapPause = (cp.execution.pausedReason ?? "").startsWith(AUDIT_CAP_PAUSE_PREFIX);
+	// v0.8: a review-cap pause SURVIVES the restore — the budget must stay
+	// bounded across restarts; only /plans-execute grants a fresh one. The
+	// legacy v0.7 prefix stays dual-matched for one release.
+	const wasReviewCapPause = isReviewCapPause(cp.execution.pausedReason);
+	// Any live round from the replaced session graph dies here (CF2-002).
+	abortInFlightReview();
 	if (!reverifyAll) {
 		for (const id of cp.execution.doneVcIds) {
 			const item = items.find((candidate) => candidate.id === id);
@@ -271,22 +309,25 @@ export function loadExecutionFromCheckpoint(
 		startedAt: utcNow(),
 		usage: { inToks: cp.execution.usage.inToks, outToks: cp.execution.usage.outToks },
 		uiLanguage: resolveUiLanguage(ctx.cwd),
-		// D-020: a paused legacy (or stopped) execution rebuilds unpaused —
-		// the resume itself is the user's intent; the reason is surfaced in
-		// the resume brief instead. An audit-cap pause additionally grants a
-		// fresh audit budget here (mirrors resumeGoalWaitIfPaused), so the
-		// first turn after a cross-session resume can actually re-audit.
-			stall: {
-			rounds: 0,
+		// D-020: a paused legacy (or stopped) execution rebuilds unpaused — the
+		// resume itself is the user's intent; the reason is surfaced in the
+		// resume brief instead. EXCEPT a review-cap pause (v0.8): it must
+		// survive restores paused and at its committed round count, or the
+		// 5-round budget would never bound anything across restarts.
+		stall: {
+			rounds: cp.execution.stallRounds ?? 0,
 			lastSnapshot: null,
-			paused: false,
-			pausedReason: undefined,
+			paused: wasReviewCapPause,
+			pausedReason: wasReviewCapPause ? (cp.execution.pausedReason ?? undefined) : undefined,
 		},
 		audit: {
-			rounds: wasAuditCapPause ? 0 : (cp.execution.audit?.rounds ?? 0),
+			rounds: cp.execution.audit?.rounds ?? 0,
 			failed: [],
+			undeterminable: cp.execution.audit?.undeterminable ?? [],
+			findings: toReviewFindings(cp.execution.audit?.findings),
 			running: false,
 		},
+		review: { attempts: 0, consecutiveDiscards: 0, inFlight: null },
 		auditLatch: { auditedThisSettle: false, activity: 0 },
 	};
 	execution.stall.lastSnapshot = stallSnapshot();
@@ -295,11 +336,6 @@ export function loadExecutionFromCheckpoint(
 	resetContinuationRuntime(ctx);
 	pendingExecutionFlush = false;
 	resetExecutionCompactionState(ctx);
-	if (wasAuditCapPause) {
-		withExecutionCheckpoint(ctx, (cp2) =>
-			applyExecutionProgress(cp2, { audit: { rounds: 0, lastResult: undefined }, pausedReason: null }),
-		);
-	}
 	// D-020: an orphaned v0.6.0 delegated executor never survives a restart.
 	// Its checkpoint delegate marker REFUSES the direct load — the run must
 	// re-enter through the execution handoff so the C-006 approval gate
@@ -337,6 +373,7 @@ export function loadExecutionFromCheckpoint(
 		pausedReason: cp.execution.pausedReason,
 		legacyPlan: planTasks.legacy,
 		legacyDelegate,
+		findings: toReviewFindings(cp.execution.audit?.findings),
 	};
 }
 
@@ -475,6 +512,9 @@ function updatePanelWidget(ctx: ExtensionContext): void {
 					pausedReason: current.stall.pausedReason,
 					auditRounds: current.audit.rounds > 0 || current.audit.running ? current.audit.rounds : null,
 					auditFailed: current.audit.failed,
+					auditUndeterminable: current.audit.undeterminable,
+					findings: current.audit.findings,
+					reviewRunning: current.audit.running === true || current.review.inFlight !== null,
 					startedAt: current.startedAt,
 					usage: current.usage,
 				});
@@ -497,6 +537,9 @@ export function updateStatusWidget(ctx: ExtensionContext): void {
 			pausedReason: execution.stall.pausedReason,
 			auditRounds: execution.audit.rounds > 0 ? execution.audit.rounds : null,
 			auditFailed: execution.audit.failed,
+			auditUndeterminable: execution.audit.undeterminable,
+			findings: execution.audit.findings,
+			reviewRunning: execution.audit.running === true || execution.review.inFlight !== null,
 		});
 		ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("accent", formatDashboardSummaryLine(model)));
 		return;
@@ -524,6 +567,10 @@ export function updateStatusWidget(ctx: ExtensionContext): void {
 			ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("accent", `⌛ plans: ${active.run_id} (executing)`));
 			return;
 		}
+		if (status === "verifying") {
+			ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("accent", `🔎 plans: ${active.run_id} (verifying)`));
+			return;
+		}
 		if (status === "planning") {
 			const emoji = parseLatestPlanExists(active.artifact_dir) ? "📝" : "💬";
 			ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("muted", `${emoji} plans: ${active.run_id}`));
@@ -564,7 +611,7 @@ function persist(ctx: ExtensionContext): void {
 		startedAt: execution.startedAt,
 		usage: execution.usage,
 		stall: execution.stall,
-		audit: { rounds: execution.audit.rounds, failed: execution.audit.failed },
+		audit: { rounds: execution.audit.rounds, failed: execution.audit.failed, findings: execution.audit.findings },
 	});
 }
 
@@ -594,6 +641,8 @@ export async function startExecution(
 	ctx: ExtensionContext,
 	input: StartExecutionInput,
 ): Promise<void> {
+	// A fresh handoff replaces any live run — abort its in-flight review round first.
+	abortInFlightReview();
 	const tasks = buildTaskView(input.planTasks);
 	execution = {
 		planPath: input.planPath,
@@ -605,7 +654,8 @@ export async function startExecution(
 		usage: { inToks: 0, outToks: 0 },
 		uiLanguage: resolveUiLanguage(ctx.cwd),
 		stall: { rounds: 0, lastSnapshot: null, paused: false },
-		audit: { rounds: 0, failed: [], running: false },
+		audit: { rounds: 0, failed: [], undeterminable: [], findings: [], running: false },
+		review: { attempts: 0, consecutiveDiscards: 0, inFlight: null },
 		auditLatch: { auditedThisSettle: false, activity: 0 },
 	};
 	// Seed the watchdog baseline only after `execution` points at the new state
@@ -670,9 +720,14 @@ export function persistTaskProgress(ctx: ExtensionContext): void {
 		applyExecutionProgress(cp, {
 			tasks: taskProgressMap(execution!.tasks),
 			doneVcIds: execution!.items.filter((item) => item.done).map((item) => item.id),
+			stallRounds: execution!.stall.rounds,
 			audit: {
 				rounds: execution!.audit.rounds,
 				lastResult: execution!.audit.failed.length > 0 ? execution!.audit.failed.join(",") : undefined,
+				undeterminable: execution!.audit.undeterminable.length > 0 ? execution!.audit.undeterminable : undefined,
+				// v0.9: audit writes are replace-semantics — every writer must
+				// carry findings or a task update would silently wipe them.
+				findings: execution!.audit.findings,
 			},
 		}),
 	);
@@ -699,10 +754,10 @@ export function recordExecutionTurn(
 }
 
 /** Test hook: replace the audit subagent with a deterministic function. */
-let auditRunnerForTests: ((input: { planPath: string; checklist: CheckItem[]; tasks: TaskView[]; round: number }) => Promise<Awaited<ReturnType<typeof runCompletionAudit>>>) | null = null;
+let auditRunnerForTests: ((input: { planPath: string; checklist: CheckItem[]; tasks: TaskView[]; round: number; priorFindings: ReviewFinding[] }) => Promise<Awaited<ReturnType<typeof runCompletionAudit>>>) | null = null;
 
 export function __setAuditRunnerForTests(
-	runner: ((input: { planPath: string; checklist: CheckItem[]; tasks: TaskView[]; round: number }) => Promise<Awaited<ReturnType<typeof runCompletionAudit>>>) | null,
+	runner: ((input: { planPath: string; checklist: CheckItem[]; tasks: TaskView[]; round: number; priorFindings: ReviewFinding[] }) => Promise<Awaited<ReturnType<typeof runCompletionAudit>>>) | null,
 ): void {
 	auditRunnerForTests = runner;
 }
@@ -746,15 +801,17 @@ export function registerExecutionTurnHandlers(
 			maybeContinuationFollowUp(ctx);
 			return;
 		}
-		// Fully settled and still owed an audit: run it now. The audit's own
-		// pass/fail message drives the rest (pass completes the run; fail
-		// triggers a fix turn), so no extra continuation is requested here —
-		// pendingAudit() is false once paused, which bounds any loop.
+		// Fully settled and still owed a review: launch the round under the
+		// mode rule — tui/rpc detach (the settle returns NOW and the overlay
+		// carries progress); print/json await inline so runtime teardown cannot
+		// kill the child. The round's own outcome routing drives the rest.
 		latchAuditThisSettle();
-		await runAuditFlow(ctx);
+		const chain = launchReviewRound(ctx);
+		if (chain) await chain;
 	});
 	ext.on("session_shutdown", async (_event, ctx) => {
 		drainExecutionFlush(ctx);
+		abortInFlightReview();
 		execution = null;
 		executionRunId = null;
 		continuationRuntime = null;
@@ -795,20 +852,242 @@ export function registerExecutionTurnHandlers(
 		if (usage) recordExecutionTurn(ctx, usage);
 		if (getExecution() && pendingAudit() && !auditLatchOf(execution!).auditedThisSettle) {
 			latchAuditThisSettle();
-			await runAuditFlow(ctx);
+			const chain = launchReviewRound(ctx);
+			if (chain) await chain;
 		}
 		await onTurnEnd?.(ctx);
 	});
 }
 
-/** Audit flow: run the completion auditor, apply pass/rollback, and either
- *  complete the run, keep iterating (rollback), pause at the round cap
- *  (interactive), or stop at the cap (auto-approve/headless — D-022).
+/** ==== Execution-review loop (v0.8) ====
  *
- *  Fail-closed completion: a run completes only when EVERY pending check was
- *  affirmatively passed (or resolved skipped-pass); checks the auditor failed
- *  to report count as failed, never as silently passed. */
-async function runAuditFlow(ctx: ExtensionContext): Promise<void> {
+ *  When every task is terminal and checks are still owed, the run enters the
+ *  `verifying` status and a DETACHED read-only reviewer round runs in the
+ *  background (tui/rpc): the settle handler returns immediately and the
+ *  executor is truly idle while the overlay shows live progress. In print/json
+ *  modes the settle handler keeps AWAITING the round inline — runtime
+ *  teardown at settle would otherwise kill a detached child and swallow the
+ *  pause signal.
+ *
+ *  Budget: `audit.rounds` counts COMMITTED rounds only (pass, fail, or
+ *  undeterminable); discards and cancellations burn nothing. Undeterminable
+ *  rounds self-schedule the retry inside the loop (no wake). Two consecutive
+ *  fingerprint discards commit as an undeterminable round so the loop stays
+ *  bounded. Exhaustion pauses in EVERY mode (fail-closed) with an in-band
+ *  `pi-plans-review-paused` message; the ONLY fresh-budget surface is
+ *  /plans-execute — ordinary input and session restores never refill.
+ *
+ *  Lifecycle: each round owns a session-scoped AbortController (never
+ *  ctx.signal, which is turn-scoped), aborted from session_shutdown,
+ *  stopExecution, startExecution, and restoreFromSession. Outcomes are
+ *  guarded by execution identity (`execution !== owner` → silent discard).
+ *
+ *  Completion stays fail-closed AND never fail-open: a run completes only
+ *  when every pending check was affirmatively passed. */
+const REVIEW_CAP_PAUSE_PREFIX = "execution review exhausted";
+/** v0.7 protocol value — dual-matched for one release so checkpoints written
+ * by older builds keep their cap pause recognized on restore. */
+const LEGACY_AUDIT_CAP_PAUSE_PREFIX = "completion audit exhausted";
+
+function isReviewCapPause(reason: string | undefined | null): boolean {
+	if (!reason) return false;
+	return reason.startsWith(REVIEW_CAP_PAUSE_PREFIX) || reason.startsWith(LEGACY_AUDIT_CAP_PAUSE_PREFIX);
+}
+
+/** The currently-running (or self-scheduling) review chain; the sanctioned
+ * test seam awaits this. */
+let activeReviewChain: Promise<void> | null = null;
+
+function abortInFlightReview(): void {
+	const inFlight = execution?.review.inFlight;
+	if (inFlight) {
+		try {
+			inFlight.controller.abort();
+		} catch {
+			/* already aborted */
+		}
+		if (execution) execution.review.inFlight = null;
+	}
+	activeReviewChain = null;
+}
+
+/** v0.9: unresolved high-severity findings from the newest committed round.
+ * Presence in the newest round's report IS the unresolved set (stable ids:
+ * a problem is resolved only by no longer being reported). */
+function unresolvedHighFindings(ex: ExecState): ReviewFinding[] {
+	return ex.audit.findings.filter((f) => f.severity === "high");
+}
+
+/** v0.9: checkpoint records -> runtime findings. Invalid severities degrade to
+ * "malformed" (recorded, non-blocking) — the same never-fail posture as the
+ * report parser. */
+function toReviewFindings(records?: ReviewFindingRecord[]): ReviewFinding[] {
+	if (!records) return [];
+	return records.map((r) => {
+		const severity = (r.severity === "high" || r.severity === "medium" || r.severity === "low") ? r.severity : "malformed";
+		return { id: r.id, severity, taskIds: Array.isArray(r.taskIds) ? r.taskIds : [], proposedTask: r.proposedTask, note: r.note ?? "", evidence: r.evidence ?? "", raw: r.raw ?? "" };
+	});
+}
+
+/** v0.9: findings widen the owed predicate — an unresolved high finding keeps
+ * the review owed even when every check is done (the stranded-high path),
+ * mirroring how a failed check keeps it owed today. */
+function reviewOwed(ex: ExecState): boolean {
+	return allTasksTerminal(ex.tasks)
+		&& (auditableChecks(ex.items, ex.tasks).some((item) => !item.done) || unresolvedHighFindings(ex).length > 0);
+}
+
+function runDirOf(ctx: ExtensionContext): string | null {
+	const runId = executionRunId ?? resolveActiveRun(ctx.sessionManager, ctx.cwd)?.run_id ?? null;
+	return runId ? runDirPath(ctx.cwd, runId) : null;
+}
+
+function setRunStatusForReview(ctx: ExtensionContext, status: "verifying" | "executing"): void {
+	const runId = executionRunId ?? resolveActiveRun(ctx.sessionManager, ctx.cwd)?.run_id ?? null;
+	if (!runId) return;
+	try {
+		const current = getRun(ctx.cwd, runId)?.status;
+		if (current !== status && current !== "done" && current !== "abandoned") {
+			setRunStatus(ctx.cwd, runId, status);
+		}
+	} catch {
+		/* best-effort */
+	}
+}
+
+/** Round fingerprint (Q-fingerprint-scope): plan digest + git HEAD +
+ * covered-file mtimes. A change between round start and resolve means the
+ * reviewer judged a subject that no longer exists — discard and re-run. */
+function captureReviewFingerprint(ctx: ExtensionContext, ex: ExecState): string {
+	const parts: string[] = [];
+	try {
+		parts.push(createHash("sha256").update(fs.readFileSync(ex.planPath, "utf8")).digest("hex"));
+	} catch {
+		parts.push("plan-unreadable");
+	}
+	try {
+		parts.push(execSync("git rev-parse HEAD", { cwd: ctx.cwd, stdio: ["ignore", "pipe", "pipe"] }).toString().trim());
+	} catch {
+		parts.push("no-head");
+	}
+	const covered = new Set<string>();
+	for (const task of flattenTaskViews(ex.tasks)) {
+		for (const file of task.files ?? []) covered.add(file);
+	}
+	const mtimes: string[] = [];
+	for (const file of [...covered].sort()) {
+		try {
+			mtimes.push(`${file}:${fs.statSync(path.resolve(ctx.cwd, file)).mtimeMs}`);
+		} catch {
+			mtimes.push(`${file}:missing`);
+		}
+	}
+	parts.push(mtimes.join("|"));
+	return createHash("sha256").update(parts.join("\u0000")).digest("hex");
+}
+
+/** Round timeout: a committed round is minutes, never the 60-min subagent
+ * default — a hung child must surface as a spawn-failure round, not park the
+ * run in verifying for an hour (CF2-010). */
+const REVIEW_ROUND_TIMEOUT_MS = 20 * 60 * 1000;
+
+/** Reviewer-role pinning (Q-role-fallback): a CONFIRMED delegated role pins
+ * the spawn's model+thinking and labels the overlay with the role; an
+ * unconfirmed or current-session role inherits the session default with the
+ * "session default" label — a detached round NEVER opens the interactive
+ * first-use panel. */
+function reviewSpawnProfile(): { model?: string; thinkingLevel?: string; label: string } {
+	try {
+		const reviewer = loadGlobalConfig().config.reviewer;
+		if (reviewer.mode !== "current-session" && reviewerReady(reviewer)) {
+			const spawn = resolveReviewerSpawn(reviewer);
+			if (spawn.modelSelector) {
+				return { model: spawn.modelSelector, thinkingLevel: spawn.thinkingLevel ?? undefined, label: spawn.label };
+			}
+		}
+	} catch {
+		/* fall through to the session default */
+	}
+	return { label: "session default" };
+}
+
+/** Engine-held lane state for the in-flight round: the reopen path builds a
+ * fresh one-shot controller seeded from THIS object, so the accumulated
+ * transcript survives ESC + reopen (CF2-001 / Q-reopen-seed). */
+let reviewLane: RefineLaneState | null = null;
+let reviewOverlay: RefineOverlayController | null = null;
+let reviewModelLabel: string | undefined;
+
+function freshReviewLane(attempt: number): RefineLaneState {
+	return {
+		id: `review-round-${attempt}`,
+		label: `Execution review round ${attempt}`,
+		status: "queued",
+		phase: "queued",
+		detail: "",
+		transcript: [],
+		currentTurnIndex: 0,
+		scrollOffset: 0,
+		followTranscript: true,
+		viewportHeight: 1,
+	};
+}
+
+/** Fresh controller per round (the controller is one-shot: closed latch,
+ * overlayPromise bail, terminal-lane early return — reuse drops progress).
+ * A UI failure must NEVER kill the round itself — best-effort only. The
+ * overlay forwards unhandled keys so Ctrl+Shift+T keeps working while the
+ * review overlay holds focus (pi-tui has no key bubbling). */
+function openReviewOverlay(ctx: ExtensionContext, lane: RefineLaneState, lang: "en" | "zh" | undefined, modelLabel: string): RefineOverlayController | null {
+	if (ctx.mode !== "tui" || ctx.hasUI !== true) return null;
+	try {
+		const controller = new RefineOverlayController(
+			"auditor",
+			[{ id: lane.id, label: lane.label }],
+			() => {},
+			lang ?? "en",
+			(data) => {
+				if (matchesTerminalKey(data, "ctrl+shift+t")) toggleDashboardExpanded(ctx);
+			},
+		);
+		controller.seedLane(lane);
+		controller.open(refineOverlayContext(ctx), modelLabel);
+		return controller;
+	} catch {
+		return null;
+	}
+}
+
+/** The reopen surface (Task-3.4): rebuilds the overlay from engine-held lane
+ * state; inert when no round is in flight. */
+export function reopenReviewOverlay(ctx: ExtensionContext): void {
+	if (!execution?.review.inFlight || !reviewLane) return;
+	// Never stack a second overlay on a live one (Ctrl+Shift+R while open).
+	if (reviewOverlay && !reviewOverlay.isClosed()) return;
+	const controller = openReviewOverlay(ctx, reviewLane, execution.uiLanguage, reviewModelLabel ?? "session default");
+	if (controller) reviewOverlay = controller;
+}
+
+function pauseReviewCap(ctx: ExtensionContext, ex: ExecState): void {
+	const highs = unresolvedHighFindings(ex);
+	const detail =
+		ex.audit.failed.length > 0
+			? `failed: ${ex.audit.failed.join(", ")}${highs.length > 0 ? `; high findings: ${highs.map((f) => f.id).join(", ")}` : ""}`
+			: highs.length > 0
+				? `high findings: ${highs.map((f) => f.id).join(", ")}`
+				: `unreadable verdicts: ${ex.audit.undeterminable.join(", ") || "unknown"}`;
+	const reason = `${REVIEW_CAP_PAUSE_PREFIX} ${REVIEW_MAX_ROUNDS} rounds (${detail}). Only /plans-execute — an explicit user confirmation — grants a fresh five-round budget; ordinary messages and session restores do not. (Or close the failed checks' tasks as skipped to pass them as skipped-pass.)`;
+	pauseForStall(ctx, reason);
+	// In-band, headless-visible pause signal (the pi-plans-exec-stop pattern):
+	// pauseForStall's ui.notify is optional and absent headless, so the pause
+	// must also land in the session stream every mode can read.
+	messaging().sendMessage(
+		{ customType: "pi-plans-review-paused", content: `**pi-plans: ${reason}**`, display: true },
+		{ triggerTurn: false },
+	);
+}
+
+async function startReviewRound(ctx: ExtensionContext): Promise<void> {
 	if (!execution) return;
 	const ex = execution;
 	// Skipped-pass checks resolve without a subagent round.
@@ -819,99 +1098,451 @@ async function runAuditFlow(ctx: ExtensionContext): Promise<void> {
 	// Only auditable checks (with task coverage) gate completion; checks that
 	// cover no task can never be verified and never block or complete.
 	const pendingChecks = auditableChecks(ex.items, ex.tasks).filter((item) => !item.done);
-	if (pendingChecks.length === 0) {
+	// v0.9: unresolved high findings block the fast completion path — they
+	// keep the review owed instead (liveness: a high can never be completed
+	// around, only fixed or paused at the cap).
+	if (pendingChecks.length === 0 && unresolvedHighFindings(ex).length === 0) {
 		await completeExecution(ctx);
 		return;
 	}
-	if (ex.audit.rounds >= AUDIT_MAX_ROUNDS) {
-		// D-022: interactive sessions pause for the user (state kept, tasks
-		// intact, resumable); auto-approve/headless terminates bounded.
-		if (isInteractiveSession(ctx)) {
-			pauseForStall(
-				ctx,
-				`${AUDIT_CAP_PAUSE_PREFIX} ${AUDIT_MAX_ROUNDS} rounds (failed: ${ex.audit.failed.join(", ") || "unknown"}); review the audit reports and fix the failures, then resume with any message or /plans-execute — resuming grants a fresh three-round audit budget (or close the failed checks' tasks as skipped to pass them as skipped-pass)`,
-			);
-			return;
-		}
-		await stopExecution(ctx, `completion audit exhausted ${AUDIT_MAX_ROUNDS} rounds (failed: ${ex.audit.failed.join(", ") || "unknown"})`);
+	if (ex.stall.paused || ex.review.inFlight) return;
+	if (ex.audit.rounds >= REVIEW_MAX_ROUNDS) {
+		pauseReviewCap(ctx, ex);
 		return;
 	}
-	ex.audit.running = true;
-	ex.audit.rounds += 1;
+	// Phase transition: the executor is done with its tasks; the review loop
+	// owns the run until it converges (or pauses at the cap).
+	setRunStatusForReview(ctx, "verifying");
+	const round: InFlightReview = {
+		controller: new AbortController(),
+		budgetRound: ex.audit.rounds + 1,
+		attempt: ex.review.attempts + 1,
+		fingerprint: captureReviewFingerprint(ctx, ex),
+		wakeSent: false,
+	};
+	ex.review.attempts = round.attempt;
+	ex.review.inFlight = round;
+	ex.audit.running = true; // dashboard mirror (the v0.8 model lands with the overlay task)
+	const spawn = reviewSpawnProfile();
+	reviewModelLabel = spawn.label;
+	const lane = freshReviewLane(round.attempt);
+	reviewLane = lane;
+	reviewOverlay = openReviewOverlay(ctx, lane, ex.uiLanguage, spawn.label);
 	updateStatusWidget(ctx);
-	let outcome = null as Awaited<ReturnType<typeof runCompletionAudit>>;
+	let result: AuditRoundResult;
 	try {
-		outcome = auditRunnerForTests
-			? await auditRunnerForTests({ planPath: ex.planPath, checklist: ex.items, tasks: ex.tasks, round: ex.audit.rounds })
+		result = auditRunnerForTests
+			? await auditRunnerForTests({ planPath: ex.planPath, checklist: ex.items, tasks: ex.tasks, round: round.attempt, priorFindings: ex.audit.findings })
 			: await runCompletionAudit(ctx, {
 				planPath: ex.planPath,
 				checklist: ex.items,
 				tasks: ex.tasks,
-				round: ex.audit.rounds,
-				signal: ctx.signal,
+				round: round.attempt,
+				priorFindings: ex.audit.findings,
+				model: spawn.model,
+				thinkingLevel: spawn.thinkingLevel,
+				timeoutMs: REVIEW_ROUND_TIMEOUT_MS,
+				signal: round.controller.signal,
+				onProgress: (event) => {
+					// The engine owns the lane state; the live controller only repaints.
+					applyRefineProgress(lane, event);
+					reviewOverlay?.rerender();
+				},
+			});
+	} catch (error) {
+		if (ex.review.inFlight === round) {
+			ex.review.inFlight = null;
+			ex.audit.running = false;
+		}
+		void reviewOverlay?.close();
+		reviewOverlay = null;
+		messaging().sendMessage(
+			{ customType: "pi-plans-review-error", content: `pi-plans: execution review round threw: ${String(error)}`, display: true },
+			{ triggerTurn: false },
+		);
+		updateStatusWidget(ctx);
+		return;
+	}
+	// Overlay terminal state + close (the controller is one-shot; the engine-held
+	// lane keeps the transcript for a later reopen within this round).
+	const cancelledResult = result !== null && typeof result === "object" && "cancelled" in result;
+	try {
+		applyRefineResult(lane, {
+			ok: !cancelledResult,
+			output: result && "report" in result ? result.report : "",
+			stderr: "",
+			turns: 0,
+			...(cancelledResult ? { cancelled: true as const } : {}),
+		});
+	} catch {
+		/* cosmetic only */
+	}
+	void reviewOverlay?.close();
+	reviewOverlay = null;
+	await handleReviewOutcome(ctx, ex, round, result, pendingChecks.map((item) => item.id));
+}
+
+async function handleReviewOutcome(
+	ctx: ExtensionContext,
+	owner: ExecState,
+	round: InFlightReview,
+	result: AuditRoundResult,
+	pendingIds: string[],
+): Promise<void> {
+	// Identity guard: a restore, stop, or fresh handoff replaced the run —
+	// drop this outcome silently (CF2-002).
+	if (execution !== owner) return;
+	if (owner.review.inFlight !== round) return;
+	owner.review.inFlight = null;
+	owner.audit.running = false;
+	if (result !== null && typeof result === "object" && "cancelled" in result) {
+		// Aborted by shutdown/stop/restore/tree-switch: no round, no budget, no wake.
+		updateStatusWidget(ctx);
+		return;
+	}
+	const outcome = result;
+	const reportText = outcome?.report ?? "(review subagent failed to run)";
+	const fingerprintNow = captureReviewFingerprint(ctx, owner);
+	const coveredTaskIds = flattenTaskViews(owner.tasks).map((task) => task.id);
+	if (fingerprintNow !== round.fingerprint) {
+		// The audited subject moved under the reviewer (Q-C): discard, re-run
+		// without budget burn; two consecutive discards commit as undeterminable
+		// so a mutating user cannot loop the loop for free (Q-discard-bound).
+		owner.review.consecutiveDiscards += 1;
+		const runDir = runDirOf(ctx);
+		if (runDir) {
+			writeReviewRoundReport(runDir, {
+				budgetRound: round.budgetRound,
+				attempt: round.attempt,
+				outcome: "discarded",
+				passed: [],
+				failed: [],
+				undeterminable: pendingIds,
+				// v0.9.1 (F-014): the discard report must not understate a
+				// round whose embedded report carries highs.
+				findings: owner.audit.findings,
+				discardedReason: "fingerprint changed between round start and resolve (worktree/plan moved under the reviewer)",
+				fingerprintCaptured: round.fingerprint,
+				fingerprintFound: fingerprintNow,
+				coveredTaskIds,
+				report: reportText,
+			});
+		}
+		if (owner.review.consecutiveDiscards >= 2) {
+			owner.review.consecutiveDiscards = 0;
+			await commitReviewOutcome(
+				ctx,
+				owner,
+				round,
+				{ passed: [], failed: [], undeterminable: pendingIds, report: `(two consecutive fingerprint discards — committed as an undeterminable round)\n\n${reportText}` },
+				pendingIds,
+			);
+			return;
+		}
+		persist(ctx);
+		updateStatusWidget(ctx);
+		await maybeContinueReview(ctx, owner);
+		return;
+	}
+	owner.review.consecutiveDiscards = 0;
+	await commitReviewOutcome(ctx, owner, round, outcome, pendingIds);
+}
+
+/** v0.9 (findings-driven fix loop): append plan tasks for high findings no
+ * existing task owns. The reviewer stays read-only — it proposes the title
+ * (proposed-task); this machinery applies it with provenance, so every high
+ * finding always has an owner the executor can close, and the stable F-###
+ * id rides in the task title for traceability. Best-effort: an unwritable
+ * plan must not crash the loop (the finding then stays stranded and the cap
+ * pause surfaces it). Returns the appended task ids. */
+function appendFindingTasks(ex: ExecState, highs: ReviewFinding[]): string[] {
+	const appended: string[] = [];
+	let next = flattenTaskViews(ex.tasks).reduce((max, t) => {
+		const m = /^Task-(\d+)$/.exec(t.id);
+		return m ? Math.max(max, Number(m[1])) : max;
+	}, 0);
+	const wave = maxWave(ex.tasks) + 1;
+	try {
+		const planText = fs.readFileSync(ex.planPath, "utf8");
+		const lines = planText.split("\n");
+		// Insert inside the Tasks section: before the Execution Waves
+		// subsection when present, else before the FIRST checklist header the
+		// plan uses (v0.9.1 F-013: legacy plans say `## Verifier Checklist`,
+		// and an EOF fallback would land outside every parsed section), else
+		// at EOF; walk back over blank separators so the bullet lands
+		// adjacent to its siblings.
+		let insertAt = lines.length;
+		const wavesIdx = lines.findIndex((l) => /^###\s+Execution Waves/.test(l));
+		const checklistIdx = lines.findIndex((l) => CHECKLIST_HEADERS.some((h) => new RegExp(`^##\\s+${h}`).test(l)));
+		if (wavesIdx !== -1) insertAt = wavesIdx;
+		else if (checklistIdx !== -1) insertAt = checklistIdx;
+		while (insertAt > 0 && lines[insertAt - 1].trim() === "") insertAt--;
+		// v0.9.1 (F-012): reviewer text becomes task-title metadata at parse
+		// time — strip the microsyntax metacharacters (em/en dashes, `--`
+		// separators, the `;` field delimiter) so an embedded token can never
+		// split title from tail or forge fields.
+		const sanitize = (text: string): string => text.replace(/[—–]/g, "-").replace(/-{2,}/g, "-").replace(/;/g, ",");
+		const entries: Array<{ id: string; title: string }> = [];
+		const newLines: string[] = [];
+		for (const h of highs) {
+			next += 1;
+			const id = `Task-${next}`;
+			const title = `fix ${h.id}: ${sanitize(h.proposedTask ?? h.note ?? "address the finding")} (appended by execution review round ${ex.audit.rounds})`;
+			// v0.9.1 (F-006): carry the wave in the bullet tail so a re-parse
+			// restores the same wave the live tree assigned — without it the
+			// appended remediation task fell back to wave 1 on restore and
+			// hijacked the ▸ anchor.
+			newLines.push(`- \`${id}\`: ${title} — wave: ${wave}`);
+			entries.push({ id, title });
+		}
+		lines.splice(insertAt, 0, ...newLines);
+		fs.writeFileSync(ex.planPath, lines.join("\n"), "utf8");
+		// v0.9.1 (F-008): only a successful plan write mints the live tasks —
+		// pushing before the write left checkpoint entries the plan file does
+		// not contain whenever the write failed.
+		for (const entry of entries) {
+			ex.tasks.push({ id: entry.id, title: entry.title, wave, deps: [], files: [], status: "pending", children: [] });
+			appended.push(entry.id);
+		}
+	} catch {
+		/* best-effort: stranded highs surface via the cap pause */
+	}
+	return appended;
+}
+
+async function commitReviewOutcome(
+	ctx: ExtensionContext,
+	ex: ExecState,
+	round: InFlightReview,
+	outcome: AuditOutcome | null,
+	pendingIds: string[],
+): Promise<void> {
+	// The budget is charged only when an outcome commits — never on discard
+	// or cancellation (CF2-003).
+	ex.audit.rounds = round.budgetRound;
+	const passed = pendingIds.filter((id) => (outcome?.passed ?? []).includes(id));
+	const failed = pendingIds.filter((id) => (outcome?.failed ?? []).includes(id));
+	// Anything the round neither passed nor failed is undeterminable: the
+	// report omitted the check, spelled the verdict unreadably, or the
+	// subagent never ran.
+	const undeterminable = pendingIds.filter((id) => !passed.includes(id) && !failed.includes(id));
+	// v0.9: the newest round's reported findings ARE the unresolved set
+	// (stable ids — a problem is resolved only by no longer being reported).
+	// v0.9.1 (F-001): only a REAL parsed report is authoritative. A round that
+	// produced no report at all — spawn failure (outcome === null) or the
+	// two-consecutive-discard synthesis — must PRESERVE the unresolved set:
+	// clearing it let the vacuous completion guard (empty pendingIds) mark a
+	// run done with its high finding silently dropped.
+	const reported = outcome !== null && outcome.findings !== undefined;
+	const findings = reported ? outcome.findings : ex.audit.findings;
+	ex.audit.findings = findings;
+	const highs = findings.filter((f) => f.severity === "high");
+	// Findings are actionable only when this round actually reported them;
+	// see the fix-loop branch below (v0.9.1, F-001).
+	const actionableHighs = reported ? highs : [];
+	const coveredTaskIds = flattenTaskViews(ex.tasks).map((task) => task.id);
+	const reportText = outcome?.report ?? "(review subagent failed to run)";
+	let reportPath: string | null = null;
+	{
+		const runDir = runDirOf(ctx);
+		if (runDir) {
+			reportPath = writeReviewRoundReport(runDir, {
+				budgetRound: round.budgetRound,
+				attempt: round.attempt,
+				outcome: outcome === null
+					? "spawn-failed"
+					: failed.length > 0 || actionableHighs.length > 0
+						? "failed"
+						: undeterminable.length > 0 ? "undeterminable" : "passed",
+				passed,
+				failed,
+				undeterminable,
+				findings,
+				fingerprintCaptured: round.fingerprint,
+				coveredTaskIds,
+				report: reportText,
+			});
+		}
+	}
+	// Partial progress counts: a check affirmed this round is done even when
+	// a sibling failed, so a later round only re-judges what is still open.
+	for (const id of passed) {
+		const item = ex.items.find((candidate) => candidate.id === id);
+		if (item) item.done = true;
+	}
+
+	// v0.9 fix loop — evaluated BEFORE the completion branch so an unresolved
+	// high finding can never complete the run (liveness). Failed checks and
+	// high findings drive ONE union rollback and exactly one executor wake;
+	// high wins over the undeterminable self-schedule (a finding is
+	// actionable independent of verdict evidence). v0.9.1 (F-001): verdicts
+	// are authoritative whenever a report exists, but the FINDINGS-driven
+	// half of the branch needs a findings-bearing report — a no-findings
+	// round (spawn failure, discard synthesis, legacy shape) preserves the
+	// unresolved set and self-schedules instead of rolling back on it.
+	if (failed.length > 0 || actionableHighs.length > 0) {
+		ex.audit.failed = failed;
+		ex.audit.undeterminable = undeterminable;
+		const rolledBack: string[] = [];
+		for (const id of failed) {
+			rolledBack.push(...auditRollbackSet(ex.tasks, ex.items, id));
+		}
+		// Invalidation is the VC-fail invariant ONLY: a check re-verifies its
+		// reopened tasks when a FAILED check rolled them back. A pure
+		// finding-driven rollback keeps earlier passes — the findings channel
+		// itself re-examines the repaired work next round (stable ids).
+		if (rolledBack.length > 0) invalidateChecksForRolledBackTasks(ex.items, ex.tasks, rolledBack);
+		const knownIds = new Set(coveredTaskIds);
+		const mappedHighIds = [...new Set(actionableHighs.flatMap((h) => h.taskIds).filter((id) => knownIds.has(id)))];
+		const highRolledBack = findingsRollbackSet(ex.tasks, mappedHighIds);
+		const unmappedHighs = actionableHighs.filter((h) => !h.taskIds.some((id) => knownIds.has(id)));
+		const amended = unmappedHighs.length > 0 ? appendFindingTasks(ex, unmappedHighs) : [];
+		const allRolledBack = [...new Set([...rolledBack, ...highRolledBack])];
+		withExecutionCheckpoint(ctx, (cp) => {
+			// v0.9.1 (F-002): appending finding tasks rewrote the approved plan;
+			// re-stamp the checkpoint's plan identity in the same revision so a
+			// later /resume-plans accepts the amended plan instead of rejecting
+			// it as plan-mismatch (which would cost a full re-approval).
+			const amendedCp = amended.length > 0
+				? applyExecutionPlanAmended(cp, planIdentityOf(ex.planPath, cp.plan?.version ?? 1), ex.audit.rounds)
+				: cp;
+			return applyExecutionProgress(amendedCp, {
+				tasks: taskProgressMap(ex.tasks),
+				doneVcIds: ex.items.filter((item) => item.done).map((item) => item.id),
+				audit: { rounds: ex.audit.rounds, lastResult: failed.join(",") || `highs: ${actionableHighs.map((h) => h.id).join(",")}`, findings },
 			});
-	} finally {
-		ex.audit.running = false;
-	}
-	// Fail-closed: checks the outcome did not affirmatively pass are failed.
-	const reportedPass = new Set(outcome?.passed ?? []);
-	const failed = pendingChecks
-		.map((item) => item.id)
-		.filter((id) => !reportedPass.has(id));
-	if (failed.length === 0) {
+		});
+		if (allRolledBack.length > 0 || amended.length > 0) {
+			// Rolling back (or appending) is itself forward progress for the
+			// watchdog, but NOT for audit.rounds: that counter stays monotonic
+			// so the repair loop is bounded. The repair belongs to the
+			// executor — back to executing.
+			ex.stall.rounds = 0;
+			ex.stall.lastSnapshot = stallSnapshot();
+			setRunStatusForReview(ctx, "executing");
+		}
+		persist(ctx);
+		updateStatusWidget(ctx);
+		// v0.8 wake, generalized (v0.9): per-round one-shot token — exactly one
+		// triggerTurn per committed fix-needing outcome, even when the round
+		// resolves long after the settle that spawned it.
+		if (!round.wakeSent) {
+			round.wakeSent = true;
+			const openTasks = flattenTaskViews(ex.tasks)
+				.filter((task) => !taskIsTerminal(task))
+				.map((task) => task.id);
+			const stranded = allRolledBack.length === 0 && amended.length === 0;
+			const highLines = actionableHighs.map((h) => `- ${h.id}${h.taskIds.length ? ` (${h.taskIds.join(", ")})` : ""}: ${h.note}`).join("\n");
+			const reportRef = reportPath
+				? `Full round report: ${reportPath}`
+				: `Full round report (run dir unwritable — inline):\n\n---\n${reportText.slice(0, 4000)}`;
+			// v0.9.1 (F-004): a pure VC-fail round keeps the v0.8 lead — never
+			// announce "0 high-severity findings" over an empty block.
+			const findingsLead = actionableHighs.length > 0
+				? `**pi-plans: execution review round ${ex.audit.rounds} found ${actionableHighs.length} high-severity finding(s)**${failed.length > 0 ? ` and failed checks: ${failed.join(", ")}` : ""}.`
+				: `**pi-plans: execution review round ${ex.audit.rounds} failed** — checks: ${failed.join(", ")}.`;
+			const findingsBlock = actionableHighs.length > 0 ? `\n\nHigh findings:\n${highLines}` : "";
+			const content = `${findingsLead} Rolled back tasks: ${allRolledBack.join(", ") || "(none covered)"}${amended.length > 0 ? `. Tasks appended to the plan for unmapped findings: ${amended.join(", ")}` : ""}.${findingsBlock}\n\nFix them and re-close the affected tasks with \`plans_update_task\`; the review reruns automatically once all tasks are terminal again.${ex.audit.rounds >= REVIEW_MAX_ROUNDS ? ` This was round ${REVIEW_MAX_ROUNDS} of ${REVIEW_MAX_ROUNDS}: the next terminal-task cycle pauses the run for review.` : ""}${stranded ? ` No task covers the finding(s) and none could be appended — the task tree stayed terminal; the next settle re-runs the review automatically.` : ""}\n\n${reportRef}`;
+			messaging().sendMessage(
+				{
+					customType: "pi-plans-audit-failed",
+					content: `${content}\n\nStill open: ${openTasks.join(", ") || "(none — the tree is terminal)"}`,
+					display: true,
+				},
+				{ triggerTurn: true },
+			);
+		}
+		return; // The agent repairs; the next settle re-enters the loop.
+	}
+
+	// Fail-closed completion: every pending check affirmatively passed AND no
+	// high finding remains. The highs guard is explicit (v0.9.1, F-001): a
+	// no-report round skips the fix branch above, so this is the last line
+	// against vacuously completing an empty-pendingIds round with an
+	// unresolved high. An all-undeterminable round yields failed === [] —
+	// completing here would be fail-open, marking a run done with nothing
+	// verified.
+	if (passed.length === pendingIds.length && highs.length === 0) {
 		ex.audit.failed = [];
+		ex.audit.undeterminable = [];
 		withExecutionCheckpoint(ctx, (cp) =>
 			applyExecutionProgress(cp, {
 				tasks: taskProgressMap(ex.tasks),
 				doneVcIds: ex.items.filter((item) => item.done).map((item) => item.id),
-				audit: { rounds: ex.audit.rounds, passed: true },
+				audit: { rounds: ex.audit.rounds, passed: true, findings },
 			}),
 		);
 		await completeExecution(ctx);
 		return;
 	}
-	// Failed checks: roll their covered tasks back (always — an unreported or
-	// infra-failed audit must reopen work so the loop can continue) and
-	// persist progress including checks that passed earlier rounds.
-	for (const id of failed) {
-		const item = ex.items.find((candidate) => candidate.id === id);
-		if (item) item.done = false;
-	}
+
+	// Undeterminable-only round: the loop self-schedules the retry (Q-B) — no
+	// wake, no message; the dashboard/overlay carries the round counter.
 	ex.audit.failed = failed;
-	const rolledBack: string[] = [];
-	for (const id of failed) {
-		rolledBack.push(...auditRollbackSet(ex.tasks, ex.items, id));
-	}
+	ex.audit.undeterminable = undeterminable;
 	withExecutionCheckpoint(ctx, (cp) =>
 		applyExecutionProgress(cp, {
 			tasks: taskProgressMap(ex.tasks),
 			doneVcIds: ex.items.filter((item) => item.done).map((item) => item.id),
-			audit: { rounds: ex.audit.rounds, lastResult: failed.join(",") },
+			audit: { rounds: ex.audit.rounds, lastResult: failed.join(",") || undefined, findings },
 		}),
 	);
-	ex.stall.rounds = 0;
-	ex.stall.lastSnapshot = stallSnapshot();
 	persist(ctx);
 	updateStatusWidget(ctx);
-	const report = outcome?.report ?? "(audit subagent failed to run)";
-	// v0.7.1: the failure notification now wakes the agent so it can fix the
-	// rolled-back work without the user having to poke the run (root cause of
-	// the observed stall). The wake is the ONLY turn this settle emits — the
-	// rollback below also marks the runtime handled so the continuation path
-	// cannot add a second EXECUTION_CONTINUE wake for the same settle (Q-2).
-	const stranded = rolledBack.length === 0;
-	messaging().sendMessage(
-		{
-			customType: "pi-plans-audit-failed",
-			content: `**pi-plans: completion audit round ${ex.audit.rounds} failed** — checks: ${failed.join(", ")}. Rolled back tasks: ${rolledBack.join(", ") || "(none covered)"}. Fix the failures and re-close the rolled-back tasks with \`plans_update_task\`; the audit reruns automatically once all tasks are terminal again.${ex.audit.rounds >= AUDIT_MAX_ROUNDS ? ` This was round ${AUDIT_MAX_ROUNDS} of ${AUDIT_MAX_ROUNDS}: interactive sessions pause for review; the next terminal-task cycle stops or pauses the run.` : ""}${stranded ? ` No task covers the failed check(s), so the task tree stayed terminal — the next settle re-runs the audit automatically.` : ""}\n\n---\n${report.slice(0, 4000)}`,
-			display: true,
-		},
-		{ triggerTurn: true },
-	);
-	// Q-2 (single wake): this message owns the settle's only turn. Mark the
-	// runtime handled so maybeContinuationFollowUp stays silent.
-	const runtime = currentContinuationRuntime(ctx);
-	if (runtime) runtime.handled = true;
+	await maybeContinueReview(ctx, ex);
+}
+
+async function maybeContinueReview(ctx: ExtensionContext, ex: ExecState): Promise<void> {
+	if (execution !== ex) return;
+	if (!reviewOwed(ex)) return;
+	if (ex.stall.paused) return;
+	if (ex.audit.rounds >= REVIEW_MAX_ROUNDS) {
+		pauseReviewCap(ctx, ex);
+		return;
+	}
+	await startReviewRound(ctx);
+}
+
+/** Launch a review round under the mode rule: detached (fire-and-forget with
+ *  the chain tracked for the test seam) in tui/rpc; awaited inline otherwise
+ *  (print/json settle must hold the runtime open through the round). Returns
+ *  the chain when the caller must await it, null when detached. */
+function launchReviewRound(ctx: ExtensionContext): Promise<void> | null {
+	const detach = ctx.mode === "tui" || ctx.mode === "rpc";
+	const chain = (async () => {
+		await startReviewRound(ctx);
+	})();
+	activeReviewChain = chain;
+	if (detach) {
+		chain.catch(() => {
+			/* surfaced via the review messages */
+		});
+		return null;
+	}
+	return chain;
+}
+
+/** Deterministic seam: await the in-flight (or self-scheduling) review chain. */
+export function __awaitReviewRoundForTests(): Promise<void> {
+	return activeReviewChain ?? Promise.resolve();
+}
+
+/** When this module graph was first imported into the running pi process.
+ * pi loads extensions once, so a fix written to disk mid-session stays
+ * invisible until /reload — which is exactly why an unreadable audit verdict
+ * deserves a /reload hint rather than a bare retry. */
+const extensionModuleLoadedAt = new Date();
+
+/** The /reload advice when the extension on disk is newer than the copy this
+ * process loaded, else null. Shared with /plans via src/staleness.ts so both
+ * report the same answer from one probe. */
+function staleReloadHint(): string | null {
+	try {
+		const root = path.dirname(path.dirname(new URL(import.meta.url).pathname));
+		return probeStaleReload(root, extensionModuleLoadedAt);
+	} catch {
+		return null;
+	}
 }
 
 /** True when the session can surface a pause to a human (D-022): interactive
@@ -931,7 +1562,7 @@ function activeVccSettings(ctx: ExtensionContext, phase: PiPlansCompactionPhase)
 	const run = getRun(ctx.cwd, active.run_id);
 	if (!run) return null;
 	if (phase === "planning" && run.status !== "planning") return null;
-	if (phase === "execution" && run.status !== "executing") return null;
+	if (phase === "execution" && run.status !== "executing" && run.status !== "verifying") return null;
 	scaffoldVccSettings(stateRoot);
 	return { settings: loadVccSettings(stateRoot), runId: run.run_id, artifactDir: run.artifact_dir };
 }
@@ -1392,6 +2023,9 @@ export function filterPlanningResumeMessages<T extends { customType?: string }>(
 
 export async function stopExecution(ctx: ExtensionContext, reason: string): Promise<void> {
 	if (!execution) return;
+	// A stopped run's in-flight review round dies with it (typed cancelled —
+	// no budget, no wake).
+	abortInFlightReview();
 	resetExecutionCompactionState(ctx);
 	pendingExecutionFlush = false;
 	persist(ctx);
@@ -1437,7 +2071,7 @@ function stallSnapshot(): string {
 }
 
 /**
- * v0.7.1: shared "the completion audit is owed" predicate. Every entry point
+ * v0.7.1: shared "the execution review is owed" predicate. Every entry point
  * that can start the audit (turn_end, agent_before_settle, restoreFromSession,
  * the resume path) goes through this so they can never disagree.
  *
@@ -1446,12 +2080,13 @@ function stallSnapshot(): string {
  */
 function pendingAudit(ex: ExecState | null = execution): ex is ExecState {
 	if (!ex) return false;
-	// A paused run is never self-driven: the stall / audit-cap pause is an
+	// A paused run is never self-driven: the stall / review-cap pause is an
 	// explicit "hand control back" signal, and resuming it is the user's call.
 	// This also bounds the zero-input continue loop in agent_before_settle.
 	if (ex.stall.paused) return false;
-	if (ex.audit.running) return false;
-	return allTasksTerminal(ex.tasks) && auditableChecks(ex.items, ex.tasks).some((item) => !item.done);
+	if (ex.review.inFlight) return false;
+	return allTasksTerminal(ex.tasks)
+		&& (auditableChecks(ex.items, ex.tasks).some((item) => !item.done) || unresolvedHighFindings(ex).length > 0);
 }
 
 /** v0.7.1: record that this settle already ran (or declined) its audit, so a
@@ -1564,48 +2199,78 @@ export function filterContinuationMessages<T extends { customType?: string; deta
 	return filterGoalWaitMessages(messages);
 }
 
-/** Prefix of the stall reason used for the audit-cap pause (D-022). */
-const AUDIT_CAP_PAUSE_PREFIX = "completion audit exhausted";
-
 /** Called for genuine user input or an explicit same-execution resume.
- * Resuming an audit-cap pause grants a fresh audit budget (three more
- * rounds): the user's explicit resume IS the decision to keep auditing —
- * without this reset the cap pause could never be lifted productively. */
+ * v0.8: a REVIEW-CAP pause is never lifted here — ordinary input must not
+ * refill the five-round budget (CF2-004); only /plans-execute
+ * (resumeActiveExecution) is the explicit confirmation surface. Genuine
+ * stall pauses still clear on input as before. */
 export function resumeGoalWaitIfPaused(ctx: ExtensionContext): boolean {
 	const ex = getExecution();
 	if (!ex?.stall.paused || !currentContinuationRuntime(ctx)) return false;
-	const wasAuditCap = (ex.stall.pausedReason ?? "").startsWith(AUDIT_CAP_PAUSE_PREFIX);
+	if (isReviewCapPause(ex.stall.pausedReason)) {
+		// Surfaced once per input so the user is not left guessing why the run
+		// stays paused; the pause itself and the budget survive untouched.
+		ctx.ui.notify?.(
+			"pi-plans: the review-round budget is exhausted — run /plans-execute to grant a fresh five-round budget (that confirmation is the only surface that does).",
+			"warning",
+		);
+		return false;
+	}
 	ex.stall.paused = false;
 	ex.stall.pausedReason = undefined;
 	ex.stall.rounds = 0;
 	ex.stall.lastSnapshot = stallSnapshot();
-	if (wasAuditCap) {
-		ex.audit.rounds = 0;
-		ex.audit.failed = [];
-		withExecutionCheckpoint(ctx, (cp) =>
-			applyExecutionProgress(cp, {
-				tasks: taskProgressMap(ex.tasks),
-				audit: { rounds: 0, lastResult: undefined },
-				pausedReason: null,
-			}),
-		);
-	} else {
-		withExecutionCheckpoint(ctx, (cp) => applyExecutionProgress(cp, { pausedReason: null }));
-	}
+	withExecutionCheckpoint(ctx, (cp) => applyExecutionProgress(cp, { pausedReason: null }));
 	persist(ctx);
 	updateStatusWidget(ctx);
 	return true;
 }
 
 export function resumeActiveExecution(ctx: ExtensionContext): boolean {
+	// v0.8: /plans-execute is THE explicit confirmation surface for a
+	// review-cap pause — the only place a fresh five-round budget is granted
+	// (Q-confirm-surface). Ordinary input and session restores never refill.
+	const pausedEx = getExecution();
+	if (pausedEx?.stall.paused && isReviewCapPause(pausedEx.stall.pausedReason)) {
+		pausedEx.stall.paused = false;
+		pausedEx.stall.pausedReason = undefined;
+		pausedEx.stall.rounds = 0;
+		pausedEx.stall.lastSnapshot = stallSnapshot();
+		pausedEx.audit.rounds = 0;
+		pausedEx.audit.failed = [];
+		pausedEx.audit.undeterminable = [];
+		// v0.9: the fresh budget inherits unresolved findings (stable ids keep
+		// counting) — only the round counter resets.
+		withExecutionCheckpoint(ctx, (cp) =>
+			applyExecutionProgress(cp, {
+				tasks: taskProgressMap(pausedEx.tasks),
+				audit: { rounds: 0, lastResult: undefined, findings: pausedEx.audit.findings },
+				pausedReason: null,
+			}),
+		);
+		persist(ctx);
+		updateStatusWidget(ctx);
+		messaging().sendMessage(
+			{
+				customType: "pi-plans-review-budget-granted",
+				content: "**pi-plans: fresh five-round review budget granted** — the execution review resumes now.",
+				display: true,
+			},
+			{ triggerTurn: false },
+		);
+		const grantChain = launchReviewRound(ctx);
+		if (grantChain) void grantChain.catch(() => { /* surfaced via the review messages */ });
+		return true;
+	}
 	// v0.7.1 (root cause A): a terminal-but-unaudited run used to fall through
 	// to `return false` here, so `/plans-execute` answered "already executing"
 	// and the run stayed stranded until a full re-entry or a session restore.
 	// It is not paused, so the pause path below cannot see it — check it first
-	// and run the owed audit instead of reporting "nothing to resume".
+	// and run the owed review instead of reporting "nothing to resume".
 	if (!execution?.stall.paused && pendingAudit()) {
 		latchAuditThisSettle();
-		void runAuditFlow(ctx).catch(() => { /* surfaced via the audit message */ });
+		const chain = launchReviewRound(ctx);
+		if (chain) void chain.catch(() => { /* surfaced via the review messages */ });
 		return true;
 	}
 	if (!resumeGoalWaitIfPaused(ctx)) return false;
@@ -1626,6 +2291,12 @@ export async function completeExecution(ctx: ExtensionContext): Promise<void> {
 	const summary = flat
 		.map((task) => `- ${taskIsTerminal(task) && task.status === "skipped" ? "~" : "✓"} \`${task.id}\` ${task.title}`)
 		.join("\n");
+	// v0.9: residual (non-high) findings are summarized, never silent — the
+	// loop converged because nothing high-blocking remained.
+	const residualFindings = execution.audit.findings.filter((f) => f.severity !== "high");
+	const residualNote = residualFindings.length > 0
+		? `\n\nRecorded findings that did not block completion: ${residualFindings.map((f) => `${f.id} (${f.severity})`).join(", ")} — see the execution-review round reports under the run directory.`
+		: "";
 	const planPath = execution.planPath;
 	withExecutionCheckpoint(ctx, (cp) => applyExecutionCompleted(cp));
 	execution = null;
@@ -1635,7 +2306,7 @@ export async function completeExecution(ctx: ExtensionContext): Promise<void> {
 	messaging().sendMessage(
 		{
 			customType: "pi-plans-complete",
-			content: `**Plan complete!** ✅ \`${planPath}\` — completion audit passed.\n\n${summary}`,
+			content: `**Plan complete!** ✅ \`${planPath}\` — execution review passed.\n\n${summary}${residualNote}`,
 			display: true,
 		},
 		{ triggerTurn: false },
@@ -1668,7 +2339,11 @@ export function executionContextMessage(ctx: ExtensionContext): string | null {
 			? `${graphBlockForExecutor(false)}\n[pi-plans: config unreadable this turn; graph features are off until .git/pi-plans/config.json is repaired]`
 			: graphBlockForExecutor(mode === "enabled");
 	const rollbackNote = execution.audit.failed.length > 0
-		? `\nCompletion audit round ${execution.audit.rounds} failed checks: ${execution.audit.failed.join(", ")} — the covered tasks were rolled back to pending; re-close them with evidence after fixing the failures.`
+		? `\nExecution review round ${execution.audit.rounds} failed checks: ${execution.audit.failed.join(", ")} — the covered tasks were rolled back to pending; re-close them with evidence after fixing the failures.`
+		: "";
+	const unresolvedHighs = unresolvedHighFindings(execution);
+	const highFindingsNote = unresolvedHighs.length > 0
+		? `\nExecution review round ${execution.audit.rounds} unresolved high-severity findings:\n${unresolvedHighs.map((f) => `- ${f.id}${f.taskIds.length ? ` (${f.taskIds.join(", ")})` : ""}: ${f.note}`).join("\n")}\nFix them, then re-close the affected tasks with evidence.`
 		: "";
 	return `[PI-PLANS EXECUTION — write access enabled]
 Implement the accepted plan at ${execution.planPath} (tasks ${progress.done}/${progress.total}${execution.legacyPlan ? " · legacy I-### mapping" : ""} · VC ${vcDone}/${execution.items.length}).
@@ -1676,7 +2351,7 @@ Implement the accepted plan at ${execution.planPath} (tasks ${progress.done}/${p
 Current wave ${currentWave} open tasks:
 ${waveList}
 
-Remaining open tasks (all waves): ${open.map((task) => task.id).join(", ") || "(none)"}.${rollbackNote}
+Remaining open tasks (all waves): ${open.map((task) => task.id).join(", ") || "(none)"}.${rollbackNote}${highFindingsNote}
 
 ${graphLine}
 
@@ -1684,7 +2359,7 @@ Execution rules:
 - Work through tasks in wave order (earlier waves first); within a wave, follow the listed dependency order. Wave grouping encodes which tasks could run in parallel — keep their file sets disjoint.
 - Report progress ONLY through the \`plans_update_task\` tool: status "complete" with evidence (test command output / file paths), or "skipped" with a skipReason. One call per task; statuses are immutable once set.
 - Close subtasks before their parent; a parent is auditable only when every child is terminal.
-- When every task is terminal, the independent completion auditor verifies the plan's verification checks (${execution.items.map((item) => item.id).join(", ")}); failed checks roll their covered tasks back automatically.
+- When every task is terminal, the independent execution reviewer verifies the plan's verification checks (${execution.items.map((item) => item.id).join(", ")}); failed checks roll their covered tasks back automatically.
 - Simplest implementation that fully meets the task: no speculative abstractions, configuration, or indirection; keep components modular with clearly separated concerns.
 - Architectural decisions are for the long term: no stopgaps. Remove the obsolete paths this change obsoletes.
 - Prefer established, well-maintained libraries when they reduce complexity; check the project's existing dependencies before adding a package or reimplementing common functionality.
@@ -1741,10 +2416,18 @@ export async function restoreFromSession(ctx: ExtensionContext, entries: Session
 		planTasks = parsePlanTasks(planText);
 		const snapshotProgress = taskProgressMap(snapshot.tasks ?? []);
 		tasks = buildTaskView(planTasks, snapshotProgress);
-		items = parseChecklist(planText);
+		// Fresh text wins, but the satisfied state survives the re-parse: a
+		// mid-loop session restore (v0.9.1, found via F-001's self-schedule
+		// path) must not hand the next round a brief that re-judges checks an
+		// earlier round already passed — that burned budget on every /reload.
+		const snapDone = new Set(snapshot.items.filter((c) => c.done).map((c) => c.id));
+		items = parseChecklist(planText).map((item) => (snapDone.has(item.id) ? { ...item, done: true } : item));
 	} catch {
 		tasks = snapshot.tasks;
 	}
+	// The snapshot cannot carry an in-flight round (it is memory-only); abort
+	// any live one from the previous session graph and rebuild fresh (CF2-002).
+	abortInFlightReview();
 	execution = {
 		planPath: snapshot.planPath,
 		items,
@@ -1754,8 +2437,15 @@ export async function restoreFromSession(ctx: ExtensionContext, entries: Session
 		startedAt: snapshot.startedAt,
 		usage: snapshot.usage ?? { inToks: 0, outToks: 0 },
 		uiLanguage: resolveUiLanguage(ctx.cwd),
-		stall: { ...snapshot.stall, lastSnapshot: null, rounds: 0 },
-		audit: { rounds: snapshot.audit?.rounds ?? 0, failed: snapshot.audit?.failed ?? [], running: false },
+		stall: { ...snapshot.stall, lastSnapshot: null },
+		audit: {
+			rounds: snapshot.audit?.rounds ?? 0,
+			failed: snapshot.audit?.failed ?? [],
+			undeterminable: [],
+			findings: toReviewFindings(snapshot.audit?.findings),
+			running: false,
+		},
+		review: { attempts: 0, consecutiveDiscards: 0, inFlight: null },
 		auditLatch: { auditedThisSettle: false, activity: 0 },
 	};
 	execution.stall.lastSnapshot = stallSnapshot();
@@ -1765,9 +2455,12 @@ export async function restoreFromSession(ctx: ExtensionContext, entries: Session
 	if (active) bindRun(ctx.sessionManager, ctx.cwd, active.run_id);
 	persist(ctx);
 	if (pendingAudit()) {
-		// Terminal tasks without a passing audit: rerun the audit flow.
+		// Self-heal (v0.8): a verifying run with pending checks restarts its
+		// round exactly once per resume — the full predicate (paused, in-flight,
+		// budget) lives inside startReviewRound. Restores never grant budget.
 		latchAuditThisSettle();
-		await runAuditFlow(ctx);
+		const chain = launchReviewRound(ctx);
+		if (chain) await chain;
 	}
 	updateStatusWidget(ctx);
 }