gentle-pi 2.1.2 → 2.2.0

package/extensions/gentle-ai.ts

@@ -51,14 +51,24 @@ import {
 } from "../lib/sdd-status.ts";
 import type { TriggerEvent } from "../lib/review-triggers.ts";
 import { canonicalJsonV1, domainHashV1 } from "../lib/review-canonical.ts";
-import { CompactReviewContractError, deriveNativeRefuterRequest, parseNativeCompactFinalizeInput, toNativeReviewerDocument, toNativeValidatorDocument } from "../lib/review-compact-contract.ts";
-import { toNativeRefuterDocument } from "../lib/review-refuter-adapter.ts";
+import { parseNativeCompactFinalizeInput, toNativeValidatorDocument } from "../lib/review-compact-contract.ts";
+import {
+	REVIEW_HOST_RELAY_FAILURE,
+	REVIEW_HOST_RELAY_SUBMISSION_MISSING_MESSAGE,
+	REVIEW_HOST_RELAY_UNAVAILABLE_MESSAGE,
+	ReviewHostRelayError,
+	reviewHostRelaySlots,
+	reviewProviderRoleVectorSlots,
+	runReviewHostRelaySlot,
+	type ReviewHostRelayRunner,
+	type ReviewHostRelaySlot,
+	type ReviewProviderRoleVectorSlot,
+} from "../lib/review-host-relay.ts";
 import {
 	inheritedUnsafeGitEnvironmentKeys,
 	publicationProbeGitEnvironment,
 	resolveRepositoryAuthorityV1,
 } from "../lib/review-repository.ts";
-import { captureLiveReviewCandidateBinding } from "../lib/review-snapshot.ts";
 import {
 	EXTERNAL_RELEASE_EVIDENCE,
 	GATE_RESULT,
@@ -96,19 +106,30 @@ import {
 	type ReviewProjectionV1,
 } from "../lib/review-snapshot.ts";
 import { sanitizeTerminalText, stripAnsi } from "../lib/terminal-theme.ts";
-import { CandidateViewError, CandidateViewRegistry, injectReviewCandidateView, resolveCanonicalCandidateBase, type CandidateView, type NativeCandidateProjectionDescriptor } from "../lib/review-candidate-view.ts";
+import { CandidateViewError, CandidateViewRegistry, injectReviewCandidateView, readCandidateContextManifestPage, resolveCanonicalCandidateBase, type CandidateView } from "../lib/review-candidate-view.ts";
+import {
+	GentleAiDevBinaryOverrideError,
+	registerGentleAiDevBinary,
+	resolveGentleAiDevBinaryOverride,
+	unregisterGentleAiDevBinary,
+	type GentleAiDevBinaryOverride,
+} from "../lib/gentle-ai-binary.ts";
 import {
 	createNativeReviewCli,
+	createNodeExecFileAdapter,
 	isCanonicalProcessString,
 	nativeReviewAbandonAuthorization,
 	nativeReviewLegacyAliasRepairAuthorization,
 	nativeReviewLegacyQuarantineAuthorization,
 	nativeReviewReconcileAuthorization,
+	nativeReviewRecoverAuthorization,
 	normalizeNativeReviewCwd,
 	NativeReviewCliError,
 	NativeReviewConsentBindingError,
 	NativeReviewConsentRequiredError,
+	NativeReviewIntegrationError,
 	NATIVE_REVIEW_ERROR_CODE,
+	NATIVE_REVIEW_OPERATION,
 	NATIVE_REVIEW_LEGACY_QUARANTINE,
 	NATIVE_REVIEW_LEGACY_ALIAS_REPAIR,
 	NATIVE_REVIEW_MODE_OPERATION,
@@ -116,15 +137,18 @@ import {
 	NATIVE_REVIEW_RECONCILE_ANOMALIES,
 	sanitizeForeignNativeReviewDiagnostics,
 	type NativeReviewCli,
+	type NativeTargetStatusRequest,
 	type NativeFinalizeResult,
+	type NativeReviewVerificationEvidenceV2,
 	type NativeReviewModeOperation,
 	type NativeReviewModeSource,
 	type NativeReviewProcessDiagnostics,
 	type NativeStartResult,
 	type NativeValidateResult,
 } from "../lib/native-review-cli.ts";
-import type { ReviewConsentV2, ReviewStatusV3 } from "../lib/review-integration-v2.ts";
+import type { ReviewCollectInputV3, ReviewConsentEnvelope, ReviewStatusV3 } from "../lib/review-integration-v2.ts";
 import { assertDistinctCorrectionEvidence, resolveCorrectionStep, type CorrectionEvidence, type CorrectionOutcome, type CorrectionStep } from "../lib/review-correction-lifecycle.ts";
+import { recordReviewConsentLatch } from "../lib/review-consent-latch.ts";
 
 const GRAPH_V1_ORDINARY_READ_ONLY = "Graph-v1 ordinary review authority is read-only; use native compact-v2 review operations";
 import {
@@ -214,15 +238,353 @@ function sddLocalAgentOverrideCount(cwd: string): number {
 	return count;
 }
 
-let orchestratorPromptCache: string | null = null;
-function getOrchestratorPrompt(): string {
-	if (orchestratorPromptCache === null) {
-		orchestratorPromptCache = renderOrchestratorPrompt(ASSETS_DIR);
+// ---------------------------------------------------------------------------
+// Background subagents policy — project > global > env > default off
+// ---------------------------------------------------------------------------
+
+type BackgroundSubagentsPolicy = "on" | "off";
+type BackgroundSubagentsCapability = "ready" | "absent";
+
+interface BackgroundSubagentsRendering {
+	policy: BackgroundSubagentsPolicy;
+	capability: BackgroundSubagentsCapability;
+}
+
+/** Which of the four sources decided the effective policy. */
+type BackgroundSubagentsSource =
+	| "project_file"
+	| "global_file"
+	| "environment"
+	| "default";
+
+interface BackgroundSubagentsResolution {
+	policy: BackgroundSubagentsPolicy;
+	source: BackgroundSubagentsSource;
+	/** The deciding file was present but failed the strict decode. */
+	malformed: boolean;
+	projectFile: string;
+	globalFile: string;
+	projectFileExists: boolean;
+	globalFileExists: boolean;
+	/** The raw env value, reported even when it is unrecognized and inert. */
+	envValue: string | undefined;
+}
+
+interface LoadBackgroundSubagentsOptions {
+	/** Override the config home directory (used in tests to avoid touching ~/.pi). */
+	gentlePiConfigHome?: string;
+	/** Override the environment lookup (used in tests). */
+	env?: Record<string, string | undefined>;
+}
+
+const BACKGROUND_SUBAGENTS_SCHEMA = "gentle-pi.background-subagents/v1";
+const BACKGROUND_SUBAGENTS_FILE = "background-subagents.json";
+
+const DEFAULT_BACKGROUND_SUBAGENTS_RENDERING: BackgroundSubagentsRendering = {
+	policy: "off",
+	capability: "absent",
+};
+
+/**
+ * Strict decode of {"schema":"gentle-pi.background-subagents/v1","policy":"on"|"off"}.
+ * Any malformed shape (bad JSON, wrong schema, unknown keys, invalid policy)
+ * returns undefined so the caller fails closed to "off".
+ */
+function parseBackgroundSubagentsPolicyFile(
+	raw: string,
+): BackgroundSubagentsPolicy | undefined {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return undefined;
+	}
+	if (!isRecord(parsed)) return undefined;
+	if (parsed.schema !== BACKGROUND_SUBAGENTS_SCHEMA) return undefined;
+	if (parsed.policy !== "on" && parsed.policy !== "off") return undefined;
+	if (Object.keys(parsed).length !== 2) return undefined;
+	return parsed.policy;
+}
+
+/**
+ * Resolve the background-subagents policy AND the source that decided it.
+ *
+ * Resolution order (first hit wins, mirroring loadRuntimeGuardrailsConfig):
+ *   1. Project file `${cwd}/.pi/gentle-ai/background-subagents.json`
+ *   2. Global file `${configHome}/background-subagents.json`
+ *      (configHome honors GENTLE_PI_CONFIG_HOME, default ~/.pi/gentle-ai)
+ *   3. Env var GENTLE_PI_BACKGROUND_SUBAGENTS ("on" | "off")
+ *   4. Default "off"
+ *
+ * A present-but-malformed file fails closed to "off" instead of falling
+ * through to a lower-priority source, and it stays attributed to that file:
+ * "off decided by a broken project file" and "off by default" are different
+ * situations, and only the first one is a mistake to fix.
+ *
+ * Four sources with first-hit-wins is exactly the shape that makes an edit
+ * look like it did nothing, so the deciding source is part of the result
+ * rather than something a caller has to re-derive.
+ */
+function resolveBackgroundSubagentsPolicy(
+	cwd: string,
+	options: LoadBackgroundSubagentsOptions = {},
+): BackgroundSubagentsResolution {
+	const env = options.env ?? process.env;
+	const envValue = env.GENTLE_PI_BACKGROUND_SUBAGENTS;
+	let projectFile = "";
+	let globalFile = "";
+	try {
+		const configHome = options.gentlePiConfigHome ?? gentleAiConfigHome();
+		projectFile = join(cwd, ".pi", "gentle-ai", BACKGROUND_SUBAGENTS_FILE);
+		globalFile = join(configHome, BACKGROUND_SUBAGENTS_FILE);
+		const projectFileExists = existsSync(projectFile);
+		const globalFileExists = existsSync(globalFile);
+		const locations = { projectFile, globalFile, projectFileExists, globalFileExists, envValue };
+		for (const [source, path, present] of [
+			["project_file", projectFile, projectFileExists],
+			["global_file", globalFile, globalFileExists],
+		] as const) {
+			if (!present) continue;
+			let decoded: BackgroundSubagentsPolicy | undefined;
+			try {
+				decoded = parseBackgroundSubagentsPolicyFile(readFileSync(path, "utf8"));
+			} catch {
+				// Unreadable is indistinguishable from unusable at this layer, and
+				// both must fail closed on the file that claimed the decision.
+				decoded = undefined;
+			}
+			return decoded === undefined
+				? { policy: "off", source, malformed: true, ...locations }
+				: { policy: decoded, source, malformed: false, ...locations };
+		}
+		if (envValue === "on" || envValue === "off") {
+			return { policy: envValue, source: "environment", malformed: false, ...locations };
+		}
+		return { policy: "off", source: "default", malformed: false, ...locations };
+	} catch {
+		return {
+			policy: "off",
+			source: "default",
+			malformed: false,
+			projectFile,
+			globalFile,
+			projectFileExists: false,
+			globalFileExists: false,
+			envValue,
+		};
+	}
+}
+
+/**
+ * The effective policy alone, for callers that do not report a source.
+ * It delegates so the loader and the resolver can never disagree.
+ */
+function loadBackgroundSubagentsPolicy(
+	cwd: string,
+	options: LoadBackgroundSubagentsOptions = {},
+): BackgroundSubagentsPolicy {
+	return resolveBackgroundSubagentsPolicy(cwd, options).policy;
+}
+
+/** Write the global policy file, creating the config home when needed. */
+function writeGlobalBackgroundSubagentsPolicy(
+	policy: BackgroundSubagentsPolicy,
+	configHome: string = gentleAiConfigHome(),
+): string {
+	const path = join(configHome, BACKGROUND_SUBAGENTS_FILE);
+	mkdirSync(configHome, { recursive: true });
+	writeFileSync(
+		path,
+		`${JSON.stringify({ schema: BACKGROUND_SUBAGENTS_SCHEMA, policy }, null, 2)}\n`,
+	);
+	return path;
+}
+
+function describeBackgroundSubagentsSource(
+	resolution: BackgroundSubagentsResolution,
+): string {
+	switch (resolution.source) {
+		case "project_file":
+			return `project file ${resolution.projectFile}`;
+		case "global_file":
+			return `global file ${resolution.globalFile}`;
+		case "environment":
+			return "GENTLE_PI_BACKGROUND_SUBAGENTS";
+		default:
+			return "built-in default";
+	}
+}
+
+/**
+ * Report the effective policy, the source that decided it, and the resolved
+ * capability, plus whatever the user needs to know about the sources that did
+ * NOT decide. `wrote` names a policy this invocation just wrote to the global
+ * file; a write that a higher-priority file outranks must never be reported as
+ * if it had taken effect.
+ */
+function renderBackgroundSubagentsReport(
+	resolution: BackgroundSubagentsResolution,
+	capability: BackgroundSubagentsCapability,
+	wrote?: BackgroundSubagentsPolicy,
+): { message: string; type: "info" | "warning" } {
+	const lines = [
+		`background subagents: ${resolution.policy} (decided by ${describeBackgroundSubagentsSource(resolution)}; capability: ${capability})`,
+	];
+	if (wrote !== undefined) {
+		lines.push(`Wrote ${wrote} to the global file ${resolution.globalFile}.`);
+	}
+	if (resolution.malformed) {
+		const path =
+			resolution.source === "project_file" ? resolution.projectFile : resolution.globalFile;
+		lines.push(
+			`${path} is present but malformed, so the policy fails closed to off and no lower-priority source is consulted.`,
+		);
+	}
+	const outranksTheWrite = wrote !== undefined && resolution.source === "project_file";
+	if (outranksTheWrite) {
+		lines.push(
+			`That global write does not take effect here: the project file ${resolution.projectFile} outranks it. Edit or remove that project file to let the global setting decide.`,
+		);
+	} else if (
+		wrote === undefined &&
+		resolution.source === "project_file" &&
+		resolution.globalFileExists
+	) {
+		lines.push(
+			`The global file ${resolution.globalFile} exists but is outranked by that project file.`,
+		);
+	}
+	if (resolution.envValue !== undefined && resolution.source !== "environment") {
+		lines.push(
+			resolution.envValue === "on" || resolution.envValue === "off"
+				? `GENTLE_PI_BACKGROUND_SUBAGENTS=${resolution.envValue} is set, but both files outrank it and it outranks the built-in default; it decides only when neither file exists.`
+				: `GENTLE_PI_BACKGROUND_SUBAGENTS="${resolution.envValue}" is not a recognized value ("on" or "off"), so it is ignored.`,
+		);
+	}
+	lines.push(
+		"Resolution order (first hit wins): project file, global file, GENTLE_PI_BACKGROUND_SUBAGENTS, built-in default off.",
+	);
+	return {
+		message: lines.join("\n"),
+		type: resolution.malformed || outranksTheWrite ? "warning" : "info",
+	};
+}
+
+const SUBAGENTS_PACKAGE_NAMES = ["pi-subagents-j0k3r", "pi-subagents"] as const;
+const SUBAGENT_RUN_TOOL = "subagent_run";
+
+/**
+ * Roots where an installed subagents package may live. These are the same
+ * roots builtinAgentDirs() walks, minus its `/agents` suffix.
+ *
+ * builtinAgentDirs() looks for markdown agent definitions, which the package
+ * legitimately may not ship. Capability is a different question, so it must
+ * not reuse that path: pi-subagents-j0k3r v1.5.2 ships index.ts, src/, skills/
+ * and scripts/ and no agents/ directory at all, so an agents-dir probe reports
+ * "absent" on every real install and leaves the background policy inert.
+ */
+function subagentsPackageRoots(cwd: string): string[] {
+	return SUBAGENTS_PACKAGE_NAMES.flatMap((packageName) => [
+		join(PACKAGE_ROOT, "..", packageName),
+		join(cwd, ".pi", "npm", "node_modules", packageName),
+		join(homedir(), ".local", "lib", "node_modules", packageName),
+	]);
+}
+
+/** A package root counts as installed only when it carries its own manifest. */
+function hasInstalledSubagentsPackage(cwd: string): boolean {
+	return subagentsPackageRoots(cwd).some((root) =>
+		existsSync(join(root, "package.json")),
+	);
+}
+
+function hasSubagentRunTool(activeTools: readonly string[]): boolean {
+	return activeTools.some(
+		(name) => name === SUBAGENT_RUN_TOOL || name.endsWith(`.${SUBAGENT_RUN_TOOL}`),
+	);
+}
+
+/**
+ * Read the live pi tool registry, or undefined when it carries no signal.
+ *
+ * An absent handle, a non-array result, a throwing registry, and an empty list
+ * are all "no signal" rather than "no subagents": reporting absent from an
+ * uninformative registry would reproduce the very defect this probe fixes.
+ */
+function readActiveToolNames(pi: unknown): readonly string[] | undefined {
+	try {
+		const getActiveTools = (pi as { getActiveTools?: () => unknown })
+			?.getActiveTools;
+		if (typeof getActiveTools !== "function") return undefined;
+		const tools = getActiveTools.call(pi);
+		if (!Array.isArray(tools)) return undefined;
+		const names = tools
+			.map((tool) =>
+				typeof tool === "string"
+					? tool
+					: isRecord(tool) && typeof tool.name === "string"
+						? tool.name
+						: "",
+			)
+			.filter((name) => name.length > 0);
+		return names.length > 0 ? names : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * `subagent_run` availability probe.
+ *
+ * The live tool registry answers the question directly and wins whenever it
+ * carries any signal. Without it -- prompt rendering outside a session, or a
+ * runtime with no getActiveTools -- capability falls back to the presence of
+ * an installed subagents package.
+ */
+function resolveBackgroundSubagentsCapability(
+	cwd: string,
+	activeTools?: readonly string[],
+): BackgroundSubagentsCapability {
+	try {
+		if (activeTools !== undefined && activeTools.length > 0) {
+			return hasSubagentRunTool(activeTools) ? "ready" : "absent";
+		}
+		return hasInstalledSubagentsPackage(cwd) ? "ready" : "absent";
+	} catch {
+		return "absent";
+	}
+}
+
+function renderBackgroundSubagentsStatusLine(
+	background: BackgroundSubagentsRendering,
+): string {
+	return `Background subagent policy: ${background.policy} (capability: ${background.capability})`;
+}
+
+// Rendered prompts are memoized per background policy/capability key for the
+// process lifetime; the assets bytes themselves are read once per key.
+const orchestratorPromptCache = new Map<string, string>();
+function getOrchestratorPrompt(
+	cwd: string = process.cwd(),
+	activeTools?: readonly string[],
+): string {
+	const background: BackgroundSubagentsRendering = {
+		policy: loadBackgroundSubagentsPolicy(cwd),
+		capability: resolveBackgroundSubagentsCapability(cwd, activeTools),
+	};
+	const cacheKey = `${background.policy}:${background.capability}`;
+	let prompt = orchestratorPromptCache.get(cacheKey);
+	if (prompt === undefined) {
+		prompt = renderOrchestratorPrompt(ASSETS_DIR, background);
+		orchestratorPromptCache.set(cacheKey, prompt);
 	}
-	return orchestratorPromptCache;
+	return prompt;
 }
 
-function renderOrchestratorPrompt(assetsDir: string): string {
+function renderOrchestratorPrompt(
+	assetsDir: string,
+	background: BackgroundSubagentsRendering = DEFAULT_BACKGROUND_SUBAGENTS_RENDERING,
+): string {
 	return readFileSync(join(assetsDir, "orchestrator.md"), "utf8")
 		.replaceAll(
 			"{{GENTLE_PI_SDD_WORKFLOW_PATH}}",
@@ -240,6 +602,10 @@ function renderOrchestratorPrompt(assetsDir: string): string {
 			"{{GENTLE_PI_SKILLS_PATH}}",
 			join(assetsDir, "orchestrator-skills.md"),
 		)
+		.replaceAll(
+			"{{GENTLE_PI_BACKGROUND_POLICY}}",
+			renderBackgroundSubagentsStatusLine(background),
+		)
 		.trim();
 }
 
@@ -275,7 +641,11 @@ const NEUTRAL_PERSONA_PROMPT = `Persona:
 - Push back when the user asks for code without enough context or understanding.
 - Correct errors directly, explain why, and show the better path.`;
 
-function buildGentlePrompt(persona: PersonaMode): string {
+function buildGentlePrompt(
+	persona: PersonaMode,
+	cwd: string = process.cwd(),
+	activeTools?: readonly string[],
+): string {
 	const personaPrompt =
 		persona === "neutral" ? NEUTRAL_PERSONA_PROMPT : GENTLEMAN_PERSONA_PROMPT;
 	const languageBoundary =
@@ -309,7 +679,7 @@ Harness principles:
 - Protect the human reviewer: avoid oversized changes, surface review workload risk, and ask before turning one task into a large multi-area change.
 - Never claim persistent memory is available because of this package. Memory is provided by separate packages or MCP tools when installed and callable.
 
-${getOrchestratorPrompt()}`;
+${getOrchestratorPrompt(cwd, activeTools)}`;
 }
 
 // Matches `git [global-flags] push` — tolerates flags like -C /repo or --work-tree=/tmp
@@ -555,7 +925,16 @@ const CORE_MODEL_AGENT_NAMES = [
 ] as const;
 const CORE_MODEL_AGENT_NAME_SET = new Set<string>(CORE_MODEL_AGENT_NAMES);
 
-type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+] as const;
+type ThinkingLevel = (typeof THINKING_LEVELS)[number];
 interface AgentRoutingEntry {
 	model?: string;
 	thinking?: ThinkingLevel;
@@ -579,12 +958,7 @@ const CUSTOM_MODEL = "Custom model id";
 const INHERIT_THINKING = "Inherit effort";
 const THINKING_OPTIONS: (ThinkingLevel | typeof INHERIT_THINKING)[] = [
 	INHERIT_THINKING,
-	"off",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
+	...THINKING_LEVELS,
 ];
 
 const MODEL_CONTROL_OPTIONS = [
@@ -804,12 +1178,8 @@ function writePersonaMode(cwd: string, mode: PersonaMode): string[] {
 
 function isThinkingLevel(value: unknown): value is ThinkingLevel {
 	return (
-		value === "off" ||
-		value === "minimal" ||
-		value === "low" ||
-		value === "medium" ||
-		value === "high" ||
-		value === "xhigh"
+		typeof value === "string" &&
+		(THINKING_LEVELS as readonly string[]).includes(value)
 	);
 }
 
@@ -2164,7 +2534,7 @@ const REVIEW_CONTROLLER_PARAMETERS = {
 		},
 		input: {
 			type: "string",
-			description: "A JSON-serialized object string, not a nested object. New native ordinary START uses {\"mode\":\"ordinary\"}; answer-consent uses exactly {\"consentBinding\":\"<opaque id>\",\"answer\":\"granted|declined\"}. An explicit baseRef requires committedOnly: true and requests a committed range, while repository-local policyPath remains optional. Legacy compact START retains policyHash. FINALIZE supplies reviewer results, correction forecast, targeted validation, final evidence, and an explicit final_verification_passed boolean. Judgment Day retains graph-v1 input.",
+			description: "A JSON-serialized object string, not a nested object. New native ordinary START uses {\"mode\":\"ordinary\"}; answer-consent uses exactly {\"consentBinding\":\"<opaque id>\",\"answer\":\"granted|declined\"}. An explicit baseRef requires committedOnly: true and requests a committed range, while repository-local policyPath remains optional. Legacy compact START retains policyHash. FINALIZE supplies only the negotiated collection answers: correction forecast, targeted validation, final evidence, and an explicit final_verification_passed boolean; reviewer, refuter, and validator verdicts are admitted natively and never Pi-authored. Judgment Day retains graph-v1 input.",
 		},
 		outputPath: { type: "string", description: "Retired with legacy bundle export; ignored. Export returns legacy-operation-retired." },
 		inputPath: { type: "string", description: "Repository-local JSON input file for finalize/advance (alternative to input). Legacy bundle import is retired." },
@@ -2177,6 +2547,23 @@ const REVIEW_CONTROLLER_PARAMETERS = {
 	},
 } as const;
 
+const REVIEW_SCOPE_PARAMETERS = {
+	type: "object",
+	additionalProperties: false,
+	required: ["manifest", "sha256"],
+	properties: {
+		manifest: { type: "string", maxLength: 4_096, description: "Exact controller-supplied gzip/base64url frozen changed-scope manifest." },
+		sha256: { type: "string", pattern: "^[0-9a-f]{64}$", description: "Exact controller-supplied SHA-256 of the decompressed canonical manifest bytes." },
+		cursor: { type: "integer", minimum: 0, description: "Pagination cursor. Start at 0 and continue with nextCursor until absent." },
+	},
+} as const;
+
+interface ReviewScopeParameters {
+	manifest: string;
+	sha256: string;
+	cursor?: number;
+}
+
 interface ReviewControllerParameters {
 	operation: ReviewControllerOperation;
 	lineageId?: string;
@@ -2533,7 +2920,17 @@ async function authorizeDestructiveReviewOperation(
 	ctx: ExtensionContext,
 ): Promise<void> {
 	const parameters = parseReviewControllerParameters(parametersValue);
-	const isReset = parameters.operation === REVIEW_CONTROLLER_OPERATION.RESET || parameters.operation === REVIEW_CONTROLLER_OPERATION.RECOVER;
+	// RESET alone carries the legacy repository-wide challenge. Native compact-v2
+	// RECOVER has its own six-field contract and its own derived
+	// `gentle-ai.review-recovery-authorization/v1` binding, neither of which the
+	// legacy `repositoryId`/`commonDirHash`/`inventoryHash`/`confirmation` quartet
+	// can express. Native INSPECT never publishes that quartet either, so
+	// demanding it here made the only supported recovery flow unreachable
+	// (issue #212).
+	// RECOVER authorizes itself in `executeReviewControllerOperation`, the way
+	// REPAIR_LEGACY_ALIAS does, because its binding can only be derived from a
+	// fresh native target-status read.
+	const isReset = parameters.operation === REVIEW_CONTROLLER_OPERATION.RESET;
 	const maintenance = nativeMaintenanceOperation(parameters.operation);
 	if (!isReset && maintenance === undefined) return;
 	const input = parseControllerJson(requiredControllerString(parameters, "input"), parameters.operation);
@@ -3849,13 +4246,21 @@ const REVIEW_MODE_DISABLED_OUTCOME = "review-mode-disabled";
 // and changes nothing — ground-truthed against a real build. Naming it here
 // would be naming a dead end, which is worse than naming nothing.
 //
-// The default source expresses no opinion and can never be what keeps reviews
-// off, so it gets no guessed continuation — the same reason gentle-ai returns
-// an empty scope for RDDModeSourceDefault.
+// The default branch changed with the pinned v2.4.0 runtime, which made
+// receipt-driven development opt-in. It used to be unreachable as a reason for
+// reviews being off — an all-sources-unset install resolved to ON with source
+// `default` — so naming a continuation for it would have been a guess, and
+// gentle-ai returned an empty scope to say exactly that. v2.4.0 resolves the
+// same install to OFF with source `default`, which makes it the most common
+// refusal there is: every install that never opted in. gentle-ai answers
+// `global` for it now, not because default is a global opinion but because
+// global is the only scope that can turn reviews on at all, and Pi answers the
+// same. Leaving this undefined would hand the single most common state a dead
+// end.
 function reviewModeContinuation(source: NativeReviewModeSource): string | undefined {
 	if (source === NATIVE_REVIEW_MODE_SOURCE.CLONE_LOCAL) return "Run /gentle:review-mode enable to turn reviews back on for this clone.";
 	if (source === NATIVE_REVIEW_MODE_SOURCE.GLOBAL) return "Run `gentle-ai review mode enable --scope=global` to turn reviews back on; /gentle:review-mode enable only clears the clone-local setting, which cannot override a global off.";
-	return undefined;
+	return "Run `gentle-ai review mode enable --scope=global` to turn reviews on; receipt-driven development is opt-in and nothing here has enabled it yet. /gentle:review-mode enable only sets clone scope, which can never turn reviews on.";
 }
 
 // Names the situation before the mechanism, then the mechanism, mirroring
@@ -3927,9 +4332,22 @@ function asNativeReviewConsentBindingError(error: unknown): { reason: string; me
 	return typeof reason !== "string" || reason.length === 0 ? undefined : { reason, message: error.message };
 }
 
+function nativeStatusPackageBinaryMissing(operation: ReviewControllerOperation, diagnostics: NativeReviewProcessDiagnostics): Record<string, unknown> {
+	return {
+		operation,
+		status: "blocked",
+		outcome: "native-status-package-binary-missing",
+		...(operation === REVIEW_CONTROLLER_OPERATION.START ? nativeStartPreAuthorityRejection() : { lineage_created: false, mutation_performed: false, mutation_outcome: "none" }),
+		inventory_complete: false,
+		diagnostics,
+		next_action: "reinstall-package-local-gentle-ai",
+	};
+}
+
 function nativeStatusFailed(operation: ReviewControllerOperation, error: unknown): Record<string, unknown> {
 	const cliError = asNativeReviewCliError(error);
 	if (cliError?.code === NATIVE_REVIEW_ERROR_CODE.VERSION_INCOMPATIBLE) return nativeStatusUnsupported(operation);
+	if (cliError?.code === NATIVE_REVIEW_ERROR_CODE.PACKAGE_BINARY_MISSING) return nativeStatusPackageBinaryMissing(operation, cliError.diagnostics);
 	if (cliError !== undefined) {
 		return {
 			...nativeOperationFailure(operation, error),
@@ -3970,7 +4388,14 @@ function nativeMaintenanceOperation(operation: ReviewControllerOperation): Nativ
 }
 
 function missingNativeMaintenanceInputs(operation: NativeMaintenanceOperation, input: Record<string, unknown>): readonly string[] {
-	return NATIVE_MAINTENANCE_INPUT[operation].filter((key) => !isCanonicalProcessString(input[key]));
+	const missing = NATIVE_MAINTENANCE_INPUT[operation].filter((key) => !isCanonicalProcessString(input[key]));
+	if (operation !== "abandon") return missing;
+	return [
+		...missing,
+		...(Array.isArray(input.capturedLensResults) && input.capturedLensResults.every((entry) => isCanonicalProcessString(entry)) ? [] : ["capturedLensResults"]),
+		...(typeof input.findingsPresent === "boolean" ? [] : ["findingsPresent"]),
+		...(typeof input.evidenceRecordsPresent === "boolean" ? [] : ["evidenceRecordsPresent"]),
+	];
 }
 
 function invalidNativeMaintenanceInput(operation: NativeMaintenanceOperation, input: Record<string, unknown>): boolean {
@@ -3979,7 +4404,7 @@ function invalidNativeMaintenanceInput(operation: NativeMaintenanceOperation, in
 }
 
 function nativeMaintenanceAuthorization(operation: NativeMaintenanceOperation, input: Record<string, unknown>): string {
-	if (operation === "abandon") return nativeReviewAbandonAuthorization({ lineage: String(input.lineage), expectedRevision: String(input.expectedRevision), snapshotIdentity: String(input.snapshotIdentity), actor: String(input.actor), reason: String(input.reason) });
+	if (operation === "abandon") return nativeReviewAbandonAuthorization({ lineage: String(input.lineage), expectedRevision: String(input.expectedRevision), snapshotIdentity: String(input.snapshotIdentity), capturedLensResults: (input.capturedLensResults as readonly unknown[]).map(String), findingsPresent: input.findingsPresent === true, evidenceRecordsPresent: input.evidenceRecordsPresent === true, actor: String(input.actor), reason: String(input.reason) });
 	if (operation === "quarantineLegacy") return nativeReviewLegacyQuarantineAuthorization({ repository: String(input.repository), lineage: String(input.lineage), expectedRevision: String(input.expectedRevision), diagnostic: NATIVE_REVIEW_LEGACY_QUARANTINE.DIAGNOSTIC, disposition: NATIVE_REVIEW_LEGACY_QUARANTINE.DISPOSITION, actor: String(input.actor), reason: String(input.reason) });
 	return nativeReviewReconcileAuthorization({ predecessorLineage: String(input.predecessorLineage), expectedPredecessorRevision: String(input.expectedPredecessorRevision), successorLineage: String(input.successorLineage), expectedSuccessorRevision: String(input.expectedSuccessorRevision), actor: String(input.actor), reason: String(input.reason), ...(input.anomalies === undefined ? {} : { anomalies: NATIVE_REVIEW_RECONCILE_ANOMALIES.COMBINED }) });
 }
@@ -4008,7 +4433,7 @@ async function executeNativeAuthorityMaintenance(
 	pendingAuthorizations.clear();
 	try {
 		const result = nativeOperation === "abandon"
-			? await nativeReviewCli.abandon!({ cwd, lineage: String(input.lineage), expectedRevision: String(input.expectedRevision), snapshotIdentity: String(input.snapshotIdentity), actor: String(input.actor), reason: String(input.reason), maintainerAuthorization: nativeMaintenanceAuthorization(nativeOperation, input), ...(signal === undefined ? {} : { signal }) })
+			? await nativeReviewCli.abandon!({ cwd, lineage: String(input.lineage), expectedRevision: String(input.expectedRevision), snapshotIdentity: String(input.snapshotIdentity), capturedLensResults: (input.capturedLensResults as readonly unknown[]).map(String), findingsPresent: input.findingsPresent === true, evidenceRecordsPresent: input.evidenceRecordsPresent === true, actor: String(input.actor), reason: String(input.reason), maintainerAuthorization: nativeMaintenanceAuthorization(nativeOperation, input), ...(signal === undefined ? {} : { signal }) })
 			: nativeOperation === "quarantineLegacy"
 				? await nativeReviewCli.quarantineLegacy!({ cwd, repository: String(input.repository), lineage: String(input.lineage), expectedRevision: String(input.expectedRevision), diagnostic: NATIVE_REVIEW_LEGACY_QUARANTINE.DIAGNOSTIC, disposition: NATIVE_REVIEW_LEGACY_QUARANTINE.DISPOSITION, actor: String(input.actor), reason: String(input.reason), maintainerAuthorization: nativeMaintenanceAuthorization(nativeOperation, input), ...(signal === undefined ? {} : { signal }) })
 				: await nativeReviewCli.reconcileAuthority!({ cwd, predecessorLineage: String(input.predecessorLineage), expectedPredecessorRevision: String(input.expectedPredecessorRevision), successorLineage: String(input.successorLineage), expectedSuccessorRevision: String(input.expectedSuccessorRevision), actor: String(input.actor), reason: String(input.reason), ...(input.anomalies === undefined ? {} : { anomalies: NATIVE_REVIEW_RECONCILE_ANOMALIES.COMBINED }), maintainerAuthorization: nativeMaintenanceAuthorization(nativeOperation, input), ...(signal === undefined ? {} : { signal }) });
@@ -4530,6 +4955,18 @@ function validateNativeStartPolicyPath(cwd: string, value: unknown): NativeStart
 	}
 }
 
+const NATIVE_START_FOCUS = {
+	RISK: "risk",
+	RESILIENCE: "resilience",
+	READABILITY: "readability",
+	RELIABILITY: "reliability",
+} as const;
+type NativeStartFocus = (typeof NATIVE_START_FOCUS)[keyof typeof NATIVE_START_FOCUS];
+
+function isNativeStartFocus(value: unknown): value is NativeStartFocus {
+	return typeof value === "string" && (Object.values(NATIVE_START_FOCUS) as readonly string[]).includes(value);
+}
+
 function nativeStartRejection(reason: string, field?: string): Record<string, unknown> {
 	return {
 		operation: REVIEW_CONTROLLER_OPERATION.START,
@@ -4546,7 +4983,7 @@ function nativeStartRejection(reason: string, field?: string): Record<string, un
 							? "native-start-committed-only-required"
 							: reason === "committed-only-invalid"
 								? "native-start-committed-only-invalid"
-								: reason === "unknown-field"
+								: reason === "unknown-field" || reason === "focus-invalid"
 									? "native-start-input-invalid"
 									: "native-start-policy-path-invalid",
 		reason,
@@ -4562,7 +4999,7 @@ interface PendingReviewConsent {
 	repositoryCwd: string;
 	authorityCwd: string;
 	candidateView: CandidateView;
-	consent: ReviewConsentV2;
+	consent: ReviewConsentEnvelope;
 	consentDigest: string;
 	expiresAt: number;
 	expiry?: ReturnType<typeof setTimeout>;
@@ -4583,7 +5020,21 @@ function cleanupAllPendingReviewConsents(pendingReviewConsents: Map<string, Pend
 	for (const pending of [...pendingReviewConsents.values()]) cleanupPendingReviewConsent(pending, pendingReviewConsents, candidateViews);
 }
 
-function reviewConsentDigest(consent: ReviewConsentV2): string {
+// An unused consent binding and the candidate view retained exclusively for
+// that binding expire as one lifecycle unit. TTL expiry is observable the
+// moment synchronous time says `expiresAt <= now`, so cleanup must be
+// synchronous with respect to that observation — the queued cleanup
+// macrotask is a safety net, not the authority. Pruning here (before any
+// later START may reuse the retained view) keeps timer order from deciding
+// correctness: a fresh candidate retry never reuses a view whose binding
+// already expired, so it cannot trip `candidate-target-projection-drift`.
+function pruneExpiredReviewConsents(pendingReviewConsents: Map<string, PendingReviewConsent>, candidateViews: CandidateViewRegistry | null, now: () => number): void {
+	for (const pending of [...pendingReviewConsents.values()]) {
+		if (pending.expiresAt <= now()) cleanupPendingReviewConsent(pending, pendingReviewConsents, candidateViews);
+	}
+}
+
+function reviewConsentDigest(consent: ReviewConsentEnvelope): string {
 	return createHash("sha256").update(JSON.stringify(consent)).digest("hex");
 }
 
@@ -4600,6 +5051,17 @@ function assertNativeStartCandidateBinding(candidateView: CandidateView, target:
 	}
 }
 
+function assertNativeFinalizeCandidateBinding(candidateView: CandidateView, target: ReviewStatusV3): void {
+	candidateView.verify();
+	if (
+		target.projection.baseTree !== candidateView.baseTree ||
+		target.projection.currentCandidateTree !== candidateView.candidateTree ||
+		JSON.stringify([...target.projection.paths].sort()) !== JSON.stringify([...candidateView.paths].sort())
+	) {
+		throw new CandidateViewError("native FINALIZE target does not match the immutable reviewer candidate view", "candidate-target-projection-drift");
+	}
+}
+
 function completeNativeStart(
 	operation: ReviewControllerOperation,
 	result: NativeStartResult,
@@ -4665,12 +5127,18 @@ function nativeOperationFailure(operation: ReviewControllerOperation, error: unk
 		};
 	}
 	const mutationOutcome = value.mutationOutcome === "unknown" ? "unknown" : "none";
-	const nativeDiagnostics = asNativeReviewCliError(error)?.diagnostics;
+	const nativeCliError = asNativeReviewCliError(error);
+	if (nativeCliError?.code === NATIVE_REVIEW_ERROR_CODE.PACKAGE_BINARY_MISSING) return nativeStatusPackageBinaryMissing(operation, nativeCliError.diagnostics);
+	const nativeDiagnostics = nativeCliError?.diagnostics;
+	// A target-status probe verifies `version` before it invokes `review/status`.
+	// Preserve either already-sanitized diagnostic on every controller route rather
+	// than relabeling an actionable failure as an opaque controller failure.
+	const preservesNativeTargetStatusDiagnostic = nativeDiagnostics?.operation === NATIVE_REVIEW_OPERATION.VERSION || nativeDiagnostics?.operation === NATIVE_REVIEW_OPERATION.STATUS;
 	const diagnostics = operation === REVIEW_CONTROLLER_OPERATION.START && error instanceof CandidateViewError && value.candidateViewPreNative === true
-		? { code: error.reason, message: "candidate view rejected before native START" }
+		? error.diagnostics ?? { code: error.reason, message: "candidate view rejected before native START" }
 		: error instanceof CandidateViewError
 			? { code: error.reason, message: error.message }
-			: nativeDiagnostics?.operation === `review/${operation}`
+			: nativeDiagnostics?.operation === `review/${operation}` || preservesNativeTargetStatusDiagnostic
 		? nativeDiagnostics
 		: undefined;
 	return {
@@ -4708,6 +5176,7 @@ async function reconcileNativeMutationFailure(
 	error: unknown,
 	nativeReviewCli: NativeReviewCli,
 	target: { cwd: string; lineageId?: string; baseRef?: string; projection?: "workspace" | "staged" },
+	preOperationRevision?: string,
 ): Promise<Record<string, unknown>> {
 	const failure = nativeOperationFailure(operation, error);
 	if (!nativeMutationRequiresStatus(error)) return failure;
@@ -4733,6 +5202,28 @@ async function reconcileNativeMutationFailure(
 				...reconcileFinalizeRouting(status, target.lineageId, operation === REVIEW_CONTROLLER_OPERATION.FINALIZE),
 			};
 		}
+		// Field defect (fambig, 2026-08-16): an envelope-less mutating failure
+		// is stamped mutationOutcome "unknown", but a reconciled authority
+		// revision identical to the pre-operation revision PROVES the failed
+		// call never mutated. Report that proof as mutation_outcome none and
+		// claim no replay prohibition for it. Every genuinely ambiguous result
+		// — revision moved, no pre-operation revision held, or STATUS
+		// unavailable — stays fail-closed exactly as before.
+		if (preOperationRevision !== undefined && status.authority?.revision === preOperationRevision) {
+			const { replayability: staleReplayability, ...provenBase } = reconciledBase;
+			void staleReplayability;
+			return {
+				...provenBase,
+				outcome: "native-mutation-status-reconciled",
+				reconciliation: status.raw,
+				authority_applicability: status.applicability,
+				provider_action: status.action,
+				mutation_performed: false,
+				mutation_outcome: "none",
+				mutation_outcome_reason: `authority revision unchanged across reconciliation (${preOperationRevision}); the failed operation provably did not mutate`,
+				next_action: status.action,
+			};
+		}
 		return {
 			...reconciledBase,
 			outcome: "native-mutation-status-reconciled",
@@ -4824,97 +5315,173 @@ function resolveReviewControllerWorkspaceRoot(requested: string | undefined, ses
 	return resolved;
 }
 
-function providerArgumentValue(name: string, input: NonNullable<NonNullable<ReviewStatusV3["nextTransition"]>["collect"]>["inputs"][number]): string {
-	const matches = input.arguments.filter((argument) => argument.name === name);
-	if (matches.length !== 1 || !isCanonicalProcessString(matches[0]?.value)) {
-		throw new CandidateViewError(`provider reviewer collect input requires exactly one canonical ${name} argument`, "manifest-input-divergence");
+function correctionOutcome(input: ReturnType<typeof parseNativeCompactFinalizeInput>): CorrectionOutcome | undefined {
+	if (input.final_verification_outcome !== undefined) return input.final_verification_outcome;
+	if (input.final_verification_passed === undefined) return undefined;
+	return input.final_verification_passed ? "passed" : "verification_failed";
+}
+
+// Both targeted-validation collection forms count as "validation offered":
+// the host-run `external.run_targeted_validation` input and the Go-owned
+// `review.capture-validation` vector (gentle-pi#311 P4-roles).
+function isTargetedValidationCollectInput(input: { captureOperation: string }): boolean {
+	return input.captureOperation === "external.run_targeted_validation" || input.captureOperation === "review.capture-validation";
+}
+
+function requireEvidenceCollection(status: ReviewStatusV3): ReviewCollectInputV3 {
+	const inputs = status.nextTransition?.kind === "collect" ? status.nextTransition.collect?.inputs ?? [] : [];
+	// An offered validation STEP is a targeted-validation collect input. The
+	// bare `validation_request` field is descriptive context both live
+	// emitters (pinned 2.2.3 and 2.4.0-main, probed 2026-08-16) publish
+	// alongside the evidence collect at `correction_required`; treating it as
+	// an offered step made the controller demand its validation phase before
+	// capturing the evidence the state itself demanded (field defect).
+	if (inputs.some(isTargetedValidationCollectInput)) {
+		throw new CandidateViewError("targeted validation was offered before correction evidence was captured", "evidence-first-ordering");
+	}
+	const evidence = inputs.filter((input) => input.captureOperation === "review.capture-evidence");
+	if (evidence.length !== 1) {
+		throw new CandidateViewError("provider status must collect exactly one correction evidence record before targeted validation", "evidence-first-ordering");
 	}
-	return matches[0]!.value;
+	return evidence[0]!;
 }
 
-function providerReviewerProjection(status: ReviewStatusV3): NativeCandidateProjectionDescriptor {
-	const authority = status.authority;
-	const inputs = status.nextTransition?.kind === "collect"
-		? status.nextTransition.collect?.inputs.filter((input) => input.captureOperation === "review.capture-result") ?? []
-		: [];
-	if (authority === undefined || inputs.length === 0) {
-		throw new CandidateViewError("provider status did not supply reviewer collect inputs for the frozen candidate", "manifest-input-divergence");
-	}
-	const first = inputs[0]!;
-	if (first.artifactSubject === undefined || first.baseTree === undefined || first.candidateTree === undefined || first.changedPathManifest === undefined) {
-		throw new CandidateViewError("provider reviewer collect input omitted its frozen artifact subject or manifest", "manifest-input-divergence");
-	}
-	const manifestBytes = JSON.stringify(first.changedPathManifest);
-	const manifestHash = first.artifactSubject.changedPathManifestSha256;
-	const seenLenses = new Set<string>();
-	const seenOrders = new Set<number>();
-	const seenSubjects = new Set<string>();
-	for (const input of inputs) {
-		const subject = input.artifactSubject;
-		if (
-			subject === undefined || input.baseTree === undefined || input.candidateTree === undefined || input.changedPathManifest === undefined ||
-			input.baseTree !== status.projection.baseTree || input.candidateTree !== status.projection.currentCandidateTree ||
-			subject.baseTree !== input.baseTree || subject.candidateTree !== input.candidateTree ||
-			subject.lineageId !== authority.lineageId || subject.authorityRevision !== authority.revision || subject.targetIdentity !== status.targetIdentity ||
-			subject.changedPathManifestSha256 !== manifestHash || JSON.stringify(input.changedPathManifest) !== manifestBytes ||
-			providerArgumentValue("lineage", input) !== subject.lineageId ||
-			providerArgumentValue("expected-revision", input) !== subject.authorityRevision ||
-			providerArgumentValue("target", input) !== subject.targetIdentity ||
-			providerArgumentValue("lens", input) !== subject.lens ||
-			providerArgumentValue("order", input) !== String(subject.selectedOrder) ||
-			providerArgumentValue("subject-hash", input) !== subject.subjectHash ||
-			seenLenses.has(subject.lens) || seenOrders.has(subject.selectedOrder) || seenSubjects.has(subject.subjectHash)
-		) {
-			throw new CandidateViewError("provider reviewer collect inputs disagree on their frozen manifest binding", "manifest-input-divergence");
-		}
-		seenLenses.add(subject.lens);
-		seenOrders.add(subject.selectedOrder);
-		seenSubjects.add(subject.subjectHash);
+interface EvidenceCaptureBinding {
+	/** The identity the collect slot demands; the top-level status identity only as a pre-slot compatibility fallback. */
+	readonly targetIdentity: string;
+	readonly expectedRevision: string;
+	/** True when the slot rendered its own target identity; the record binds the slot's (fix-diff) scope, not the frozen projection scope. */
+	readonly slotBound: boolean;
+	readonly submission?: {
+		readonly argumentTokens: readonly string[];
+		readonly outcomeSubstitutionLocation: number;
+		readonly inputSubstitutionLocation: number;
+		readonly carriesRepositoryContext: boolean;
+	};
+}
+
+// Field defect (fambig, 2026-08-16): at every evidence-pending sub-state the
+// collect slot renders the identity native demands — for a correction that is
+// the FIX-DIFF identity, never the top-level live workspace snapshot identity.
+// Collect satisfaction binds to the slot's rendered arguments and submission
+// tokens; top-level status fields remain only a compatibility fallback for
+// pre-v5 emitters whose slots render no identities.
+function resolveEvidenceCaptureBinding(slot: ReviewCollectInputV3, status: ReviewStatusV3, lineageId: string, outcome: CorrectionOutcome): EvidenceCaptureBinding {
+	const named = new Map(slot.arguments.map((argument) => [argument.name, argument.value]));
+	const slotLineage = named.get("lineage");
+	if (slotLineage !== undefined && slotLineage !== lineageId) {
+		throw new CandidateViewError("provider evidence collect slot is bound to a different lineage", "correction-evidence-binding-drift");
+	}
+	const slotRevision = named.get("expected-revision");
+	if (slotRevision !== undefined && slotRevision !== status.authority?.revision) {
+		throw new CandidateViewError("provider evidence collect slot is bound to a different authority revision", "correction-evidence-binding-drift");
+	}
+	const slotTarget = named.get("target");
+	const binding = {
+		targetIdentity: slotTarget ?? status.targetIdentity,
+		expectedRevision: slotRevision ?? status.authority!.revision,
+		slotBound: slotTarget !== undefined,
+	};
+	const descriptor = slot.submissionDescriptor;
+	if (descriptor === undefined || descriptor.operationToken !== "capture-evidence") return binding;
+	const outcomeSlot = descriptor.values?.find((value) => value.slot === "outcome");
+	const inputSlot = descriptor.values?.find((value) => value.slot === "input");
+	if (outcomeSlot === undefined || inputSlot === undefined) {
+		throw new CandidateViewError("provider capture-evidence submission descriptor must render the outcome and input slots", "correction-evidence-binding-drift");
 	}
-	const intendedUntracked = first.changedPathManifest.filter((entry) => entry.intendedUntracked).map((entry) => entry.path).sort();
-	if (JSON.stringify(intendedUntracked) !== JSON.stringify([...status.projection.intendedUntracked].sort())) {
-		throw new CandidateViewError("provider manifest intended-untracked fields disagree with its projection", "manifest-intended-untracked-not-subset");
+	if (outcomeSlot.allowedValues !== undefined && !outcomeSlot.allowedValues.includes(outcome)) {
+		throw new CandidateViewError(`provider capture-evidence submission does not admit outcome ${outcome}`, "correction-evidence-binding-drift");
 	}
 	return {
-		...status.projection,
-		manifest: first.changedPathManifest.map((entry) => ({
-			path: entry.path,
-			status: entry.status,
-			oldMode: entry.oldMode,
-			newMode: entry.newMode,
-			deleted: entry.deleted,
-			typeChanged: entry.typeChanged,
-			modeOnly: entry.modeOnly,
-		})),
-		manifestSha256: manifestHash,
-		providerManifestHashVerified: true,
+		...binding,
+		submission: {
+			argumentTokens: descriptor.argumentTokens,
+			outcomeSubstitutionLocation: outcomeSlot.substitutionLocation,
+			inputSubstitutionLocation: inputSlot.substitutionLocation,
+			carriesRepositoryContext: descriptor.argumentTokens.some((token) => token === "--repository-context" || token.startsWith("--repository-context=")),
+		},
 	};
 }
 
-function correctionOutcome(input: ReturnType<typeof parseNativeCompactFinalizeInput>): CorrectionOutcome | undefined {
-	if (input.final_verification_outcome !== undefined) return input.final_verification_outcome;
-	if (input.final_verification_passed === undefined) return undefined;
-	return input.final_verification_passed ? "passed" : "verification_failed";
+async function captureEvidenceForCollection(
+	nativeReviewCli: NativeReviewCli,
+	binding: EvidenceCaptureBinding,
+	cwd: string,
+	lineageId: string,
+	outcome: CorrectionOutcome,
+	evidenceDocument: string,
+	signal: AbortSignal | undefined,
+): Promise<NativeReviewVerificationEvidenceV2> {
+	if (binding.submission !== undefined) {
+		if (nativeReviewCli.captureEvidenceSubmission === undefined) throw new CandidateViewError("native capture-evidence submission execution is unavailable", "evidence-first-ordering");
+		return nativeReviewCli.captureEvidenceSubmission({
+			// The slot's --repository-context is cwd-independent and
+			// authoritative; a path is passed only when the slot renders none.
+			...(binding.submission.carriesRepositoryContext ? {} : { cwd }),
+			argumentTokens: binding.submission.argumentTokens,
+			outcomeSubstitutionLocation: binding.submission.outcomeSubstitutionLocation,
+			inputSubstitutionLocation: binding.submission.inputSubstitutionLocation,
+			outcome,
+			evidenceDocument,
+			...(signal === undefined ? {} : { signal }),
+		});
+	}
+	if (nativeReviewCli.captureEvidence === undefined) throw new CandidateViewError("native capture-evidence execution is unavailable", "evidence-first-ordering");
+	return nativeReviewCli.captureEvidence({
+		cwd,
+		lineageId,
+		targetIdentity: binding.targetIdentity,
+		expectedRevision: binding.expectedRevision,
+		outcome,
+		evidenceDocument,
+		...(signal === undefined ? {} : { signal }),
+	});
 }
 
-function requireEvidenceCollection(status: ReviewStatusV3): void {
+// Same misbinding class as capture-evidence (live smoke, 2026-08-16): the
+// correction PLAN and TARGETED VALIDATION collect slots render `finalize`
+// submission descriptors. When one is rendered, the reconstructed legacy
+// `--correction-lines`/`--validation` argv fails the live emitter's
+// committed-intent reconciliation, so the rendered tokens execute verbatim.
+function finalizeSubmissionSlot(
+	status: ReviewStatusV3,
+	slot: "correction_lines" | "validation",
+): { argumentTokens: readonly string[]; value: NonNullable<NonNullable<ReviewCollectInputV3["submissionDescriptor"]>["value"]> } | undefined {
 	const inputs = status.nextTransition?.kind === "collect" ? status.nextTransition.collect?.inputs ?? [] : [];
-	if (status.validationRequest !== undefined || inputs.some((input) => input.captureOperation === "external.run_targeted_validation")) {
-		throw new CandidateViewError("targeted validation was offered before correction evidence was captured", "evidence-first-ordering");
+	for (const input of inputs) {
+		const descriptor = input.submissionDescriptor;
+		if (descriptor?.operationToken === "finalize" && descriptor.value?.slot === slot) {
+			return { argumentTokens: descriptor.argumentTokens, value: descriptor.value };
+		}
 	}
-	if (inputs.filter((input) => input.captureOperation === "review.capture-evidence").length !== 1) {
-		throw new CandidateViewError("provider status must collect exactly one correction evidence record before targeted validation", "evidence-first-ordering");
+	return undefined;
+}
+
+// A slot-bound record covers the slot-demanded (fix-diff) scope: its paths are
+// a subset of the frozen projection paths and its digest binds the record's
+// own paths (captured 2026-08-16, lineage review-2b6206ed68fb9128). Only the
+// pre-slot compatibility fallback still demands projection-exact paths.
+function evidencePathsDrift(captured: NativeReviewVerificationEvidenceV2, binding: EvidenceCaptureBinding, status: ReviewStatusV3): boolean {
+	if (binding.slotBound) {
+		return captured.paths.length === 0 || captured.paths.some((path) => !status.projection.paths.includes(path));
 	}
+	return captured.pathsDigest !== status.projection.pathsDigest || JSON.stringify([...captured.paths].sort()) !== JSON.stringify([...status.projection.paths].sort());
 }
 
 function requireTargetedValidationAfterEvidence(status: ReviewStatusV3): NonNullable<ReviewStatusV3["validationRequest"]> {
 	const inputs = status.nextTransition?.kind === "collect" ? status.nextTransition.collect?.inputs ?? [] : [];
-	const targeted = inputs.filter((input) => input.captureOperation === "external.run_targeted_validation");
+	const targeted = inputs.filter(isTargetedValidationCollectInput);
 	const request = status.validationRequest;
 	if (
-		status.authority?.state !== "validating" || targeted.length !== 1 || targeted[0]?.validationRequest === undefined || request === undefined ||
+		// Both live emitters (pinned 2.2.3 and 2.4.0-main, probed 2026-08-16)
+		// keep the post-evidence authority state at `correction_required`;
+		// `validating` is retained for pre-existing fixture compatibility.
+		(status.authority?.state !== "validating" && status.authority?.state !== "correction_required") || targeted.length !== 1 || targeted[0]?.validationRequest === undefined || request === undefined ||
 		JSON.stringify(targeted[0].validationRequest) !== JSON.stringify(request) || request.lineageId !== status.authority.lineageId ||
-		request.expectedRevision !== status.authority.revision || request.targetIdentity !== status.targetIdentity ||
+		// The live emitter binds the request to the FROZEN authority target
+		// identity; the top-level target identity is the live workspace
+		// snapshot, which already contains the fix (probed 2026-08-16).
+		request.expectedRevision !== status.authority.revision || request.targetIdentity !== (status.authorityTargetIdentity ?? status.targetIdentity) ||
 		request.correctionCandidateTree !== status.projection.currentCandidateTree ||
 		JSON.stringify([...request.correctionPaths].sort()) !== JSON.stringify([...status.projection.paths].sort()) ||
 		request.correctionPathsDigest !== status.projection.pathsDigest
@@ -4926,11 +5493,278 @@ function requireTargetedValidationAfterEvidence(status: ReviewStatusV3): NonNull
 
 function assertNoTargetedValidation(status: ReviewStatusV3): void {
 	const inputs = status.nextTransition?.kind === "collect" ? status.nextTransition.collect?.inputs ?? [] : [];
-	if (status.validationRequest !== undefined || inputs.some((input) => input.captureOperation === "external.run_targeted_validation")) {
+	// Same rule as requireEvidenceCollection: only an offered targeted-
+	// validation collect input counts; the descriptive `validation_request`
+	// context rides along on non-passing outcomes too.
+	if (inputs.some(isTargetedValidationCollectInput)) {
 		throw new CandidateViewError("non-passing evidence unexpectedly unlocked targeted validation", "evidence-first-ordering");
 	}
 }
 
+// gentle-pi#311 P4 — the thin Pi host relay. The provider decides which
+// capture slots the host satisfies by issuing the --materialize token on a
+// pi-bound `review.capture-result` collect input; nothing is ever inferred.
+// The runner is injectable for tests only; production always uses the real
+// relay in lib/review-host-relay.ts.
+let activeReviewHostRelayRunner: ReviewHostRelayRunner = runReviewHostRelaySlot;
+function setReviewHostRelayRunnerForTesting(runner?: ReviewHostRelayRunner): void {
+	activeReviewHostRelayRunner = runner ?? runReviewHostRelaySlot;
+}
+
+const REVIEW_HOST_RELAY_RETRY_ACTION =
+	"Re-query negotiated STATUS and relaunch only if the exact same bound slot is reoffered; never rerun from transcript inference.";
+
+async function executeReviewHostRelayCollection(
+	operation: ReviewControllerOperation,
+	lineageId: string,
+	slots: readonly ReviewHostRelaySlot[],
+	nativeReviewCli: NativeReviewCli,
+	cwd: string,
+	signal?: AbortSignal,
+): Promise<Record<string, unknown>> {
+	const captured: Array<Record<string, unknown>> = [];
+	for (const slot of slots) {
+		let result: Awaited<ReturnType<ReviewHostRelayRunner>>;
+		try {
+			// A materialize slot without the provider-owned submission form is
+			// a provider contract mismatch: fail closed before any launch and
+			// never synthesize the completing form.
+			if (slot.submission === undefined) {
+				throw new ReviewHostRelayError(
+					REVIEW_HOST_RELAY_FAILURE.SUBMISSION_CONTRACT_MISMATCH,
+					"binding",
+					REVIEW_HOST_RELAY_SUBMISSION_MISSING_MESSAGE,
+				);
+			}
+			result = await activeReviewHostRelayRunner({
+				captureArgumentTokens: slot.captureArgumentTokens,
+				submission: slot.submission,
+				...(signal === undefined ? {} : { signal }),
+			});
+		} catch (error) {
+			if (!(error instanceof ReviewHostRelayError)) throw error;
+			const base = {
+				operation,
+				status: "blocked",
+				captured_slots: captured,
+				mutation_performed: captured.length > 0,
+				mutation_outcome: error.mutationOutcome === "unknown" ? "unknown" : captured.length > 0 ? "committed" : "none",
+			};
+			if (error.kind === REVIEW_HOST_RELAY_FAILURE.RELAY_UNAVAILABLE) {
+				return {
+					...base,
+					outcome: "pi-host-relay-unavailable",
+					reason: REVIEW_HOST_RELAY_UNAVAILABLE_MESSAGE,
+					next_action: "Install a gentle-ai release with the pi host relay surface; existing behavior stays untouched and there is no Pi-authored review document fallback.",
+				};
+			}
+			if (error.kind === REVIEW_HOST_RELAY_FAILURE.HANDSHAKE_REFUSED) {
+				return {
+					...base,
+					outcome: "pi-host-relay-handshake-refused",
+					reason: error.message,
+					refusal: error.stderr,
+					next_action: REVIEW_HOST_RELAY_RETRY_ACTION,
+				};
+			}
+			return {
+				...base,
+				outcome: "pi-host-relay-transport-failure",
+				failure: { kind: error.kind, stage: error.stage, exit_code: error.exitCode, timed_out: error.timedOut },
+				reason: error.message,
+				next_action: REVIEW_HOST_RELAY_RETRY_ACTION,
+			};
+		}
+		captured.push({
+			...(slot.lens === undefined ? {} : { lens: slot.lens }),
+			...(slot.order === undefined ? {} : { order: slot.order }),
+			...(slot.subjectHash === undefined ? {} : { subject_hash: slot.subjectHash }),
+			prompt_bytes: result.promptByteLength,
+			result_bytes: result.resultByteLength,
+			submission: result.submission,
+		});
+	}
+	const after = await nativeReviewCli.targetStatus!({ cwd, lineageId, ...(signal === undefined ? {} : { signal }) });
+	return {
+		...mapNativeTargetStatus(operation, after, lineageId),
+		host_relay: { transport: "pi_host_relay", captured_slots: captured },
+	};
+}
+
+// gentle-pi#311 P4-roles — the Go-owned adversarial role route. The provider
+// renders each non-lens role slot (`review.capture-refuter` /
+// `review.capture-validation`) as a SELF-CONTAINED authority-advancing
+// vector: binding tokens plus `--agent=pi --execute=true` and no submission
+// descriptor. Pi executes each exact vector once, verbatim and in the
+// foreground; Go materializes the role prompt, spawns its own locked-down pi
+// subprocess, and admits the raw verdict. On any failure the typed error is
+// surfaced and nothing is relaunched — the caller re-queries negotiated
+// STATUS and executes only a vector it reoffers.
+const REVIEW_PROVIDER_ROLE_RETRY_ACTION =
+	"Re-query negotiated STATUS and execute only the exact role vector it reoffers; never relaunch from transcript inference.";
+
+async function executeProviderRoleVectorCollection(
+	operation: ReviewControllerOperation,
+	lineageId: string,
+	slots: readonly ReviewProviderRoleVectorSlot[],
+	nativeReviewCli: NativeReviewCli,
+	cwd: string,
+	signal?: AbortSignal,
+): Promise<Record<string, unknown>> {
+	if (nativeReviewCli.captureProviderRole === undefined) {
+		return {
+			operation,
+			status: "blocked",
+			outcome: "provider-role-capture-unsupported",
+			reason: "The provider issued self-contained role capture vectors, but this runtime has no native provider-role capture surface.",
+			mutation_performed: false,
+			mutation_outcome: "none",
+			next_action: "Install a gentle-pi release with the provider-role capture surface; the vectors stay reoffered by negotiated STATUS.",
+		};
+	}
+	const executed: Array<Record<string, unknown>> = [];
+	for (const slot of slots) {
+		let artifact: Awaited<ReturnType<NonNullable<NativeReviewCli["captureProviderRole"]>>>;
+		try {
+			artifact = await nativeReviewCli.captureProviderRole({
+				captureOperation: slot.captureOperation,
+				argumentTokens: slot.argumentTokens,
+				cwd,
+				...(signal === undefined ? {} : { signal }),
+			});
+		} catch (error) {
+			return {
+				...nativeOperationFailure(operation, error),
+				outcome: "provider-role-vector-failed",
+				provider_roles: { transport: "go_owned_pi_process", executed_slots: executed },
+				retry_discipline: REVIEW_PROVIDER_ROLE_RETRY_ACTION,
+			};
+		}
+		executed.push({
+			capture_operation: slot.captureOperation,
+			role: artifact.role,
+			lineage_id: artifact.lineageId,
+			target_identity: artifact.targetIdentity,
+			captured: artifact.captured,
+		});
+	}
+	const after = await nativeReviewCli.targetStatus!({ cwd, lineageId, ...(signal === undefined ? {} : { signal }) });
+	return {
+		...mapNativeTargetStatus(operation, after, lineageId),
+		provider_roles: { transport: "go_owned_pi_process", executed_slots: executed },
+	};
+}
+
+// The provider-named lenses still awaiting a reviewer result: one lens per
+// pending `review.capture-result` collect input, in provider order.
+function pendingReviewerLenses(status: ReviewStatusV3): readonly string[] {
+	if (status.nextTransition?.kind !== "collect") return [];
+	return [...new Set((status.nextTransition.collect?.inputs ?? [])
+		.filter((input) => input.captureOperation === "review.capture-result")
+		.map((input) => input.artifactSubject?.lens)
+		.filter((lens): lens is NonNullable<typeof lens> => lens !== undefined))];
+}
+
+// Live defect (2026-08-16, Engram #12461): a successor lineage created by
+// native `review recover` exists only in native authority — this controller
+// never saw its START, so direct reviewer dispatch refused with
+// current-binding-missing even though the controller itself had just decoded
+// the successor's authoritative STATUS. Mirror the START-time registration
+// from STATUS discovery: when an unknown-but-live lineage still collecting
+// reviewer results appears in a status this controller decoded, restore its
+// frozen projection from the native descriptor and bind the dispatch-facing
+// current candidate view with the provider-named pending lenses.
+//
+// Field report (2026-08-16, gentle-pi 402f9f77): hydration must run from
+// EVERY lane that decodes an authoritative status, not from the STATUS
+// operation alone — the reported flow was `finalize` (blocked on
+// review.capture-result) followed by a reviewer dispatch, which never passed
+// through STATUS. It also never fails its caller: STATUS and the blocked
+// FINALIZE envelope stay read-only, and the outcome is returned so the caller
+// can report it instead of swallowing it.
+// Field defect (2026-08-16, third report): the Pi host relay never ran for a
+// real lineage. Measured against the live 2.4.0-main provider on a faithful
+// reproduction — an agent-less `review status` returns a bare capture-result
+// collect input (lineage, expected-revision, target, repository-context, lens,
+// order, subject-hash), while the SAME status with `--agent pi` additionally
+// carries agent=pi, materialize=true and the provider submission. The adapter
+// never named its agent, so reviewHostRelaySlots() saw zero materialize slots,
+// the relay was unreachable, and no lens was ever launched.
+//
+// The agent is PROBED, never assumed. The pinned provider defines `--agent` as
+// of v2.4.0 — v2.2.3 did not define it on `review status` at all and refused it
+// outright — but Pi still never version-sniffs: the installed binary remains
+// the only authority on whether the flag exists. A typed refusal is remembered
+// per provider instance and the exact provider cause is reported to the user
+// rather than degraded into a generic candidate-view message.
+const REVIEW_HOST_AGENT = "pi" as const;
+const REVIEW_TRANSPORT_REFUSAL_CODES = new Set([
+	"immutable_review_transport_unsupported",
+	"unsupported_agent",
+	"unknown_flag",
+]);
+interface ReviewTransportRefusal { supported: false; code: string; message: string; }
+const reviewTransportRefusalByProvider = new WeakMap<object, ReviewTransportRefusal>();
+
+function clearReviewTransportProbeForTesting(nativeReviewCli: NativeReviewCli | null): void {
+	if (nativeReviewCli !== null) reviewTransportRefusalByProvider.delete(nativeReviewCli as unknown as object);
+}
+
+/**
+ * Queries negotiated STATUS for the pi reviewer transport so the provider
+ * offers its materialize-marked relay slot, probing the agent exactly once per
+ * provider and falling back to the agent-less status on a typed refusal. The
+ * refusal is returned, never swallowed.
+ */
+async function negotiatedStatusForHostTransport(
+	nativeReviewCli: NativeReviewCli,
+	request: NativeTargetStatusRequest,
+): Promise<{ status: ReviewStatusV3; transport?: ReviewTransportRefusal }> {
+	const provider = nativeReviewCli as unknown as object;
+	const remembered = reviewTransportRefusalByProvider.get(provider);
+	if (remembered !== undefined) {
+		return { status: await nativeReviewCli.targetStatus!(request), transport: remembered };
+	}
+	try {
+		return { status: await nativeReviewCli.targetStatus!({ ...request, agent: REVIEW_HOST_AGENT }) };
+	} catch (error) {
+		const code = error instanceof NativeReviewIntegrationError ? error.failureEnvelope.code : undefined;
+		// Only a transport-shaped refusal falls back; every other failure is
+		// the caller's to handle exactly as before.
+		if (code === undefined || !REVIEW_TRANSPORT_REFUSAL_CODES.has(code)) throw error;
+		const refusal: ReviewTransportRefusal = { supported: false, code, message: error.message };
+		reviewTransportRefusalByProvider.set(provider, refusal);
+		return { status: await nativeReviewCli.targetStatus!(request), transport: refusal };
+	}
+}
+
+type DispatchHydrationOutcome =
+	| { hydrated: true; lineage_id: string; lenses: readonly string[] }
+	| { hydrated: false; lineage_id: string; reason: string; message: string }
+	| undefined;
+
+function hydrateDispatchBindingFromStatus(candidateViews: CandidateViewRegistry | null, contributorRoot: string, status: ReviewStatusV3): DispatchHydrationOutcome {
+	if (candidateViews === null || candidateViews.hasCurrentBinding()) return undefined;
+	const lineageId = status.authority?.lineageId;
+	if (lineageId === undefined || status.applicability !== "current_target" || candidateViews.hasProjection(lineageId)) return undefined;
+	const lenses = pendingReviewerLenses(status);
+	if (lenses.length === 0) return undefined;
+	try {
+		candidateViews.restoreCurrentForDispatchFromNative(lineageId, contributorRoot, status.projection, lenses);
+		return { hydrated: true, lineage_id: lineageId, lenses };
+	} catch (error) {
+		// Never fail the caller on hydration; the registry records the typed
+		// cause so the later dispatch refusal names the attempt instead of
+		// claiming no binding was ever available.
+		return {
+			hydrated: false,
+			lineage_id: lineageId,
+			reason: error instanceof CandidateViewError ? error.reason : "candidate-view-invalid",
+			message: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
 async function executeReviewControllerOperation(
 	parametersValue: unknown,
 	sessionCwd: string,
@@ -4943,6 +5777,9 @@ async function executeReviewControllerOperation(
 	context?: ExtensionContext,
 	correctionEvidenceByLineage: Map<string, CorrectionEvidence> = new Map(),
 	pendingReviewConsents: Map<string, PendingReviewConsent> = new Map(),
+	writeReviewConsentLatch: typeof recordReviewConsentLatch = recordReviewConsentLatch,
+	reviewConsentNow: () => number = Date.now,
+	reviewConsentScheduleTimer: (callback: () => void, delayMs: number) => { unref: () => void } = setTimeout,
 ): Promise<Record<string, unknown>> {
 	const parameters = parseReviewControllerParameters(parametersValue);
 	const defaultCwd = resolveReviewControllerWorkspaceRoot(parameters.workspaceRoot, sessionCwd);
@@ -4995,6 +5832,20 @@ async function executeReviewControllerOperation(
 	}
 	if (parameters.operation === REVIEW_CONTROLLER_OPERATION.RECOVER) {
 		const input = parseControllerJson(requiredControllerString(parameters, "input"), parameters.operation);
+		// The authorization binding is Pi-derived, never caller-carried. It is
+		// recorded verbatim as a maintainer attestation, so accepting one the
+		// caller composed would let an unapproved actor sign the recovery edge.
+		if (input.maintainerAuthorization !== undefined) {
+			return {
+				operation: parameters.operation,
+				status: "blocked",
+				outcome: "native-recovery-caller-authorization-rejected",
+				native_operation: "review recover",
+				mutation_performed: false,
+				mutation_outcome: "none",
+				next_action: "resubmit-without-maintainer-authorization",
+			};
+		}
 		const missing = NATIVE_RECOVERY_INPUT.recover.filter((key) =>
 			key === "disposition"
 				? !["scope_changed", "invalidated", "escalated"].includes(input[key] as string)
@@ -5002,27 +5853,76 @@ async function executeReviewControllerOperation(
 		);
 		if (missing.length > 0) return await executeNativeRecoveryRoute(parameters.operation, "recover", input, defaultCwd, nativeReviewCli, pendingAuthorizations, signal);
 		if (nativeReviewCli?.targetStatus === undefined) return nativeStatusUnsupported(parameters.operation);
+		const frozenTarget = candidateViews?.hasProjection(String(input.predecessorLineage))
+			? candidateViews.resolveProjection(String(input.predecessorLineage), defaultCwd)
+			: undefined;
+		const statusRequest = {
+			cwd: defaultCwd,
+			lineageId: String(input.predecessorLineage),
+			...(frozenTarget?.committedOnly === true ? { baseRef: frozenTarget.baseCommit } : {}),
+			...(signal === undefined ? {} : { signal }),
+		};
 		let status: ReviewStatusV3;
 		try {
-			const frozenTarget = candidateViews?.hasProjection(String(input.predecessorLineage))
-				? candidateViews.resolveProjection(String(input.predecessorLineage), defaultCwd)
-				: undefined;
-			status = await nativeReviewCli.targetStatus({
-				cwd: defaultCwd,
-				lineageId: String(input.predecessorLineage),
-				...(frozenTarget?.committedOnly === true ? { baseRef: frozenTarget.baseCommit } : {}),
-				...(signal === undefined ? {} : { signal }),
-			});
+			status = await nativeReviewCli.targetStatus(statusRequest);
 		} catch (error) {
 			return nativeStatusFailed(parameters.operation, error);
 		}
-		if (status.action !== "recover" || status.actionDisposition === undefined || status.authority?.lineageId !== input.predecessorLineage || status.authority.revision !== input.expectedPredecessorRevision) {
+		const pinnedRecoveryStatus = (candidate: ReviewStatusV3): boolean =>
+			candidate.action === "recover"
+			&& candidate.actionDisposition === status.actionDisposition
+			&& candidate.authority?.lineageId === input.predecessorLineage
+			&& candidate.authority?.revision === input.expectedPredecessorRevision
+			&& candidate.targetIdentity === status.targetIdentity;
+		if (status.action !== "recover" || status.actionDisposition === undefined || status.authority?.lineageId !== input.predecessorLineage || status.authority.revision !== input.expectedPredecessorRevision || !isCanonicalProcessString(status.targetIdentity)) {
 			return { operation: parameters.operation, status: "blocked", outcome: "native-recovery-status-mismatch", mutation_performed: false, mutation_outcome: "none", result: status.raw, next_action: "follow-provider-target-status" };
 		}
 		if (input.disposition !== status.actionDisposition) {
 			return { operation: parameters.operation, status: "blocked", outcome: "native-recovery-disposition-mismatch", mutation_performed: false, mutation_outcome: "none", provider_disposition: status.actionDisposition, next_action: "resubmit-with-provider-disposition" };
 		}
-		return await executeNativeRecoveryRoute(parameters.operation, "recover", { ...input, disposition: status.actionDisposition }, defaultCwd, nativeReviewCli, pendingAuthorizations, signal);
+		const recoverAuthorization = nativeReviewRecoverAuthorization({
+			predecessorLineage: String(input.predecessorLineage),
+			expectedPredecessorRevision: String(input.expectedPredecessorRevision),
+			targetIdentity: status.targetIdentity,
+			actor: String(input.actor),
+			reason: String(input.reason),
+		});
+		if (context?.hasUI !== true) throw new Error("Review controller RECOVER requires fresh explicit authorization through the interactive Pi UI; headless execution fails closed");
+		const approved = await context.ui.confirm(
+			"Authorize destructive review authority RECOVER?",
+			[
+				"Operation: RECOVER",
+				`Provider-selected disposition: ${status.actionDisposition}`,
+				"Exact published authorization binding:",
+				recoverAuthorization,
+				`The native command creates one auditable successor authority (${String(input.successorLineage)}) for this exact predecessor and target identity; the predecessor stays untouched.`,
+			].join("\n"),
+		);
+		if (!approved) throw new Error("Review controller RECOVER was not explicitly authorized");
+		// Time-of-check to time-of-use: the human deliberates for an unbounded
+		// interval, and the authority can advance, be recovered by someone else, or
+		// stop being recovery-eligible while they do. The approval and the derived
+		// binding are pinned to the pre-approval read, so the authority is read once
+		// more and must still match it exactly before anything mutates.
+		let confirmedStatus: ReviewStatusV3;
+		try {
+			confirmedStatus = await nativeReviewCli.targetStatus(statusRequest);
+		} catch (error) {
+			return nativeStatusFailed(parameters.operation, error);
+		}
+		if (!pinnedRecoveryStatus(confirmedStatus)) {
+			return {
+				operation: parameters.operation,
+				status: "blocked",
+				outcome: "native-recovery-authority-changed",
+				native_operation: "review recover",
+				mutation_performed: false,
+				mutation_outcome: "none",
+				result: confirmedStatus.raw,
+				next_action: "reinspect-and-reauthorize-recovery",
+			};
+		}
+		return await executeNativeRecoveryRoute(parameters.operation, "recover", { ...input, disposition: status.actionDisposition, maintainerAuthorization: recoverAuthorization }, defaultCwd, nativeReviewCli, pendingAuthorizations, signal);
 	}
 	if (parameters.operation === REVIEW_CONTROLLER_OPERATION.RESET) {
 		const input = parseControllerJson(requiredControllerString(parameters, "input"), parameters.operation);
@@ -5030,7 +5930,12 @@ async function executeReviewControllerOperation(
 	}
 	if (parameters.operation === REVIEW_CONTROLLER_OPERATION.REPAIR) {
 		if (nativeReviewCli?.targetStatus === undefined) return nativeStatusUnsupported(parameters.operation);
-		const status = await nativeReviewCli.targetStatus({ cwd: defaultCwd, ...(parameters.lineageId === undefined ? {} : { lineageId: parameters.lineageId }), ...(signal === undefined ? {} : { signal }) });
+		let status: ReviewStatusV3;
+		try {
+			status = await nativeReviewCli.targetStatus({ cwd: defaultCwd, ...(parameters.lineageId === undefined ? {} : { lineageId: parameters.lineageId }), ...(signal === undefined ? {} : { signal }) });
+		} catch (error) {
+			return nativeStatusFailed(parameters.operation, error);
+		}
 		if (status.authority?.version === "compact-v2") return { operation: parameters.operation, repaired: false, compact_authority: "immutable-untouched", status: mapNativeTargetStatus(parameters.operation, status, parameters.lineageId) };
 		if (status.authority?.version !== "legacy-v1") return mapNativeTargetStatus(parameters.operation, status, parameters.lineageId);
 		const store = ReviewTransactionStore.forRepository(defaultCwd);
@@ -5097,7 +6002,7 @@ async function executeReviewControllerOperation(
 		if (typeof input.consentBinding !== "string" || input.consentBinding.length === 0) throw new Error("Review controller answer-consent requires an opaque consentBinding");
 		if (input.answer !== "granted" && input.answer !== "declined") throw new Error("Review controller answer-consent answer must be granted or declined");
 		const pending = pendingReviewConsents.get(input.consentBinding);
-		if (pending === undefined || pending.expiresAt <= Date.now()) {
+		if (pending === undefined || pending.expiresAt <= reviewConsentNow()) {
 			if (pending !== undefined) cleanupPendingReviewConsent(pending, pendingReviewConsents, candidateViews);
 			throw new Error("Review controller consent binding is unknown, expired, or already consumed");
 		}
@@ -5117,6 +6022,7 @@ async function executeReviewControllerOperation(
 		// The one-shot binding is consumed before the provider mutation. Any
 		// ambiguous result reconciles through STATUS and can never be replayed.
 		consumePendingReviewConsent(pending, pendingReviewConsents);
+		let completed: Record<string, unknown>;
 		try {
 			const answered = await nativeReviewCli.answerConsent({
 				cwd: pending.authorityCwd,
@@ -5134,7 +6040,7 @@ async function executeReviewControllerOperation(
 					...nativeStartPreAuthorityRejection(),
 				};
 			}
-			return completeNativeStart(parameters.operation, answered.start, pending.repositoryCwd, pending.candidateView, candidateViews);
+			completed = completeNativeStart(parameters.operation, answered.start, pending.repositoryCwd, pending.candidateView, candidateViews);
 		} catch (error) {
 			const value = error as { mutationOutcome?: unknown };
 			if (value.mutationOutcome === "none") candidateViews?.cleanup(pending.candidateView.token);
@@ -5144,6 +6050,16 @@ async function executeReviewControllerOperation(
 				projection: "workspace",
 			});
 		}
+		if (input.answer === "granted") {
+			try {
+				writeReviewConsentLatch(pending.repositoryCwd);
+			} catch (error) {
+				try {
+					context?.ui.notify(`Native review start completed, but Pi could not record the local consent latch: ${error instanceof Error ? error.message : String(error)}`, "warning");
+				} catch { /* Reporting is best effort; native completion remains authoritative. */ }
+			}
+		}
+		return completed;
 	}
 	if (parameters.operation === REVIEW_CONTROLLER_OPERATION.START) {
 		const rawStart = parseControllerJson(
@@ -5151,16 +6067,11 @@ async function executeReviewControllerOperation(
 			REVIEW_CONTROLLER_OPERATION.START,
 		);
 		if (rawStart.mode === REVIEW_MODE.ORDINARY) {
-			try {
-				const gated = await resolveReviewModeGate(nativeReviewCli, parameters.operation, defaultCwd, signal);
-				if (gated !== undefined) return gated;
-			} catch (error) {
-				return nativeOperationFailure(parameters.operation, error);
-			}
-			if (nativeReviewCli?.targetStatus === undefined) return nativeStatusUnsupported(parameters.operation);
 			if ("policyHash" in rawStart) return nativeStartRejection("legacy-policy-hash-unsupported");
-			const unknownField = Object.keys(rawStart).find((field) => !["mode", "baseRef", "committedOnly", "policyPath"].includes(field));
+			const unknownField = Object.keys(rawStart).find((field) => !["mode", "baseRef", "committedOnly", "policyPath", "focus"].includes(field));
 			if (unknownField !== undefined) return nativeStartRejection("unknown-field", unknownField);
+			const focus = rawStart.focus;
+			if (focus !== undefined && !isNativeStartFocus(focus)) return nativeStartRejection("focus-invalid");
 			const policy: NativeStartPolicyValidation = rawStart.policyPath === undefined
 				? {}
 				: validateNativeStartPolicyPath(defaultCwd, rawStart.policyPath);
@@ -5174,10 +6085,18 @@ async function executeReviewControllerOperation(
 				try {
 					canonicalBaseRef = resolveCanonicalCandidateBase(defaultCwd, baseRef).commit;
 				} catch (error) {
+					if (error instanceof CandidateViewError && error.diagnostics !== undefined) return nativeOperationFailure(parameters.operation, Object.assign(error, { candidateViewPreNative: true }));
 					if (error instanceof CandidateViewError && (error.reason === "base-ref-ambiguous" || error.reason === "base-ref-unresolvable" || error.reason === "base-ref-moved")) return nativeStartRejection(error.reason);
 					return nativeStartRejection("base-ref-unresolvable");
 				}
 			}
+			try {
+				const gated = await resolveReviewModeGate(nativeReviewCli, parameters.operation, defaultCwd, signal);
+				if (gated !== undefined) return gated;
+			} catch (error) {
+				return nativeOperationFailure(parameters.operation, error);
+			}
+			if (nativeReviewCli?.targetStatus === undefined) return nativeStatusUnsupported(parameters.operation);
 			let target: ReviewStatusV3;
 			try {
 				target = await nativeReviewCli.targetStatus({
@@ -5191,6 +6110,12 @@ async function executeReviewControllerOperation(
 				return nativeOperationFailure(parameters.operation, error);
 			}
 			const replayKey = JSON.stringify({ cwd: defaultCwd, lineageId: parameters.lineageId ?? null, input: parameters.input ?? null, inputPath: parameters.inputPath ?? null });
+			// Synchronously drop any binding whose TTL has already elapsed
+			// before reusing its retained candidate view, so a fresh-candidate
+			// retry cannot reuse a view tied to an expired binding and trip
+			// candidate-target-projection-drift. Timer order must not decide
+			// correctness: the queued cleanup macrotask may not have fired yet.
+			pruneExpiredReviewConsents(pendingReviewConsents, candidateViews, reviewConsentNow);
 			let candidateView: ReturnType<CandidateViewRegistry["create"]> | undefined;
 			let nativeStartAttempted = false;
 			try {
@@ -5208,6 +6133,7 @@ async function executeReviewControllerOperation(
 						projection: target.projection.projection,
 						...(parameters.lineageId === undefined ? {} : { lineageId: parameters.lineageId }),
 						...(policy.policyPath === undefined ? {} : { policyPath: policy.policyPath }),
+						...(focus === undefined ? {} : { focus }),
 						...(signal === undefined ? {} : { signal }),
 					});
 				} catch (error) {
@@ -5216,13 +6142,13 @@ async function executeReviewControllerOperation(
 					const consentCandidateView = candidateView;
 					const repositoryCwd = realpathSync(defaultCwd);
 					const consentDigest = reviewConsentDigest(error.consent);
-					const existing = [...pendingReviewConsents.values()].find((pending) => pending.repositoryCwd === repositoryCwd && pending.candidateView.token === consentCandidateView.token && pending.consentDigest === consentDigest && pending.expiresAt > Date.now());
+					const existing = [...pendingReviewConsents.values()].find((pending) => pending.repositoryCwd === repositoryCwd && pending.candidateView.token === consentCandidateView.token && pending.consentDigest === consentDigest && pending.expiresAt > reviewConsentNow());
 					if (existing === undefined) for (const pending of [...pendingReviewConsents.values()]) if (pending.candidateView.token === consentCandidateView.token) consumePendingReviewConsent(pending, pendingReviewConsents);
 					const id = existing?.id ?? randomUUID();
 					if (existing === undefined) {
-						const pending: PendingReviewConsent = { id, repositoryCwd, authorityCwd: defaultCwd, candidateView: consentCandidateView, consent: error.consent, consentDigest, expiresAt: Date.now() + PENDING_REVIEW_CONSENT_TTL_MS };
+						const pending: PendingReviewConsent = { id, repositoryCwd, authorityCwd: defaultCwd, candidateView: consentCandidateView, consent: error.consent, consentDigest, expiresAt: reviewConsentNow() + PENDING_REVIEW_CONSENT_TTL_MS };
 						pendingReviewConsents.set(id, pending);
-						pending.expiry = setTimeout(() => cleanupPendingReviewConsent(pending, pendingReviewConsents, candidateViews), PENDING_REVIEW_CONSENT_TTL_MS);
+						pending.expiry = reviewConsentScheduleTimer(() => cleanupPendingReviewConsent(pending, pendingReviewConsents, candidateViews), PENDING_REVIEW_CONSENT_TTL_MS);
 						pending.expiry.unref();
 					}
 					return {
@@ -5236,6 +6162,7 @@ async function executeReviewControllerOperation(
 				}
 				return completeNativeStart(parameters.operation, result, defaultCwd, candidateView, candidateViews);
 			} catch (error) {
+				if (error instanceof CandidateViewError && error.diagnostics !== undefined) return nativeOperationFailure(parameters.operation, Object.assign(error, { candidateViewPreNative: true }));
 				if (error instanceof CandidateViewError && (error.reason === "base-ref-ambiguous" || error.reason === "base-ref-unresolvable" || error.reason === "base-ref-moved")) return nativeStartRejection(error.reason);
 				const value = error as { mutationOutcome?: unknown; nextAction?: unknown };
 				const provenNoMutation = value.mutationOutcome === "none";
@@ -5328,22 +6255,180 @@ async function executeReviewControllerOperation(
 			let correctionCompletion = false;
 			let negotiatedStatus: ReviewStatusV3 | undefined;
 			let candidateView: ReturnType<CandidateViewRegistry["create"]> | undefined;
-			let nativeResult: NativeFinalizeResult;
+			let provisionalCandidateView: ReturnType<CandidateViewRegistry["create"]> | undefined;
+			let nativeResult: NativeFinalizeResult | undefined;
 			let correctionStep: CorrectionStep | undefined;
+			let transportRefusal: ReviewTransportRefusal | undefined;
 			try {
 				if (parameters.lineageId === undefined) throw new CandidateViewError("Native FINALIZE requires an explicit lineage");
-				negotiatedStatus = await nativeReviewCli.targetStatus({ cwd: defaultCwd, lineageId: parameters.lineageId, ...(signal === undefined ? {} : { signal }) });
-				if (negotiatedStatus.applicability !== "current_target" || negotiatedStatus.authority?.lineageId !== parameters.lineageId || (negotiatedStatus.action !== "finalize" && negotiatedStatus.action !== "reconcile_finalize")) return mapNativeTargetStatus(parameters.operation, negotiatedStatus, parameters.lineageId);
-				correctionCompletion = input.review_result === undefined && (input.validation !== undefined || input.validation_proof !== undefined) && input.final_evidence !== undefined;
-				const validationAttempt = input.review_result === undefined && input.correction_line_forecast === undefined && input.final_evidence !== undefined;
-				// A correction-forecast-only FINALIZE (the pre-edit forecast step in
-				// correction_required) must also participate in fresh-process projection
-				// reconstruction; before #176 it skipped restoration and failed against
-				// an empty in-memory registry without ever invoking native FINALIZE.
-				const correctionForecast = input.review_result === undefined && input.correction_line_forecast !== undefined;
+				correctionCompletion = input.validation !== undefined && input.final_evidence !== undefined;
+				const validationAttempt = input.correction_line_forecast === undefined && input.final_evidence !== undefined;
 				const replayKey = JSON.stringify({ cwd: defaultCwd, lineageId: parameters.lineageId ?? null, input: parameters.input ?? null, inputPath: parameters.inputPath ?? null });
-				if ((validationAttempt || input.review_result !== undefined || correctionForecast) && candidateViews && !candidateViews.hasProjection(parameters.lineageId)) {
-					const projection = input.review_result === undefined ? negotiatedStatus.projection : providerReviewerProjection(negotiatedStatus);
+				if (candidateViews?.hasProjection(parameters.lineageId)) {
+					candidateViews.resolveProjection(parameters.lineageId, defaultCwd);
+					candidateView = correctionCompletion || validationAttempt
+						? candidateViews.createCorrected(parameters.lineageId, defaultCwd, replayKey)
+						: candidateViews.resolveForFinalize(parameters.lineageId);
+				} else if (candidateViews) {
+					provisionalCandidateView = candidateViews.createOrReuse({ contributorRoot: defaultCwd, replayKey: `${replayKey}:status-candidate` });
+					candidateView = provisionalCandidateView;
+				}
+				candidateView?.verify();
+				const statusCandidateRoot = candidateView?.root ?? defaultCwd;
+				// Name the host's reviewer transport so the provider offers its
+				// materialize-marked relay slot; a provider without that
+				// transport answers the agent-less status and its typed refusal
+				// travels with the result.
+				const negotiated = await negotiatedStatusForHostTransport(nativeReviewCli, { cwd: statusCandidateRoot, lineageId: parameters.lineageId, ...(signal === undefined ? {} : { signal }) });
+				negotiatedStatus = negotiated.status;
+				transportRefusal = negotiated.transport;
+				if (negotiatedStatus.applicability !== "current_target" || negotiatedStatus.authority?.lineageId !== parameters.lineageId || (negotiatedStatus.action !== "finalize" && negotiatedStatus.action !== "reconcile_finalize")) {
+					if (provisionalCandidateView && candidateViews) {
+						candidateViews.cleanup(provisionalCandidateView.token);
+						provisionalCandidateView = undefined;
+						candidateView = undefined;
+					}
+					return mapNativeTargetStatus(parameters.operation, negotiatedStatus, parameters.lineageId);
+				}
+				if (provisionalCandidateView && candidateViews) {
+					candidateViews.cleanup(provisionalCandidateView.token);
+					provisionalCandidateView = undefined;
+					candidateView = undefined;
+				}
+				// Live smoke root cause (2026-08-16, dev binary 2.4.0-main):
+				// status/v5 mints the opaque --repository-context handle bound to
+				// the STATUS query root, and every rendered payload embeds it. A
+				// context minted from a frozen candidate-view root fails the live
+				// emitter's committed-intent reconciliation on the next lifecycle
+				// operation, so on v5 the lane rebinds its negotiated STATUS to
+				// the workspace root before executing any rendered payload.
+				// Pinned pre-v5 emitters keep the frozen-view status untouched.
+				if (statusCandidateRoot !== defaultCwd && (negotiatedStatus.raw as { schema?: unknown }).schema === "gentle-ai.review-integration.status/v5") {
+					const rebound = await negotiatedStatusForHostTransport(nativeReviewCli, { cwd: defaultCwd, lineageId: parameters.lineageId, ...(signal === undefined ? {} : { signal }) });
+					const workspaceStatus = rebound.status;
+					transportRefusal = rebound.transport;
+					if (workspaceStatus.authority?.lineageId !== parameters.lineageId || workspaceStatus.authority.revision !== negotiatedStatus.authority.revision) {
+						throw new CandidateViewError("workspace-root status no longer matches the negotiated lifecycle authority", "workspace-status-rebind-drift");
+					}
+					negotiatedStatus = workspaceStatus;
+				}
+				// gentle-pi#311 P4: pi-slot capture inputs route through the host
+				// relay ONLY when the provider issued the --materialize token on
+				// the collect input. Every other slot and lane stays untouched.
+				const hostRelaySlots = negotiatedStatus.nextTransition?.kind === "collect"
+					? reviewHostRelaySlots(negotiatedStatus.nextTransition.collect?.inputs ?? [])
+					: [];
+				if (hostRelaySlots.length > 0 && input.final_evidence === undefined && input.correction_line_forecast === undefined) {
+					// One cost/side-effect forecast BEFORE launch, once per
+					// FINALIZE and never per lens: each host-relay slot runs a
+					// real locked-down `pi` reviewer subprocess against the
+					// user's own model, so an unacknowledged finalize would spend
+					// tokens as a silent side effect of what reads like
+					// bookkeeping. Same acknowledgement shape the adapter already
+					// uses for consequential inputs (committedOnly): the caller
+					// states the cost it accepts, which keeps headless callers
+					// working without an interactive prompt.
+					if (input.reviewer_run_acknowledged !== true) {
+						const forecastLenses = hostRelaySlots.map((slot, index) => slot.lens ?? `slot-${index}`);
+						return {
+							operation: parameters.operation,
+							status: "blocked",
+							outcome: "reviewer-model-run-forecast",
+							reason: `Finalize is about to run ${hostRelaySlots.length} real reviewer model run${hostRelaySlots.length === 1 ? "" : "s"} through the pi host relay (${forecastLenses.join(", ")}), one locked-down pi subprocess per outstanding lens, in the foreground. This spends model tokens on your configured model and provider.`,
+							cost_forecast: {
+								transport: "pi_host_relay",
+								model_runs: hostRelaySlots.length,
+								lenses: forecastLenses,
+								side_effects: [
+									"one locked-down pi subprocess per lens, in an empty scratch directory with every discovery surface disabled",
+									"each captured reviewer result is admitted natively into this lineage's authority",
+									"no candidate file, index, or commit is modified",
+								],
+								model_selection: "user-owned: the relay never sets --model, --provider, or --profile",
+							},
+							mutation_performed: false,
+							mutation_outcome: "none",
+							next_action: "Re-run finalize with {\"reviewer_run_acknowledged\": true} to authorize exactly this reviewer work.",
+						};
+					}
+					// The relay itself needs no candidate view (it consumes only
+					// provider-issued tokens), but a session that dispatches a
+					// reviewer by hand on this same lineage does. Hydrate here too
+					// so both routes work; it is best-effort and never fails the
+					// relay.
+					const relayDispatchBinding = hydrateDispatchBindingFromStatus(candidateViews, defaultCwd, negotiatedStatus);
+					const relayResult = await executeReviewHostRelayCollection(parameters.operation, parameters.lineageId, hostRelaySlots, nativeReviewCli, defaultCwd, signal);
+					return relayDispatchBinding === undefined ? relayResult : { ...relayResult, dispatch_binding: relayDispatchBinding };
+				}
+				// gentle-pi#311 P4-roles: the provider renders the non-lens
+				// adversarial roles as self-contained --execute vectors; each is
+				// run exactly as rendered and STATUS is re-queried. Nothing here
+				// authors, parses, or transports role output.
+				const roleVectorSlots = negotiatedStatus.nextTransition?.kind === "collect"
+					? reviewProviderRoleVectorSlots(negotiatedStatus.nextTransition.collect?.inputs ?? [])
+					: [];
+				if (roleVectorSlots.length > 0 && input.final_evidence === undefined && input.correction_line_forecast === undefined && input.validation === undefined) {
+					return await executeProviderRoleVectorCollection(parameters.operation, parameters.lineageId, roleVectorSlots, nativeReviewCli, defaultCwd, signal);
+				}
+				// Live defect (2026-08-16, Engram #12466): FINALIZE on a lineage
+				// still at reviewer_results_required misrouted into the correction
+				// evidence-first-ordering lane and failed. Route strictly from the
+				// provider transition: a collect naming review.capture-result means
+				// reviewer results are still outstanding — no correction-evidence
+				// or targeted-validation lane is ever admissible here, so any
+				// document-carrying FINALIZE stops with the provider-offered step.
+				// A document-free FINALIZE stops too on the live status/v5 lane
+				// (the same v5 keying as the workspace rebind above); the pinned
+				// pre-v5 raw-finalize fallback keeps its native captured-results
+				// discovery unchanged. Materialize-marked pi slots were already
+				// routed through the host relay above.
+				const reviewerResultsOutstanding = negotiatedStatus.nextTransition?.kind === "collect"
+					&& (negotiatedStatus.nextTransition.collect?.inputs ?? []).some((collectInput) => collectInput.captureOperation === "review.capture-result");
+				const finalizeDocumentsPresent = input.final_evidence !== undefined || input.validation !== undefined || input.correction_line_forecast !== undefined;
+				if (reviewerResultsOutstanding && (finalizeDocumentsPresent || (negotiatedStatus.raw as { schema?: unknown }).schema === "gentle-ai.review-integration.status/v5")) {
+					const outstandingReviewerLenses = pendingReviewerLenses(negotiatedStatus);
+					if (candidateView !== undefined && candidateViews && (correctionCompletion || validationAttempt)) candidateViews.cleanup(candidateView.token);
+					// Field report (2026-08-16): this lane is where the reported
+					// flow actually learns reviewer results are outstanding, and
+					// the reviewer dispatch follows it directly. Hydrate the
+					// dispatch binding from the authoritative status just decoded
+					// — against the workspace root, never a frozen view root —
+					// and report the outcome either way.
+					const dispatchBinding = hydrateDispatchBindingFromStatus(candidateViews, defaultCwd, negotiatedStatus);
+					return {
+						operation: parameters.operation,
+						status: "blocked",
+						outcome: "reviewer-results-required",
+						reason: transportRefusal === undefined
+							? "Capture the reviewer result first; the provider offers review.capture-result. Correction evidence and targeted validation are never admissible while reviewer results are outstanding."
+							: `Capture the reviewer result first; the provider offers review.capture-result. This provider does not admit the pi reviewer transport (${transportRefusal.code}), so it offers no host-relay slot: ${transportRefusal.message}`,
+						...(outstandingReviewerLenses.length === 0 ? {} : { pending_lenses: outstandingReviewerLenses }),
+						...(dispatchBinding === undefined ? {} : { dispatch_binding: dispatchBinding }),
+						...(transportRefusal === undefined ? {} : { relay_transport: transportRefusal }),
+						result: negotiatedStatus.raw,
+						mutation_performed: false,
+						mutation_outcome: "none",
+						next_action: "review.capture-result",
+					};
+				}
+				// Ordinary final verification (field defect, 2026-08-16): at
+				// native state `validating` the provider collects one final
+				// `review.capture-evidence` record and then offers exactly one
+				// execute `review.finalize --captured-evidence` transition. This
+				// lane is provider-owned end to end: it is not a correction
+				// transaction, no targeted validation exists in it, and no
+				// candidate view is materialized — the workspace root IS the
+				// unchanged frozen candidate, native FINALIZE validates the live
+				// snapshot itself, and the provider binds its repository-context
+				// effects to the root the lifecycle runs from. The correction
+				// lane keeps its pre-capture state `correction_required` and
+				// stays byte-identical below.
+				const ordinaryFinalVerification = validationAttempt &&
+					negotiatedStatus.authority?.state === "validating" &&
+					negotiatedStatus.validationRequest === undefined &&
+					!(negotiatedStatus.nextTransition?.kind === "collect" && (negotiatedStatus.nextTransition.collect?.inputs ?? []).some(isTargetedValidationCollectInput));
+				if (candidateViews && !ordinaryFinalVerification && !candidateViews.hasProjection(parameters.lineageId)) {
+					const projection = negotiatedStatus.projection;
 					candidateView = validationAttempt
 						? (candidateViews.restoreProjectionFromNative(parameters.lineageId, defaultCwd, projection), undefined)
 						: candidateViews.restoreForFinalizeFromNative(parameters.lineageId, defaultCwd, projection);
@@ -5351,25 +6436,102 @@ async function executeReviewControllerOperation(
 				// Fail closed before any native mutation when the frozen projection
 				// belongs to a different worktree than the requested workspace (#169).
 				if (candidateViews && parameters.lineageId && candidateViews.hasProjection(parameters.lineageId)) candidateViews.resolveProjection(parameters.lineageId, defaultCwd);
-				candidateView ??= candidateViews && parameters.lineageId ? (correctionCompletion || validationAttempt) ? candidateViews.createCorrected(parameters.lineageId, defaultCwd, replayKey) : candidateViews.resolveForFinalize(parameters.lineageId) : undefined;
-				if (validationAttempt && candidateView && parameters.lineageId) {
-					if (nativeReviewCli.captureEvidence === undefined) throw new CandidateViewError("native correction evidence capture is unavailable", "evidence-first-ordering");
+				candidateView ??= candidateViews && parameters.lineageId && !ordinaryFinalVerification ? (correctionCompletion || validationAttempt) ? candidateViews.createCorrected(parameters.lineageId, defaultCwd, replayKey) : candidateViews.resolveForFinalize(parameters.lineageId) : undefined;
+				// Field defect (Engram #12547): a FINALIZE that merely follows the
+				// provider's own execute transition carries no documents, so
+				// neither correctionCompletion nor validationAttempt holds and the
+				// START-time reviewer view is resolved. After an admitted bounded
+				// correction the candidate identity has legitimately moved, so
+				// that view is compared against the corrected target the provider
+				// itself authorized and every finalize fails as drift — no receipt
+				// is ever minted, while a fresh process finalizes the same lineage
+				// fine because it restores from the native descriptor. Re-derive
+				// the binding from that same descriptor here instead of reading a
+				// retired reviewer view as drift. It is not a relaxation: the
+				// replacement is materialized from Git, must match the provider
+				// descriptor exactly, and is asserted immediately below.
+				if (
+					candidateView !== undefined && candidateViews && parameters.lineageId && !ordinaryFinalVerification &&
+					candidateView.candidateTree !== negotiatedStatus.projection.currentCandidateTree
+				) {
+					candidateView = candidateViews.rebindForFinalizeFromNative(parameters.lineageId, defaultCwd, negotiatedStatus.projection);
+				}
+				if (candidateView !== undefined) assertNativeFinalizeCandidateBinding(candidateView, negotiatedStatus);
+				if (ordinaryFinalVerification && parameters.lineageId) {
+					// A projection held by this process routes the top-of-try path
+					// through createCorrected before the lane is known; that view
+					// is unused here — the lifecycle runs from the workspace root.
+					if (candidateView !== undefined && candidateViews) {
+						candidateViews.cleanup(candidateView.token);
+						candidateView = undefined;
+					}
+					if (nativeReviewCli.captureEvidence === undefined && nativeReviewCli.captureEvidenceSubmission === undefined) throw new CandidateViewError("native final verification evidence capture is unavailable", "final-verification-provider-owned");
 					const outcome = correctionOutcome(input);
-					if (outcome === undefined || negotiatedStatus.authority === undefined) throw new CandidateViewError("native correction evidence requires one authoritative outcome-bound status", "evidence-first-ordering");
-					requireEvidenceCollection(negotiatedStatus);
-					const captured = await nativeReviewCli.captureEvidence({
+					if (outcome === undefined || negotiatedStatus.authority === undefined) throw new CandidateViewError("native final verification evidence requires one authoritative outcome-bound status", "final-verification-provider-owned");
+					if (input.validation !== undefined) {
+						throw new CandidateViewError("native final verification is provider-owned; a targeted validation document is not admissible at state validating", "final-verification-provider-owned");
+					}
+					const evidenceSlot = requireEvidenceCollection(negotiatedStatus);
+					const evidenceBinding = resolveEvidenceCaptureBinding(evidenceSlot, negotiatedStatus, parameters.lineageId, outcome);
+					const captured = await captureEvidenceForCollection(nativeReviewCli, evidenceBinding, defaultCwd, parameters.lineageId, outcome, input.final_evidence!, signal);
+					if (
+						captured.lineageId !== parameters.lineageId || captured.authorityRevision !== evidenceBinding.expectedRevision ||
+						captured.targetIdentity !== evidenceBinding.targetIdentity || captured.candidateTree !== negotiatedStatus.projection.currentCandidateTree ||
+						evidencePathsDrift(captured, evidenceBinding, negotiatedStatus) ||
+						captured.outcome !== outcome
+					) {
+						throw new CandidateViewError("captured final verification evidence does not match the requested lineage, target, and outcome", "correction-evidence-binding-drift");
+					}
+					// Follow the provider transition faithfully: re-query
+					// negotiated STATUS and execute only the exact rendered
+					// `review.finalize` transition it offers for the captured
+					// evidence. Never demand targeted validation here and never
+					// substitute the validate gate.
+					const afterEvidence = await nativeReviewCli.targetStatus({ cwd: defaultCwd, lineageId: parameters.lineageId, ...(signal === undefined ? {} : { signal }) });
+					if (afterEvidence.authority?.lineageId !== parameters.lineageId) throw new CandidateViewError("post-evidence status lost the final-verification lineage", "correction-evidence-binding-drift");
+					if (afterEvidence.validationRequest !== undefined || (afterEvidence.nextTransition?.kind === "collect" && (afterEvidence.nextTransition.collect?.inputs ?? []).some(isTargetedValidationCollectInput))) {
+						throw new CandidateViewError("final verification evidence unexpectedly unlocked targeted validation", "final-verification-provider-owned");
+					}
+					const evidenceTransition = afterEvidence.nextTransition?.kind === "execute" && afterEvidence.nextTransition.execute?.operation === "review.finalize"
+						? afterEvidence.nextTransition.execute
+						: undefined;
+					if (evidenceTransition === undefined || nativeReviewCli.finalizeTransition === undefined) {
+						// Fail closed on an unrecognized transition: report the
+						// committed capture and the provider's own status verbatim.
+						return {
+							...mapNativeTargetStatus(parameters.operation, afterEvidence, parameters.lineageId),
+							outcome: "final-verification-transition-unavailable",
+							verification_evidence: { outcome: captured.outcome, record_digest: captured.recordDigest },
+							mutation_performed: true,
+							mutation_outcome: "committed",
+						};
+					}
+					if (evidenceTransition.binding.lineageId !== undefined && evidenceTransition.binding.lineageId !== parameters.lineageId) {
+						throw new CandidateViewError("provider finalize transition is bound to a different lineage", "finalize-transition-binding-drift");
+					}
+					nativeResult = await nativeReviewCli.finalizeTransition({
 						cwd: defaultCwd,
-						lineageId: parameters.lineageId,
-						targetIdentity: negotiatedStatus.targetIdentity,
-						expectedRevision: negotiatedStatus.authority.revision,
-						outcome,
-						evidenceDocument: input.final_evidence!,
+						// The exact rendered tokens, verbatim and in provider
+						// order; the hyphenated fallback mirrors the provider's
+						// published rendering rule for older payloads.
+						argumentTokens: evidenceTransition.arguments.map((argument) => argument.token ?? `--${argument.name.replaceAll("_", "-")}=${argument.value}`),
 						...(signal === undefined ? {} : { signal }),
 					});
+					if (nativeResult.lineageId !== parameters.lineageId) {
+						throw new CandidateViewError("provider finalize transition answered for a different lineage", "finalize-transition-binding-drift");
+					}
+				}
+				if (validationAttempt && !ordinaryFinalVerification && candidateView && parameters.lineageId) {
+					if (nativeReviewCli.captureEvidence === undefined && nativeReviewCli.captureEvidenceSubmission === undefined) throw new CandidateViewError("native correction evidence capture is unavailable", "evidence-first-ordering");
+					const outcome = correctionOutcome(input);
+					if (outcome === undefined || negotiatedStatus.authority === undefined) throw new CandidateViewError("native correction evidence requires one authoritative outcome-bound status", "evidence-first-ordering");
+					const evidenceSlot = requireEvidenceCollection(negotiatedStatus);
+					const evidenceBinding = resolveEvidenceCaptureBinding(evidenceSlot, negotiatedStatus, parameters.lineageId, outcome);
+					const captured = await captureEvidenceForCollection(nativeReviewCli, evidenceBinding, candidateView.root, parameters.lineageId, outcome, input.final_evidence!, signal);
 					if (
-						captured.lineageId !== parameters.lineageId || captured.authorityRevision !== negotiatedStatus.authority.revision ||
-						captured.targetIdentity !== negotiatedStatus.targetIdentity || captured.candidateTree !== negotiatedStatus.projection.currentCandidateTree || captured.candidateTree !== candidateView.candidateTree ||
-						captured.pathsDigest !== negotiatedStatus.projection.pathsDigest || JSON.stringify([...captured.paths].sort()) !== JSON.stringify([...negotiatedStatus.projection.paths].sort()) ||
+						captured.lineageId !== parameters.lineageId || captured.authorityRevision !== evidenceBinding.expectedRevision ||
+						captured.targetIdentity !== evidenceBinding.targetIdentity || captured.candidateTree !== negotiatedStatus.projection.currentCandidateTree || captured.candidateTree !== candidateView.candidateTree ||
+						evidencePathsDrift(captured, evidenceBinding, negotiatedStatus) ||
 						captured.outcome !== outcome
 					) {
 						throw new CandidateViewError("captured correction evidence does not match the requested lineage, target, and outcome", "correction-evidence-binding-drift");
@@ -5391,11 +6553,13 @@ async function executeReviewControllerOperation(
 					}
 					correctionStep = resolveCorrectionStep({
 						lineageId: parameters.lineageId,
-						targetIdentity: negotiatedStatus.targetIdentity,
-						authorityRevision: negotiatedStatus.authority.revision,
+						targetIdentity: evidenceBinding.targetIdentity,
+						authorityRevision: evidenceBinding.expectedRevision,
 						correctionBudget: negotiatedStatus.frozen?.correctionBudget ?? 0,
 						changedLinesCharged: 0,
 					}, evidence);
+					// Workspace-bound like the pre-capture rebind above: rendered
+					// validation payloads embed the context this status mints.
 					const afterEvidence = await nativeReviewCli.targetStatus({ cwd: defaultCwd, lineageId: parameters.lineageId, ...(signal === undefined ? {} : { signal }) });
 					if (afterEvidence.authority?.lineageId !== parameters.lineageId) throw new CandidateViewError("post-evidence status lost the correction lineage", "correction-evidence-binding-drift");
 					if (correctionStep.kind === "recapture-required") {
@@ -5416,55 +6580,143 @@ async function executeReviewControllerOperation(
 					const validationRequest = requireTargetedValidationAfterEvidence(afterEvidence);
 					correctionEvidenceByLineage.delete(parameters.lineageId);
 					negotiatedStatus = afterEvidence;
+					// gentle-pi#311 P4-roles: when the provider offers targeted
+					// validation as a self-contained capture-validation vector, the
+					// verdict is Go-owned — a Pi-authored validation document is not
+					// admissible for it, and the next FINALIZE call executes the
+					// vector exactly as rendered.
+					const validationVectors = afterEvidence.nextTransition?.kind === "collect"
+						? reviewProviderRoleVectorSlots(afterEvidence.nextTransition.collect?.inputs ?? [])
+						: [];
+					if (validationVectors.length > 0) {
+						candidateViews.cleanup(candidateView.token);
+						if (input.validation !== undefined) {
+							return {
+								operation: parameters.operation,
+								status: "blocked",
+								outcome: "targeted-validation-is-provider-owned",
+								reason: "The provider rendered targeted validation as a self-contained review.capture-validation vector: Go materializes the validator prompt and runs its own locked-down pi process, so a Pi-authored validation document is not admissible.",
+								correction_step: correctionStep,
+								mutation_performed: true,
+								mutation_outcome: "committed",
+								next_action: "Re-run finalize without validation; the provider-rendered vector executes verbatim and STATUS is re-queried.",
+							};
+						}
+						return { ...mapNativeTargetStatus(parameters.operation, afterEvidence, parameters.lineageId), correction_step: correctionStep };
+					}
 					if (input.validation === undefined) {
 						candidateViews.cleanup(candidateView.token);
 						return { ...mapNativeTargetStatus(parameters.operation, afterEvidence, parameters.lineageId), correction_step: correctionStep };
 					}
-					if (input.validation_proof !== undefined) throw new Error("Negotiated FINALIZE requires the native targeted validation document");
 					if (input.validation.request_hash !== validationRequest.requestHash.replace(/^sha256:/, "") || JSON.stringify([...input.validation.correction_ids].sort()) !== JSON.stringify([...validationRequest.fixFindingIds].sort())) {
 						throw new CandidateViewError("targeted validation document does not match the provider request", "targeted-validation-binding-drift");
 					}
-				}
-				if (input.review_result !== undefined) {
-					if (parameters.lineageId === undefined) throw new CandidateViewError("Native FINALIZE requires an explicit lineage for refuter derivation");
-					let request;
-					try {
-						request = deriveNativeRefuterRequest({ lineageId: parameters.lineageId, ...(candidateView === undefined ? {} : { candidateTree: candidateView.candidateTree }), reviewResult: input.review_result });
-					} catch (error) {
-						if (!(error instanceof CompactReviewContractError) || error.code !== "candidate-tree") throw error;
-						const candidateTree = captureLiveReviewCandidateBinding({
+					const validationSubmission = finalizeSubmissionSlot(negotiatedStatus, "validation");
+					if (validationSubmission !== undefined) {
+						if (nativeReviewCli.finalizeSubmission === undefined) throw new CandidateViewError("native finalize submission execution is unavailable", "finalize-transition-binding-drift");
+						nativeResult = await nativeReviewCli.finalizeSubmission({
+							// The rendered tokens are self-contained (the opaque
+							// --repository-context binds the repository); the process
+							// runs from the authority workspace root — a frozen
+							// candidate-view root is a different toplevel of the same
+							// store and fails the live emitter's effect binding.
 							cwd: defaultCwd,
-							repositoryId: resolveRepositoryAuthorityV1(defaultCwd).repository_id,
-						}).initial_review_tree;
-						request = deriveNativeRefuterRequest({ lineageId: parameters.lineageId, candidateTree, reviewResult: input.review_result });
+							argumentTokens: validationSubmission.argumentTokens,
+							valueSubstitutionLocation: validationSubmission.value.substitutionLocation,
+							// The rendered submission consumes the raw validator
+							// artifact, so the request binding rides inside it.
+							valueDocument: JSON.stringify({
+								targeted_validation_request_hash: validationRequest.requestHash,
+								correction_target_identity: validationRequest.correctionTargetIdentity,
+								...toNativeValidatorDocument(input.validation),
+							}),
+							...(signal === undefined ? {} : { signal }),
+						});
+						if (nativeResult.lineageId !== parameters.lineageId) {
+							throw new CandidateViewError("provider finalize submission answered for a different lineage", "finalize-transition-binding-drift");
+						}
 					}
-					if (request !== undefined && input.refuter_batch === undefined) {
-						return { operation: parameters.operation, status: "blocked", outcome: "refuter-required", lineage_created: false, mutation_performed: false, mutation_outcome: "none", refuter_request: request };
+				}
+				// gentle-pi#311 P5: when the provider's negotiated transition IS a
+				// review.finalize execution (captured_results_ready), run it exactly
+				// as rendered — the provider discovers its own admitted lens and
+				// role slots. Pi never assembles reviewer, refuter, or validator
+				// documents for this lane; the remaining document lanes below
+				// (correction forecast, targeted validation, final evidence) are the
+				// negotiated collection answers the pinned provider still consumes
+				// through --correction-lines/--validation/--evidence.
+				const finalizeTransition = negotiatedStatus.nextTransition?.kind === "execute" && negotiatedStatus.nextTransition.execute?.operation === "review.finalize"
+					? negotiatedStatus.nextTransition.execute
+					: undefined;
+				if (
+					nativeResult === undefined &&
+					finalizeTransition !== undefined && nativeReviewCli.finalizeTransition !== undefined &&
+					input.validation === undefined && input.final_evidence === undefined && input.correction_line_forecast === undefined
+				) {
+					if (finalizeTransition.binding.lineageId !== undefined && finalizeTransition.binding.lineageId !== parameters.lineageId) {
+						throw new CandidateViewError("provider finalize transition is bound to a different lineage", "finalize-transition-binding-drift");
 					}
-					if (request !== undefined && input.review_result.refuter_request_hash !== request.request_hash) {
-						throw new Error("Native FINALIZE refuter_request_hash must exactly match the controller-derived request");
+					nativeResult = await nativeReviewCli.finalizeTransition({
+						// The provider binds this transition's effects to the root
+						// the lifecycle runs from (live smoke, 2026-08-16): running
+						// the rendered vector from a frozen candidate-view root
+						// records a mismatched repository binding that fails every
+						// later committed-intent reconciliation. The workspace root
+						// IS the frozen candidate here; run from it.
+						cwd: defaultCwd,
+						// The exact rendered tokens, verbatim and in provider order.
+						// The provider tokenizes each argument itself; the hyphenated
+						// fallback mirrors its published rendering rule for older
+						// payloads that omit the token field.
+						argumentTokens: finalizeTransition.arguments.map((argument) => argument.token ?? `--${argument.name.replaceAll("_", "-")}=${argument.value}`),
+						...(signal === undefined ? {} : { signal }),
+					});
+					if (parameters.lineageId !== undefined && nativeResult.lineageId !== parameters.lineageId) {
+						throw new CandidateViewError("provider finalize transition answered for a different lineage", "finalize-transition-binding-drift");
 					}
-					if (request === undefined && (input.review_result.refuter_request_hash !== undefined || input.refuter_batch !== undefined)) {
-						throw new Error("Native FINALIZE refuter material is invalid without inferential candidate-caused severe findings");
+				} else if (nativeResult === undefined) {
+					const planSubmission = input.correction_line_forecast === undefined ? undefined : finalizeSubmissionSlot(negotiatedStatus, "correction_lines");
+					if (planSubmission !== undefined) {
+						if (nativeReviewCli.finalizeSubmission === undefined) throw new CandidateViewError("native finalize submission execution is unavailable", "finalize-transition-binding-drift");
+						const forecast = input.correction_line_forecast!;
+						if ((planSubmission.value.minimum !== undefined && forecast < planSubmission.value.minimum) || (planSubmission.value.maximum !== undefined && forecast > planSubmission.value.maximum)) {
+							throw new CandidateViewError(`correction line forecast ${forecast} is outside the provider-rendered bounds`, "correction-forecast-out-of-bounds");
+						}
+						nativeResult = await nativeReviewCli.finalizeSubmission({
+							// Self-contained rendered tokens; run from the authority
+							// workspace root, never a frozen candidate-view root.
+							cwd: defaultCwd,
+							argumentTokens: planSubmission.argumentTokens,
+							valueSubstitutionLocation: planSubmission.value.substitutionLocation,
+							valueLiteral: String(forecast),
+							...(signal === undefined ? {} : { signal }),
+						});
+						if (parameters.lineageId !== undefined && nativeResult.lineageId !== parameters.lineageId) {
+							throw new CandidateViewError("provider finalize submission answered for a different lineage", "finalize-transition-binding-drift");
+						}
+					} else {
+						nativeResult = await nativeReviewCli.finalize({
+							cwd: candidateView?.root ?? defaultCwd,
+							...(parameters.lineageId === undefined ? {} : { lineageId: parameters.lineageId }),
+							...(input.correction_line_forecast === undefined ? {} : { correctionLines: input.correction_line_forecast }),
+							...(input.validation === undefined ? {} : { validationDocument: toNativeValidatorDocument(input.validation) }),
+							...(input.final_evidence === undefined ? {} : { evidenceDocument: input.final_evidence, failed: input.final_verification_passed === false }),
+							...(signal === undefined ? {} : { signal }),
+						});
 					}
 				}
-				nativeResult = await nativeReviewCli.finalize({
-					cwd: candidateView?.root ?? defaultCwd,
-					...(parameters.lineageId === undefined ? {} : { lineageId: parameters.lineageId }),
-					...(input.review_result === undefined ? {} : { lensResults: input.review_result.lens_results.map((document, index) => ({ lens: document.lens ?? `lens-${index}`, document: toNativeReviewerDocument(document) })) }),
-					...(input.refuter_batch === undefined ? {} : { refuterDocument: toNativeRefuterDocument(input.refuter_batch) }),
-					...(input.correction_line_forecast === undefined ? {} : { correctionLines: input.correction_line_forecast }),
-					...(input.validation === undefined && input.validation_proof === undefined ? {} : { validationDocument: toNativeValidatorDocument(input.validation ?? input.validation_proof!) }),
-					...(input.final_evidence === undefined ? {} : { evidenceDocument: input.final_evidence, failed: input.final_verification_passed === false }),
-					...(signal === undefined ? {} : { signal }),
-				});
 			} catch (error) {
+				if (provisionalCandidateView && candidateViews) {
+					candidateViews.cleanup(provisionalCandidateView.token);
+					provisionalCandidateView = undefined;
+					candidateView = undefined;
+				}
 				if (correctionCompletion && candidateView && candidateViews && !nativeMutationRequiresStatus(error)) candidateViews.cleanup(candidateView.token);
 				return reconcileNativeMutationFailure(parameters.operation, error, nativeReviewCli, {
 					cwd: candidateView?.root ?? defaultCwd,
 					...(parameters.lineageId === undefined ? {} : { lineageId: parameters.lineageId }),
 					projection: "workspace",
-				});
+				}, negotiatedStatus?.authority?.revision);
 			}
 			try {
 				if (correctionCompletion && candidateViews && parameters.lineageId) candidateViews.promoteCorrected(parameters.lineageId, candidateView!.token);
@@ -5534,6 +6786,7 @@ async function executeReviewControllerOperation(
 					...(parameters.lineageId === undefined ? {} : { lineageId: parameters.lineageId }),
 					...(signal === undefined ? {} : { signal }),
 				});
+				hydrateDispatchBindingFromStatus(candidateViews, defaultCwd, status);
 				return mapNativeTargetStatus(parameters.operation, status, parameters.lineageId);
 			} catch (error) {
 				return nativeOperationFailure(parameters.operation, error);
@@ -5940,14 +7193,25 @@ export const __testing = {
 	gateLifecycleCommand,
 	nativeStatusUnsupported,
 	executeReviewControllerOperation,
+	setReviewHostRelayRunnerForTesting,
+	clearReviewTransportProbeForTesting,
 	enforceReviewGateAndCommandSafety,
 	renderSddModelPanel: renderSddModelPanelForTesting,
 	getOrchestratorPrompt,
 	renderOrchestratorPrompt,
+	loadBackgroundSubagentsPolicy,
+	resolveBackgroundSubagentsPolicy,
+	renderBackgroundSubagentsReport,
+	writeGlobalBackgroundSubagentsPolicy,
+	parseBackgroundSubagentsPolicyFile,
+	resolveBackgroundSubagentsCapability,
+	readActiveToolNames,
+	renderBackgroundSubagentsStatusLine,
 	resolveControllerSddStatus,
 	resolveStartupControllerSddStatus,
 	repositoryLocationIdentity,
 	runPublicationProbeGit,
+	createGentleAiExtension: createGentleAiExtensionForTesting,
 	publicationProbeErrorCode: PUBLICATION_PROBE_ERROR_CODE,
 };
 
@@ -6001,13 +7265,28 @@ export interface GentleAiRuntimeDependencies {
 	publicationProbe?: PublicationProbe;
 	publicationProbeTimeoutMs?: number;
 	bashTimeRevalidationTimeoutMs?: number;
+	// Deterministic test seam for the consent-binding TTL clock. Production
+	// leaves both undefined so the consent path observes real wall-clock time;
+	// tests inject a fake clock so expiry is observable without a 10-minute
+	// sleep and without relying on the queued cleanup macrotask firing.
+	now?: () => number;
+	scheduleTimer?: (callback: () => void, delayMs: number) => { unref: () => void };
 }
 
 export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencies = {}): (pi: ExtensionAPI) => void {
+	return createGentleAiExtensionForTesting(dependencies);
+}
+
+function createGentleAiExtensionForTesting(
+	dependencies: GentleAiRuntimeDependencies = {},
+	writeReviewConsentLatch: typeof recordReviewConsentLatch = recordReviewConsentLatch,
+): (pi: ExtensionAPI) => void {
 	const nativeReviewCli = dependencies.nativeReviewCli === undefined ? createNativeReviewCli() : dependencies.nativeReviewCli;
 	const publicationProbe = dependencies.publicationProbe ?? nodePublicationProbe;
 	const publicationProbeTimeoutMs = dependencies.publicationProbeTimeoutMs ?? PUBLICATION_PROBE_TIMEOUT_MS;
 	const bashTimeRevalidationTimeoutMs = dependencies.bashTimeRevalidationTimeoutMs ?? BASH_TIME_REVALIDATION_TIMEOUT_MS;
+	const reviewConsentNow = dependencies.now ?? (() => Date.now());
+	const reviewConsentScheduleTimer = dependencies.scheduleTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
 	if (!Number.isSafeInteger(publicationProbeTimeoutMs) || publicationProbeTimeoutMs <= 0) throw new TypeError("Publication probe timeout must be a positive safe integer");
 	if (!Number.isSafeInteger(bashTimeRevalidationTimeoutMs) || bashTimeRevalidationTimeoutMs <= 0) throw new TypeError("Bash-time revalidation timeout must be a positive safe integer");
 	return function gentleAi(pi: ExtensionAPI): void {
@@ -6022,18 +7301,31 @@ export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencie
 		cleanupAllPendingReviewConsents(pendingReviewConsents, candidateViews);
 	});
 
+	pi.registerTool({
+		name: "gentle_review_scope",
+		label: "Gentle Review Scope",
+		description: "Read one bounded, integrity-checked page of the controller-owned frozen changed scope. This read-only tool never inspects the ambient or candidate tree.",
+		parameters: REVIEW_SCOPE_PARAMETERS,
+		executionMode: "parallel",
+		async execute(_toolCallId, parameters) {
+			const input = parameters as ReviewScopeParameters;
+			const details = readCandidateContextManifestPage(input.manifest, input.sha256, input.cursor ?? 0);
+			return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+		},
+	});
+
 	pi.registerTool({
 		name: "gentle_review",
 		label: "Gentle Review Controller",
 		description:
-			"Inspect and recover review authority, run new native ordinary review through start/finalize/validate, preserve legacy compact compatibility reads and graph-v1 Judgment Day, and authorize one exact lifecycle command. FINALIZE input is a JSON string: review_result.lens_results[] entries contain lens, findings, and non-empty evidence exactly once for every lens selected by START; final_evidence is paired with either the legacy final_verification_passed boolean or one closed final_verification_outcome. This is the Pi wrapper contract, distinct from native CLI --result, --refuter, --validation, and --evidence files. RESET/RECOVER remain destructive and are executed by the audited native CLI: RESET and RECOVER_LOCK map to `gentle-ai review reclaim` and RECOVER maps to `gentle-ai review recover` with the provider-selected disposition. Published v2.1.11 repair-legacy-alias derives its fixed repository binding from fresh native inventory before fresh UI approval; dispose-result remains unsupported pending design. Legacy bundle transport is retired: export/import return a legacy-operation-retired envelope pointing at the native gentle-ai review CLI and the Git common-directory store.",
+			"Inspect and recover review authority, run new native ordinary review through start/finalize/validate, preserve legacy compact compatibility reads and graph-v1 Judgment Day, and authorize one exact lifecycle command. Reviewer, refuter, and validator verdicts are never Pi-authored: lens results are admitted natively (the pi host relay satisfies provider --materialize slots), adversarial roles execute through Go-owned pi processes via provider-rendered self-contained vectors, and FINALIZE follows the provider's negotiated next_transition (captured-results discovery). FINALIZE input is a JSON string carrying only the negotiated collection answers: correction_line_forecast, validation (the targeted validation document when the exact collection input requests it), and final_evidence paired with either the legacy final_verification_passed boolean or one closed final_verification_outcome. RESET/RECOVER remain destructive and are executed by the audited native CLI: RESET and RECOVER_LOCK map to `gentle-ai review reclaim` and RECOVER maps to `gentle-ai review recover` with the provider-selected disposition. Published v2.1.11 repair-legacy-alias derives its fixed repository binding from fresh native inventory before fresh UI approval; dispose-result remains unsupported pending design. Legacy bundle transport is retired: export/import return a legacy-operation-retired envelope pointing at the native gentle-ai review CLI and the Git common-directory store.",
 		promptSnippet: "Inspect authority, then use native start/finalize/validate for a new ordinary review; use graph-v1 only for explicit Judgment Day",
 		promptGuidelines: [
 			'Call {"operation":"inspect"} before START. New native ordinary START uses a JSON string such as "{\\"mode\\":\\"ordinary\\"}"; an explicit baseRef must be paired with committedOnly: true to request a committed range, while policyPath remains repository-local. policyHash is legacy compact-only. The controller derives lineage, Git/untracked scope, tier, lenses, authored lines, and budget.',
 			"Use RECONCILE_AUTHORITY only to quarantine one invalid native recovery successor. Supply exact predecessorLineage, expectedPredecessorRevision, successorLineage, expectedSuccessorRevision, actor, and reason values; Pi derives and displays the seven-line native authorization binding for fresh UI approval. The predecessor stays untouched, native returns the durable audit record, and Pi never falls back to RESET or RECOVER.",
-			"Use ABANDON or QUARANTINE_LEGACY only after an explicit user decision and with exact native inputs. ABANDON needs lineage, expectedRevision, snapshotIdentity, actor, and reason; QUARANTINE_LEGACY accepts only the published malformed freeze-findings diagnostic/disposition. A dual reconciliation may supply only anomalies `unchanged_target,malformed_recovery_authorization` in that exact order. Use REPAIR_LEGACY_ALIAS only with lineage, actor, and reason: Pi freshly reads native inventory and derives repository, revision, diagnostic, disposition, and the exact eight-line binding before interactive approval. `review dispose-result` is unsupported pending design.",
-			"Run selected lenses once, then call FINALIZE with a JSON string containing review_result.lens_results entries for every START-selected lens. Each entry has lens, findings, and non-empty evidence; clean lenses use findings: []. Pair final_evidence with exactly one of final_verification_passed or final_verification_outcome (passed, verification_failed, procedural_tooling_failed). Correction evidence is captured natively before STATUS can expose targeted validation. This Pi wrapper shape differs from native CLI --result, --refuter, --validation, and --evidence files. Use ADVANCE only for explicit graph-v1 Judgment Day.",
-			"For blocked-legacy or blocked-mixed, do not call START repeatedly. Explain invalidation, request explicit user authorization for the exact reset_request challenge, then call RESET or RECOVER only after authorization. RESET and RECOVER_LOCK route to audited native `gentle-ai review reclaim` and RECOVER routes to native `gentle-ai review recover`; negotiated target status supplies the sole accepted recovery disposition, and a caller-supplied substitute is rejected. Treat a native-input-required envelope as a request for exact values, never as permission to invent them. After a committed native recovery record, INSPECT before any fresh ordinary START.",
+			"Use ABANDON or QUARANTINE_LEGACY only after an explicit user decision and with exact native inputs. ABANDON needs lineage, expectedRevision, snapshotIdentity, capturedLensResults, findingsPresent, evidenceRecordsPresent, actor, and reason; QUARANTINE_LEGACY accepts only the published malformed freeze-findings diagnostic/disposition. A dual reconciliation may supply only anomalies `unchanged_target,malformed_recovery_authorization` in that exact order. Use REPAIR_LEGACY_ALIAS only with lineage, actor, and reason: Pi freshly reads native inventory and derives repository, revision, diagnostic, disposition, and the exact eight-line binding before interactive approval. `review dispose-result` is unsupported pending design.",
+			"Lens, refuter, and validator verdicts are admitted natively, never Pi-authored: FINALIZE routes provider --materialize lens slots through the host relay, executes provider-rendered self-contained role vectors verbatim, and runs the provider's own review.finalize transition (captured-results discovery). Call FINALIZE with a JSON string carrying only the negotiated collection answers: correction_line_forecast for the pre-edit forecast, validation for the targeted validation document the exact collection input requests, and final_evidence paired with exactly one of final_verification_passed or final_verification_outcome (passed, verification_failed, procedural_tooling_failed). Correction evidence is captured natively before STATUS can expose targeted validation. When the provider offers host-relay lens slots, FINALIZE first returns a `reviewer-model-run-forecast` naming the lenses and the real model runs it would spend; re-run it with `reviewer_run_acknowledged: true` to authorize exactly that reviewer work. Use ADVANCE only for explicit graph-v1 Judgment Day.",
+			"For blocked-legacy or blocked-mixed, do not call START repeatedly. Explain invalidation, request explicit user authorization, then call RESET or RECOVER only after authorization. RESET and RECOVER_LOCK route to audited native `gentle-ai review reclaim`; only RESET carries the legacy repositoryId, commonDirHash, inventoryHash, and confirmation challenge. RECOVER routes to native `gentle-ai review recover` with exactly six inputs: predecessorLineage, expectedPredecessorRevision, successorLineage, disposition, actor, and reason. Never send RECOVER the reset challenge and never send it a maintainerAuthorization: Pi reads fresh native target status, pins the predecessor lineage, revision, provider-selected disposition, and target identity, derives the exact six-line native authorization binding, displays it for fresh UI approval, and re-reads status before mutating. Negotiated target status supplies the sole accepted recovery disposition, and a caller-supplied substitute is rejected. Treat a native-input-required envelope as a request for exact values, never as permission to invent them. After a committed native recovery record, INSPECT before any fresh ordinary START.",
 			"A consent-required START returns the complete provider envelope and an opaque consent_binding, then stops. The parent presents and localizes that envelope without changing machine tokens, commands, target IDs, or invocations. After one explicit human answer, call answer-consent exactly once with a JSON string containing only consentBinding and answer (`granted` or `declined`). A reported lineage_created false or pre-authority validation error proves no lineage was created. After ambiguous START, answer-consent, or FINALIZE output, the controller calls target-scoped native status first and returns only its declared action. Never infer or prescribe replay unless native explicitly reports exact_replay_safe for the same canonical request and required lineage.",
 			"Use gentle_review for bounded review transaction operations and exact lifecycle validation; never fabricate bash tool metadata or a separate gate target.",
 		],
@@ -6054,6 +7346,9 @@ export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencie
 				ctx,
 				correctionEvidenceByLineage,
 				pendingReviewConsents,
+				writeReviewConsentLatch,
+				reviewConsentNow,
+				reviewConsentScheduleTimer,
 			);
 			return {
 				content: [{ type: "text", text: JSON.stringify(details) }],
@@ -6071,6 +7366,15 @@ export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencie
 	}
 
 	pi.on("session_start", async (_event, ctx) => {
+		// Loud, every session: an active dev-binary override means this session
+		// runs an unpinned gentle-ai. Announce which one before anything else.
+		try {
+			const devBinary = await describeDevBinaryOverride();
+			if (ctx.hasUI && devBinary.state === "active") ctx.ui.notify(devBinary.line, "warning");
+			if (ctx.hasUI && devBinary.state === "invalid") ctx.ui.notify(devBinary.line, "error");
+		} catch (error) {
+			if (ctx.hasUI) ctx.ui.notify(`Gentle AI dev binary override check failed: ${error instanceof Error ? error.message : String(error)}`, "warning");
+		}
 		try {
 			const transactionRecovery = reconcileCommitTransaction(ctx.cwd);
 			if (ctx.hasUI && transactionRecovery.status !== "clean") {
@@ -6149,7 +7453,7 @@ export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencie
 			: "";
 		const gentlePrompt = isNamedAgent || isSddAgent
 			? ""
-			: `\n\n${buildGentlePrompt(readPersonaMode(ctx.cwd))}`;
+			: `\n\n${buildGentlePrompt(readPersonaMode(ctx.cwd), ctx.cwd, readActiveToolNames(pi))}`;
 		return {
 			systemPrompt: `${event.systemPrompt}${gentlePrompt}${sddPrompt}${nativeStatusPrompt}`,
 		};
@@ -6383,6 +7687,66 @@ export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencie
 		},
 	});
 
+	// Dev-binary override surfacing (unpinned field-test mode). While the
+	// override is active every diagnostic surface names the exact binary, its
+	// live version, and its fresh content digest, so the maintainer always
+	// knows which gentle-ai actually answered. An invalid override surfaces as
+	// a failure — it is never silently ignored, because the native resolver
+	// refuses to fall back to the pin while an override is declared.
+	const describeDevBinaryOverride = async (): Promise<
+		| { state: "inactive" }
+		| { state: "active"; line: string; override: GentleAiDevBinaryOverride }
+		| { state: "invalid"; line: string }
+	> => {
+		let override: GentleAiDevBinaryOverride | undefined;
+		try {
+			override = resolveGentleAiDevBinaryOverride();
+		} catch (error) {
+			if (error instanceof GentleAiDevBinaryOverrideError) return { state: "invalid", line: `Gentle AI dev binary override invalid — ${error.message}` };
+			throw error;
+		}
+		if (override === undefined) return { state: "inactive" };
+		let version = "version unavailable";
+		try {
+			const adapter = createNodeExecFileAdapter();
+			const result = await adapter({ file: override.path, arguments: ["version"], cwd: dirname(override.path), timeoutMs: 10_000, maxBufferBytes: 1024 * 1024 });
+			const banner = result.stdout.trim();
+			if (result.exitCode === 0 && banner.startsWith("gentle-ai ")) version = banner.slice("gentle-ai ".length);
+		} catch {
+			// The doctor line still names the binary; the version stays unavailable.
+		}
+		return {
+			state: "active",
+			override,
+			line: `Gentle AI dev binary override active (unpinned, field-test only): ${override.path} ${version} sha256:${override.sha256.slice(0, 16)}`,
+		};
+	};
+
+	pi.registerCommand("gentle:dev-binary", {
+		description: "Register, inspect, or clear the persistent Gentle AI dev-binary override (status | <absolute path> | off). Unpinned, field-test only.",
+		handler: async (args, ctx) => {
+			const argument = args.trim();
+			try {
+				if (argument === "off") {
+					const removed = unregisterGentleAiDevBinary();
+					ctx.ui.notify(removed ? "Gentle AI dev binary registration removed; the pinned binary is active again." : "No dev binary registration to remove.", "info");
+					return;
+				}
+				if (argument === "" || argument === "status") {
+					const described = await describeDevBinaryOverride();
+					if (described.state === "inactive") ctx.ui.notify("No dev binary override; the pinned Gentle AI binary is active.", "info");
+					else ctx.ui.notify(described.line, described.state === "active" ? "warning" : "error");
+					return;
+				}
+				registerGentleAiDevBinary(argument);
+				const described = await describeDevBinaryOverride();
+				ctx.ui.notify(described.state === "inactive" ? "Dev binary registration written." : described.line, "warning");
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
 	pi.registerCommand("gentle:doctor", {
 		description: "Run read-only Gentle AI diagnostics for this Pi workspace.",
 		handler: async (_args, ctx) => {
@@ -6402,6 +7766,7 @@ export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencie
 			const localSddAgentOverrides = sddLocalAgentOverrideCount(ctx.cwd);
 			const modelConfig = await readSavedModelConfigAsync(ctx.cwd);
 			const engramActive = hasWritableEngramTool(pi);
+			const devBinary = await describeDevBinaryOverride();
 			const lines = [
 				"el Gentleman doctor",
 				`${agentsInstalled ? "pass" : "fail"}: Global SDD agents ${agentsInstalled ? "installed" : "missing"}`,
@@ -6413,6 +7778,8 @@ export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencie
 				`${modelConfig.status === "invalid" ? "fail" : "pass"}: Global model config ${modelConfig.status}`,
 				"pass: Sensitive-path guard active for read/write/edit tools",
 				`${engramActive ? "pass" : "warn"}: Engram memory tools ${engramActive ? "active" : "not active in this session"}`,
+				...(devBinary.state === "active" ? [`warn: ${devBinary.line}`] : []),
+				...(devBinary.state === "invalid" ? [`fail: ${devBinary.line}`, "remedy: fix the dev binary override or clear it with /gentle:dev-binary off (or unset GENTLE_PI_GENTLE_AI_DEV_BINARY)"] : []),
 			];
 			if (!agentsInstalled || !chainsInstalled) {
 				lines.push("remedy: run /gentle:install-sdd --force to refresh global SDD assets intentionally");
@@ -6474,6 +7841,31 @@ export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencie
 		},
 	});
 
+	// Mirrors gentle:review-mode: a user-owned switch, never an automated one.
+	// It matters more here than there, because this policy governs whether
+	// background subagents may be launched at all, so nothing in Pi may write
+	// it. The only writer is this handler, reached only by explicit invocation.
+	pi.registerCommand("gentle:background-subagents", {
+		description: "Show or set the managed background-subagents policy (status|enable|disable). Every sub-action is user-initiated only; Pi automation never toggles it.",
+		handler: async (args, ctx) => {
+			const subAction = args.trim().length === 0 ? "status" : args.trim();
+			if (subAction !== "status" && subAction !== "enable" && subAction !== "disable") {
+				ctx.ui.notify(`Unknown /gentle:background-subagents sub-action "${subAction}". Use status, enable, or disable.`, "warning");
+				return;
+			}
+			try {
+				const wrote: BackgroundSubagentsPolicy | undefined = subAction === "enable" ? "on" : subAction === "disable" ? "off" : undefined;
+				if (wrote !== undefined) writeGlobalBackgroundSubagentsPolicy(wrote);
+				const resolution = resolveBackgroundSubagentsPolicy(ctx.cwd);
+				const capability = resolveBackgroundSubagentsCapability(ctx.cwd, readActiveToolNames(pi));
+				const report = renderBackgroundSubagentsReport(resolution, capability, wrote);
+				ctx.ui.notify(report.message, report.type);
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
 	pi.registerCommand("gentle:status", {
 		description: "Show Gentle AI package status for this project.",
 		handler: async (_args, ctx) => {
@@ -6489,9 +7881,11 @@ export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencie
 			const staleSddAssets = sddGlobalAssetDriftCount();
 			const localSddAgentOverrides = sddLocalAgentOverrideCount(ctx.cwd);
 			const modelConfig = await readModelConfigAsync(ctx.cwd);
+			const devBinary = await describeDevBinaryOverride();
 			ctx.ui.notify(
 				[
 					"el Gentleman package is active.",
+					...(devBinary.state === "inactive" ? [] : [devBinary.line]),
 					`Persona: ${readPersonaMode(ctx.cwd)}`,
 					`Global SDD agents: ${agentsInstalled ? "installed" : "not installed"}`,
 					`Global SDD chains: ${chainsInstalled ? "installed" : "not installed"}`,
@@ -6509,7 +7903,7 @@ export function createGentleAiExtension(dependencies: GentleAiRuntimeDependencie
 					`Global model config: ${existsSync(modelConfigPath(ctx.cwd)) ? "present" : "missing"}`,
 					...describeModelConfig(ctx.cwd, modelConfig),
 				].join("\n"),
-				staleSddAssets > 0 || localSddAgentOverrides > 0 ? "warning" : "info",
+				staleSddAssets > 0 || localSddAgentOverrides > 0 || devBinary.state !== "inactive" ? "warning" : "info",
 			);
 		},
 	});