gentle-pi 2.1.2 → 2.2.0

package/tests/review-controller-native-routing.test.ts

@@ -1,9 +1,9 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { chmodSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { delimiter, dirname, join, resolve } from "node:path";
 import test from "node:test";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { __testing, createGentleAiExtension } from "../extensions/gentle-ai.ts";
@@ -22,7 +22,6 @@ import { canonicalJsonV1, domainHashV1 } from "../lib/review-canonical.ts";
 import { CandidateViewRegistry, deriveChangedPathManifest } from "../lib/review-candidate-view.ts";
 import { inspectLegacyReviewAuthorityV1 } from "../lib/review-legacy-detector.ts";
 import { resolveRepositoryAuthorityV1 } from "../lib/review-repository.ts";
-import { NATIVE_REVIEW_REMEDIATION, classifyNativeReviewRemediation } from "../lib/native-review-remediation.ts";
 import type { AuthorityRepairAssessmentV1, ReviewStatusV3 } from "../lib/review-integration-v2.ts";
 
 interface RegisteredTool {
@@ -46,6 +45,7 @@ interface RegisteredCommandFixture {
 
 interface Runtime {
 	controller: RegisteredTool;
+	scopeReader: RegisteredTool;
 	toolCall: ToolCallHandler;
 	commands: Map<string, RegisteredCommandFixture>;
 }
@@ -90,15 +90,23 @@ function runtime(
 		registerCommand(name: string, definition: RegisteredCommandFixture) { commands.set(name, definition); },
 	} as unknown as ExtensionAPI);
 	const controller = tools.get("gentle_review");
+	const scopeReader = tools.get("gentle_review_scope");
 	assert.ok(controller);
+	assert.ok(scopeReader);
 	assert.ok(toolCall);
-	return { controller, toolCall, commands };
+	return { controller, scopeReader, toolCall, commands };
 }
 
 function context(cwd: string, signal?: AbortSignal): ExtensionContext {
 	return { cwd, hasUI: false, signal, ui: { confirm: async () => true } } as unknown as ExtensionContext;
 }
 
+function compactCandidateContextManifest(task: string): { encoded: string; sha256: string } {
+	const match = /Frozen changed scope manifest \(gzip\+base64url\): `([A-Za-z0-9_-]+)`\.\nFrozen changed scope manifest SHA-256: `([0-9a-f]{64})`\./.exec(task);
+	assert.ok(match, "expected a compact candidate context manifest");
+	return { encoded: match[1]!, sha256: match[2]! };
+}
+
 function interactiveContext(cwd: string, signal?: AbortSignal): ExtensionContext {
 	return { cwd, hasUI: true, signal, ui: { confirm: async () => true } } as unknown as ExtensionContext;
 }
@@ -268,7 +276,7 @@ function fakeNative(overrides: Partial<NativeReviewCli> = {}): NativeReviewCli {
 			const lineageId = request.lineageId ?? "";
 			return lineageId === ""
 				? candidateStartTargetStatus(request)
-				: targetStatusFixture({ lineageId });
+				: candidateFinalizeTargetStatus(request, lineageId);
 		},
 		...overrides,
 	};
@@ -400,6 +408,24 @@ function candidateStartTargetStatus(request: Parameters<NonNullable<NativeReview
 	}
 }
 
+function candidateFinalizeTargetStatus(request: Parameters<NonNullable<NativeReviewCli["targetStatus"]>>[0], lineageId: string): ReviewStatusV3 {
+	let candidate: ReturnType<CandidateViewRegistry["create"]> | undefined;
+	try {
+		candidate = new CandidateViewRegistry().create({ contributorRoot: request.cwd });
+		return targetStatusFixture({
+			lineageId,
+			baseTree: candidate.baseTree,
+			currentCandidateTree: candidate.candidateTree,
+			paths: candidate.paths,
+			projection: request.projection ?? "workspace",
+		});
+	} catch {
+		return targetStatusFixture({ lineageId });
+	} finally {
+		candidate?.cleanup();
+	}
+}
+
 function bindReviewerManifest(status: ReviewStatusV3, cwd: string, manifestHash = `sha256:${"7".repeat(64)}`): ReviewStatusV3 {
 	const manifest = deriveChangedPathManifest(cwd, status.projection.baseTree, status.projection.currentCandidateTree).map((entry) => ({
 		...entry,
@@ -555,12 +581,60 @@ test("new ordinary START and native-lineage FINALIZE use exactly one native call
 	}));
 	const start = await controller.execute("start", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
 	assert.deepEqual(start.details, { operation: "start", result: { lineage_id: "native-lineage", state: "reviewing", risk_tier: "medium", selected_lenses: ["review-reliability"], changed_files: 2, original_changed_lines: 7, correction_budget: 4, action: "created", lenses_required: true }, workspace_root: cwd });
-	const finalize = await controller.execute("finalize", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({ review_result: { lens_results: [{ findings: [], evidence: ["complete candidate reviewed"] }] } }) }, undefined, undefined, context(cwd));
+	const finalize = await controller.execute("finalize", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({}) }, undefined, undefined, context(cwd));
 	assert.deepEqual(finalize.details, { operation: "finalize", result: { lineage_id: "native-lineage", state: "approved", action: "approved", store_revision: "r1", receipt_path: "/opaque/receipt" } });
 	assert.equal(starts, 1);
 	assert.equal(finalizes, 1);
 });
 
+test("native FINALIZE resolves STATUS and mutation against the verified frozen candidate root", async (t) => {
+	const cwd = repository(t);
+	writeFileSync(join(cwd, "app.ts"), "export const value = 2;\n");
+	const candidateViews = new CandidateViewRegistry();
+	const statusRoots: string[] = [];
+	let finalizeRoot: string | undefined;
+	const native = fakeNative({
+		targetStatus: async (request) => {
+			if (request.lineageId === undefined) return candidateStartTargetStatus(request);
+			statusRoots.push(request.cwd);
+			if (request.cwd === cwd) return targetStatusFixture({ applicability: "unrelated", action: "start" });
+			const candidate = candidateViews.resolveForFinalize(request.lineageId);
+			return targetStatusFixture({
+				lineageId: request.lineageId,
+				baseTree: candidate.baseTree,
+				currentCandidateTree: candidate.candidateTree,
+				paths: candidate.paths,
+			});
+		},
+		start: async () => ({
+			lineageId: "candidate-root-finalize",
+			state: "reviewing",
+			riskLevel: "medium",
+			selectedLenses: ["review-reliability"],
+			changedFiles: 1,
+			changedLines: 1,
+			correctionBudget: 1,
+			action: "created",
+			lensesRequired: true,
+		}),
+		finalize: async (request) => {
+			finalizeRoot = request.cwd;
+			return { lineageId: "candidate-root-finalize", state: "approved", action: "approved", storeRevision: "r1" };
+		},
+	});
+	const { controller } = runtime(native, undefined, undefined, undefined, candidateViews);
+	await controller.execute("candidate-root-start", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
+	const candidateRoot = candidateViews.resolveForFinalize("candidate-root-finalize").root;
+	const result = await controller.execute("candidate-root-finalize", {
+		operation: "finalize",
+		lineageId: "candidate-root-finalize",
+		input: JSON.stringify({}),
+	}, undefined, undefined, context(cwd));
+	assert.deepEqual(statusRoots, [candidateRoot]);
+	assert.equal(finalizeRoot, candidateRoot);
+	assert.equal((result.details as { result: { state: string } }).result.state, "approved");
+});
+
 test("parent subagent_run mutates single and parallel review actors with one verified controller-owned candidate view", async (t) => {
 	const cwd = repository(t);
 	writeFileSync(join(cwd, "app.ts"), "export const value = 2;\n");
@@ -750,91 +824,12 @@ test("fresh negotiated registries reconstruct the frozen candidate before FINALI
 	const result = await controller.execute("restarted-finalize", {
 		operation: "finalize",
 		lineageId: "restarted-lineage",
-		input: JSON.stringify({ review_result: { lens_results: [{ lens: "review-reliability", findings: [], evidence: ["reviewed frozen candidate"] }] } }),
+		input: JSON.stringify({}),
 	}, undefined, undefined, context(cwd));
 	assert.equal(finalizedContent, "export const value = 2;\n");
 	assert.equal((result.details as { result: { state: string } }).result.state, "approved");
 });
 
-test("fresh FINALIZE restores the provider manifest binding and rejects mode drift on the production path", async (t) => {
-	const cwd = repository(t);
-	writeFileSync(join(cwd, "app.ts"), "export const value = 2;\n");
-	const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
-	const status = targetStatusFixture({ lineageId: "manifest-lineage", baseTree: frozen.baseTree, currentCandidateTree: frozen.candidateTree, paths: frozen.paths });
-	bindReviewerManifest(status, cwd);
-	const collect = status.nextTransition!.collect!;
-	const input = collect.inputs[0]!;
-	const changed = input.changedPathManifest![0]!;
-	status.nextTransition = { ...status.nextTransition!, collect: { inputs: [{
-		...input,
-		changedPathManifest: [{
-		...changed,
-		newMode: "100755",
-		modeOnly: true,
-		}],
-	}] } };
-	frozen.cleanup();
-	let finalizes = 0;
-	const { controller } = runtime(fakeNative({
-		targetStatus: async () => status,
-		finalize: async () => {
-			finalizes += 1;
-			return { lineageId: "manifest-lineage", state: "approved", action: "approved", storeRevision: "r1" };
-		},
-	}), undefined, undefined, undefined, new CandidateViewRegistry());
-	const result = await controller.execute("manifest-mode-drift", {
-		operation: "finalize",
-		lineageId: "manifest-lineage",
-		input: JSON.stringify({ review_result: { lens_results: [{ lens: "review-reliability", findings: [], evidence: ["reviewed frozen candidate"] }] } }),
-	}, undefined, undefined, context(cwd));
-	assert.equal((result.details as { outcome?: string }).outcome, "native-operation-failed");
-	assert.equal(((result.details as { diagnostics?: { code?: string } }).diagnostics?.code), "manifest-mode-drift");
-	assert.equal(finalizes, 0, "manifest drift must stop before native FINALIZE");
-});
-
-test("fresh FINALIZE rejects inconsistent provider manifest hashes before production dispatch", async (t) => {
-	const cwd = repository(t);
-	writeFileSync(join(cwd, "app.ts"), "export const value = 2;\n");
-	const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
-	const status = bindReviewerManifest(targetStatusFixture({ lineageId: "manifest-hash-lineage", baseTree: frozen.baseTree, currentCandidateTree: frozen.candidateTree, paths: frozen.paths }), cwd);
-	const first = status.nextTransition!.collect!.inputs[0]!;
-	const secondSubjectHash = `sha256:${"a".repeat(64)}`;
-	status.nextTransition = { ...status.nextTransition!, collect: { inputs: [first, {
-		...first,
-		arguments: first.arguments.map((argument) => argument.name === "lens"
-			? { ...argument, value: "review-risk", token: "--lens=review-risk" }
-			: argument.name === "order"
-				? { ...argument, value: "1", token: "--order=1" }
-				: argument.name === "subject-hash"
-					? { ...argument, value: secondSubjectHash, token: `--subject-hash=${secondSubjectHash}` }
-					: argument),
-		artifactSubject: {
-			...first.artifactSubject!,
-			subjectHash: secondSubjectHash,
-			changedPathManifestSha256: `sha256:${"b".repeat(64)}`,
-			lens: "review-risk",
-			selectedOrder: 1,
-		},
-	}] } };
-	frozen.cleanup();
-	let finalizes = 0;
-	const { controller } = runtime(fakeNative({
-		targetStatus: async () => status,
-		finalize: async () => {
-			finalizes += 1;
-			return { lineageId: "manifest-hash-lineage", state: "approved", action: "approved", storeRevision: "r1" };
-		},
-	}), undefined, undefined, undefined, new CandidateViewRegistry());
-	const result = await controller.execute("manifest-hash-drift", {
-		operation: "finalize",
-		lineageId: "manifest-hash-lineage",
-		input: JSON.stringify({ review_result: { lens_results: [{ lens: "review-reliability", findings: [], evidence: ["reviewed frozen candidate"] }] } }),
-	}, undefined, undefined, context(cwd));
-	assert.equal((result.details as { outcome?: string }).outcome, "native-operation-failed");
-	assert.equal(((result.details as { diagnostics?: { code?: string } }).diagnostics?.code), "manifest-input-divergence");
-	assert.equal(finalizes, 0);
-});
-
 test("forecast-only FINALIZE reconstructs the frozen candidate after a fresh process (#176)", async (t) => {
 	const cwd = repository(t);
 	writeFileSync(join(cwd, "app.ts"), "export const value = 2;\n");
@@ -1313,113 +1308,480 @@ test("production correction routing rejects a second capture that reuses failed
 	execFileSync("chmod", ["-R", "u+w", cwd]);
 });
 
-test("native FINALIZE derives and requires the trusted refuter request before invoking native FINALIZE", async (t) => {
+// Live-emitter correction shapes (probed 2026-08-16 against BOTH the pinned
+// 2.2.3 binary and dev 2.4.0-main.b1afef46, scripted correction lane):
+// - The evidence-collect status at `correction_required` carries the
+//   `validation_request` CONTEXT alongside its single `review.capture-evidence`
+//   input (reason correction_repository_verification_required). The request
+//   context is not an offered validation step.
+// - The post-evidence targeted-validation status keeps state
+//   `correction_required` (never `validating`), and its
+//   `external.run_targeted_validation` input embeds the identical
+//   validation_request.
+test("production correction routing accepts the live emitters' early validation-request context and correction_required post-evidence state", async (t) => {
+	for (const [outcome, expectedKind] of [
+		["passed", "run-targeted-validation"],
+		["verification_failed", "recapture-required"],
+	] as const) {
+		await t.test(outcome, async (scenario) => {
+			const cwd = repository(scenario);
+			writeFileSync(join(cwd, "app.ts"), `export const live = ${JSON.stringify(outcome)};\n`);
+			const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
+			const beforeCapture = bindCorrectionCollection(targetStatusFixture({
+				lineageId: `live-correction-${outcome.replaceAll("_", "-")}`,
+				authorityState: "correction_required",
+				baseTree: frozen.baseTree,
+				currentCandidateTree: frozen.candidateTree,
+				paths: frozen.paths,
+			}));
+			// The live emitters publish the request context BEFORE evidence.
+			beforeCapture.validationRequest = bindTargetedValidation(targetStatusFixture({
+				lineageId: beforeCapture.authority!.lineageId,
+				authorityState: "correction_required",
+				baseTree: frozen.baseTree,
+				currentCandidateTree: frozen.candidateTree,
+				paths: frozen.paths,
+			})).validationRequest;
+			const afterCapture = targetStatusFixture({
+				lineageId: beforeCapture.authority!.lineageId,
+				// Live post-evidence state on both emitters.
+				authorityState: "correction_required",
+				baseTree: frozen.baseTree,
+				currentCandidateTree: frozen.candidateTree,
+				paths: frozen.paths,
+			});
+			if (outcome === "passed") bindTargetedValidation(afterCapture);
+			else {
+				bindCorrectionCollection(afterCapture);
+				afterCapture.validationRequest = beforeCapture.validationRequest;
+			}
+			frozen.cleanup();
+			const calls: string[] = [];
+			let statuses = 0;
+			let finalizes = 0;
+			const { controller } = runtime(fakeNative({
+				targetStatus: async () => {
+					calls.push("status");
+					statuses += 1;
+					return statuses === 1 ? beforeCapture : afterCapture;
+				},
+				captureEvidence: async (request) => {
+					calls.push("capture-evidence");
+					assert.equal(request.outcome, outcome);
+					return capturedCorrectionEvidence(beforeCapture, outcome, outcome === "passed" ? "7" : "8");
+				},
+				finalize: async () => {
+					calls.push("finalize");
+					finalizes += 1;
+					return { lineageId: beforeCapture.authority!.lineageId, state: "approved", action: "approved", storeRevision: "r-final" };
+				},
+			}), undefined, undefined, undefined, new CandidateViewRegistry());
+			const validation = outcome === "passed" ? {
+				request_hash: "9".repeat(64), correction_ids: [],
+				original_criteria: { passed: true, evidence: ["acceptance passes"] },
+				correction_regression: { passed: true, evidence: ["regression passes"] },
+				fix_caused_findings: [], follow_ups: [],
+			} : undefined;
+			const result = await controller.execute(`live-correction-${outcome}`, {
+				operation: "finalize",
+				lineageId: beforeCapture.authority!.lineageId,
+				input: JSON.stringify({ final_evidence: `evidence: ${outcome}`, final_verification_outcome: outcome, ...(validation === undefined ? {} : { validation }) }),
+			}, undefined, undefined, context(cwd));
+			const details = result.details as Record<string, unknown>;
+			assert.deepEqual(calls.slice(0, 3), ["status", "capture-evidence", "status"], "the early validation-request context must not block the evidence capture the state demands");
+			assert.equal((details.correction_step as { kind?: string } | undefined)?.kind, expectedKind);
+			assert.equal(finalizes, outcome === "passed" ? 1 : 0);
+		});
+	}
+});
+
+// Ordinary final verification (field defect, dev binary 2.4.0-main.b1afef46,
+// reproduced identically on the pinned 2.2.3 binary): after FINALIZE with
+// captured results the native state is `validating` and the provider collects
+// exactly one `review.capture-evidence` record, then offers one execute
+// `review.finalize --captured-evidence=true` transition. The controller must
+// follow that transition faithfully — it must never demand its correction-lane
+// targeted-validation phase, and never substitute the validate gate.
+function bindFinalVerificationTransition(status: ReviewStatusV3, outcome: "passed" | "verification_failed" | "procedural_tooling_failed"): ReviewStatusV3 {
+	const reasonCode = outcome === "passed"
+		? "captured_verification_evidence_passed"
+		: outcome === "verification_failed" ? "captured_verification_failed" : "captured_verification_tooling_failed";
+	status.nextTransition = {
+		kind: "execute",
+		reasonCode,
+		execute: {
+			operation: "review.finalize",
+			// The second argument deliberately omits `token` to pin the
+			// provider's published hyphenation fallback (captured_evidence ->
+			// --captured-evidence=true); the host never invents another form.
+			arguments: [
+				{ name: "lineage", value: status.authority!.lineageId, token: `--lineage=${status.authority!.lineageId}` },
+				{ name: "captured_evidence", value: "true" },
+			],
+			preconditions: [{ name: "state", value: "validating" }, { name: "verification_outcome", value: outcome }],
+			binding: { targetIdentity: status.targetIdentity, lineageId: status.authority!.lineageId },
+		},
+	};
+	delete status.validationRequest;
+	return status;
+}
+
+test("ordinary final verification at validating captures evidence then executes the provider finalize transition, never targeted validation", async (t) => {
+	for (const [outcome, terminalState] of [
+		["passed", "approved"],
+		["verification_failed", "escalated"],
+		["procedural_tooling_failed", "escalated"],
+	] as const) {
+		await t.test(outcome, async (scenario) => {
+			const cwd = repository(scenario);
+			writeFileSync(join(cwd, "app.ts"), `export const outcome = ${JSON.stringify(outcome)};\n`);
+			const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
+			const beforeCapture = bindCorrectionCollection(targetStatusFixture({
+				lineageId: "final-verification",
+				authorityState: "validating",
+				baseTree: frozen.baseTree,
+				currentCandidateTree: frozen.candidateTree,
+				paths: frozen.paths,
+			}));
+			const afterCapture = bindFinalVerificationTransition(targetStatusFixture({
+				lineageId: "final-verification",
+				authorityState: "validating",
+				baseTree: frozen.baseTree,
+				currentCandidateTree: frozen.candidateTree,
+				paths: frozen.paths,
+			}), outcome);
+			frozen.cleanup();
+			const calls: string[] = [];
+			const transitions: Array<readonly string[]> = [];
+			let statuses = 0;
+			const { controller } = runtime(fakeNative({
+				targetStatus: async () => {
+					calls.push("status");
+					statuses += 1;
+					return statuses === 1 ? beforeCapture : afterCapture;
+				},
+				captureEvidence: async (request) => {
+					calls.push("capture-evidence");
+					assert.equal(request.outcome, outcome);
+					return capturedCorrectionEvidence(beforeCapture, outcome, "6");
+				},
+				finalize: async () => {
+					calls.push("finalize");
+					return { lineageId: "final-verification", state: terminalState, action: "terminal", storeRevision: "r2" };
+				},
+				finalizeTransition: async (request) => {
+					calls.push("finalize-transition");
+					transitions.push(request.argumentTokens);
+					return { lineageId: "final-verification", state: terminalState, action: "terminal", storeRevision: "r2", receiptPath: "/opaque/receipt" };
+				},
+			}), undefined, undefined, undefined, new CandidateViewRegistry());
+			const result = await controller.execute(`final-verification-${outcome}`, {
+				operation: "finalize",
+				lineageId: "final-verification",
+				input: JSON.stringify({ final_evidence: `verification run: ${outcome}`, final_verification_outcome: outcome }),
+			}, undefined, undefined, context(cwd));
+			const details = result.details as Record<string, unknown>;
+			assert.deepEqual(calls, ["status", "capture-evidence", "status", "finalize-transition"], "the controller must follow the provider transition after evidence capture");
+			assert.deepEqual(transitions, [["--lineage=final-verification", "--captured-evidence=true"]]);
+			assert.equal((details.result as { state?: string } | undefined)?.state, terminalState);
+			assert.equal("correction_step" in details, false, "ordinary final verification is not a correction transaction");
+		});
+	}
+});
+
+test("ordinary final verification rejects a Pi-authored targeted validation document before any capture", async (t) => {
 	const cwd = repository(t);
+	writeFileSync(join(cwd, "app.ts"), "export const value = 1;\n");
+	const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
+	const status = bindCorrectionCollection(targetStatusFixture({
+		lineageId: "final-verification",
+		authorityState: "validating",
+		baseTree: frozen.baseTree,
+		currentCandidateTree: frozen.candidateTree,
+		paths: frozen.paths,
+	}));
+	frozen.cleanup();
+	let captures = 0;
 	let finalizes = 0;
 	const { controller } = runtime(fakeNative({
-		start: async () => ({ lineageId: "native-lineage", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-risk"], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: true }),
-		finalize: async () => {
-			finalizes += 1;
-			return { lineageId: "native-lineage", state: "validating", action: "continue", storeRevision: "r1" };
-		},
-	}));
-	await controller.execute("risk-001-start", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
-	const proof = "differential-test:candidate still fails";
-	const finding = { id: "RISK-001", lens: "review-risk", location: "lib/a.ts:1", severity: "CRITICAL", claim: "Candidate fails", evidence_class: "inferential", causal_disposition: "introduced", proof_refs: [proof] };
-	const review_result = { lens_results: [{ lens: "review-risk", findings: [finding], evidence: ["complete candidate reviewed"] }] };
-	const required = await controller.execute("risk-001-refuter-request", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({ review_result }) }, undefined, undefined, context(cwd));
-	const request = (required.details as { refuter_request?: { request_hash: string; findings: unknown[] } }).refuter_request;
+		targetStatus: async () => status,
+		captureEvidence: async () => { captures += 1; return capturedCorrectionEvidence(status, "passed", "4"); },
+		finalize: async () => { finalizes += 1; return { lineageId: "final-verification", state: "approved", action: "approved", storeRevision: "r1" }; },
+	}), undefined, undefined, undefined, new CandidateViewRegistry());
+	const result = await controller.execute("final-verification-validation-doc", {
+		operation: "finalize",
+		lineageId: "final-verification",
+		input: JSON.stringify({
+			final_evidence: "verification run: passed",
+			final_verification_outcome: "passed",
+			validation: { request_hash: "9".repeat(64), correction_ids: [], original_criteria: { passed: true, evidence: ["passes"] }, correction_regression: { passed: true, evidence: ["passes"] }, fix_caused_findings: [], follow_ups: [] },
+		}),
+	}, undefined, undefined, context(cwd));
+	assert.equal((result.details as { outcome?: string }).outcome, "native-operation-failed");
+	assert.match(JSON.stringify(result.details), /final-verification-provider-owned/);
+	assert.equal(captures, 0, "an inadmissible payload must fail closed before the single evidence capture is consumed");
 	assert.equal(finalizes, 0);
-	assert.equal((required.details as { outcome?: string }).outcome, "refuter-required");
-	assert.equal(typeof request?.request_hash, "string");
-	assert.deepEqual(request?.findings.map((row) => (row as { id: string }).id), ["RISK-001"]);
-	const retry = await controller.execute("risk-001-refuter-retry", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({
-		review_result: { ...review_result, refuter_request_hash: request!.request_hash },
-		refuter_batch: { schema: "gentle-ai.refuter-result-batch/v1", request_hash: request!.request_hash, results: [{ finding_id: "RISK-001", outcome: "corroborated", proof_refs: [proof] }] },
-	}) }, undefined, undefined, context(cwd));
-	assert.equal(finalizes, 1);
-	assert.equal((retry.details as { result?: { state?: string } }).result?.state, "validating");
 });
 
-test("native FINALIZE emits exact v2.1.4 process documents and failed verification argv intent", async (t) => {
+test("ordinary final verification fails closed without substituting a step when the provider offers no finalize transition", async (t) => {
 	const cwd = repository(t);
-	const requests: Parameters<NativeReviewCli["finalize"]>[0][] = [];
+	writeFileSync(join(cwd, "app.ts"), "export const value = 2;\n");
+	const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
+	const beforeCapture = bindCorrectionCollection(targetStatusFixture({
+		lineageId: "final-verification",
+		authorityState: "validating",
+		baseTree: frozen.baseTree,
+		currentCandidateTree: frozen.candidateTree,
+		paths: frozen.paths,
+	}));
+	const afterCapture = targetStatusFixture({
+		lineageId: "final-verification",
+		authorityState: "validating",
+		action: "stop",
+		replayability: "manual_action_required",
+		baseTree: frozen.baseTree,
+		currentCandidateTree: frozen.candidateTree,
+		paths: frozen.paths,
+	});
+	frozen.cleanup();
+	let statuses = 0;
+	let finalizes = 0;
+	let transitions = 0;
+	let validates = 0;
 	const { controller } = runtime(fakeNative({
-		start: async () => ({ lineageId: "native-lineage", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-risk"], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: true }),
-		finalize: async (request) => {
-			requests.push(request);
+		targetStatus: async () => {
+			statuses += 1;
+			return statuses === 1 ? beforeCapture : afterCapture;
+		},
+		captureEvidence: async () => capturedCorrectionEvidence(beforeCapture, "passed", "5"),
+		finalize: async () => { finalizes += 1; return { lineageId: "final-verification", state: "approved", action: "approved", storeRevision: "r1" }; },
+		finalizeTransition: async () => { transitions += 1; return { lineageId: "final-verification", state: "approved", action: "approved", storeRevision: "r1" }; },
+		validate: async () => { validates += 1; return { allowed: true, result: "allow", action: "continue", reason: "ok", gateContext: nativeGateContext() }; },
+	}), undefined, undefined, undefined, new CandidateViewRegistry());
+	const result = await controller.execute("final-verification-no-transition", {
+		operation: "finalize",
+		lineageId: "final-verification",
+		input: JSON.stringify({ final_evidence: "verification run: passed", final_verification_outcome: "passed" }),
+	}, undefined, undefined, context(cwd));
+	const details = result.details as Record<string, unknown>;
+	assert.equal(details.outcome, "final-verification-transition-unavailable");
+	assert.equal(details.mutation_performed, true, "the committed evidence capture must never be reported as zero mutations");
+	assert.equal(details.mutation_outcome, "committed");
+	assert.equal(finalizes, 0, "no substitute finalize form may be invented");
+	assert.equal(transitions, 0);
+	assert.equal(validates, 0, "the validate gate must never be substituted for a missing transition");
+});
+
+// gentle-pi#311 P4-roles fixture: one provider-rendered SELF-CONTAINED role
+// capture vector (binding tokens + --agent=pi --execute=true, no submission).
+function bindProviderRoleVector(status: ReviewStatusV3, role: "refuter" | "targeted-validator"): ReviewStatusV3 {
+	const authority = status.authority!;
+	const contextHandle = `rctx1_${"c".repeat(64)}`;
+	const requestHash = `sha256:${"9".repeat(64)}`;
+	const argumentsList = [
+		{ name: "lineage", value: authority.lineageId, token: `--lineage=${authority.lineageId}` },
+		{ name: "expected-revision", value: authority.revision, token: `--expected-revision=${authority.revision}` },
+		{ name: "target", value: status.targetIdentity, token: `--target=${status.targetIdentity}` },
+		{ name: "repository-context", value: contextHandle, token: `--repository-context=${contextHandle}` },
+		...(role === "targeted-validator" ? [{ name: "request-hash", value: requestHash, token: `--request-hash=${requestHash}` }] : []),
+		{ name: "agent", value: "pi", token: "--agent=pi" },
+		{ name: "execute", value: "true", token: "--execute=true" },
+	];
+	status.nextTransition = {
+		kind: "collect",
+		reasonCode: role === "refuter" ? "provider_refuter_required" : "targeted_validation_required",
+		collect: { inputs: [role === "refuter" ? {
+			name: "provider_refuter",
+			schema: "https://gentle-ai.dev/schema/review/refuter/v1",
+			captureOperation: "review.capture-refuter",
+			arguments: argumentsList,
+		} : {
+			name: "provider_targeted_validator",
+			schema: "https://gentle-ai.dev/schema/review/validator/v1",
+			captureOperation: "review.capture-validation",
+			arguments: argumentsList,
+			validationRequest: {
+				schema: "gentle-ai.review-targeted-validation-request/v1" as const,
+				requestHash,
+				lineageId: authority.lineageId,
+				expectedRevision: authority.revision,
+				targetIdentity: status.targetIdentity,
+				fixFindingIds: ["RISK-001"],
+				projection: "workspace" as const,
+				correctionCandidateTree: status.projection.currentCandidateTree,
+				correctionTargetIdentity: status.targetIdentity,
+				correctionPaths: status.projection.paths,
+				correctionPathsDigest: status.projection.pathsDigest,
+			},
+		}] },
+	};
+	return status;
+}
+
+test("provider refuter vector executes exactly as rendered, then STATUS is re-queried", async (t) => {
+	const cwd = repository(t);
+	const executed: Array<{ captureOperation: string; argumentTokens: readonly string[]; cwd: string }> = [];
+	let finalizes = 0;
+	let statusCalls = 0;
+	const roleStatus = bindProviderRoleVector(targetStatusFixture({ lineageId: "native-lineage" }), "refuter");
+	const settledStatus = targetStatusFixture({ lineageId: "native-lineage" });
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			statusCalls += 1;
+			return statusCalls === 1 ? roleStatus : settledStatus;
+		},
+		finalize: async () => {
+			finalizes += 1;
 			return { lineageId: "native-lineage", state: "approved", action: "approved", storeRevision: "r1" };
 		},
+		captureProviderRole: async (request) => {
+			executed.push({ captureOperation: request.captureOperation, argumentTokens: request.argumentTokens, cwd: request.cwd });
+			return { schema: "gentle-ai.review-provider-role-capture/v1", lineageId: "native-lineage", targetIdentity: roleStatus.targetIdentity, role: "refuter", captured: true };
+		},
 	}));
-	await controller.execute("finalize-v212-start", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
-	const finding = { id: "RISK-001", lens: "review-risk", location: "lib/a.ts:1", severity: "CRITICAL", claim: "Candidate fails", evidence_class: "inferential", causal_disposition: "introduced", proof_refs: ["differential-test:candidate still fails"] };
-	const review_result = { lens_results: [{ lens: "review-risk", findings: [finding], evidence: ["complete candidate reviewed"] }] };
-	const requested = await controller.execute("finalize-v212-request", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({ review_result }) }, undefined, undefined, context(cwd));
-	const request_hash = (requested.details as { refuter_request: { request_hash: string } }).refuter_request.request_hash;
-	const refuterBatch = { schema: "gentle-ai.refuter-result-batch/v1", request_hash, results: [{ finding_id: "RISK-001", outcome: "inconclusive", proof_refs: ["differential-test:candidate still fails"] }] };
-	await controller.execute("finalize-v212", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({
-		review_result: { ...review_result, refuter_request_hash: request_hash },
-		refuter_batch: refuterBatch,
-		validation: { request_hash: "b".repeat(64), correction_ids: ["RISK-001"], original_criteria: { passed: false, evidence: ["acceptance still fails"] }, correction_regression: { passed: true, evidence: ["regression suite passes"] }, fix_caused_findings: [], follow_ups: [{ finding_id: "RISK-001", location: "lib/a.ts:1", summary: "Track the remaining failure", proof_refs: ["differential-test:candidate still fails"] }] },
-		final_evidence: "  focused verification failed\n\n",
-		final_verification_passed: false,
-	}) }, undefined, undefined, context(cwd));
-	assert.deepEqual(requests, [{
+	const result = await controller.execute("role-vector", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({}) }, undefined, undefined, context(cwd));
+	assert.deepEqual(executed, [{
+		captureOperation: "review.capture-refuter",
+		argumentTokens: [
+			"--lineage=native-lineage",
+			`--expected-revision=sha256:${"a".repeat(64)}`,
+			`--target=sha256:${"a".repeat(64)}`,
+			`--repository-context=rctx1_${"c".repeat(64)}`,
+			"--agent=pi",
+			"--execute=true",
+		],
 		cwd,
-		lineageId: "native-lineage",
-		lensResults: [{ lens: "review-risk", document: { lens: "risk", findings: [{ ...finding, lens: "risk" }], evidence: ["complete candidate reviewed"] } }],
-		refuterDocument: { results: refuterBatch.results },
-		validationDocument: { original_criteria: { passed: false, evidence: ["acceptance still fails"] }, correction_regression: { passed: true, evidence: ["regression suite passes"] }, follow_ups: [{ observation: "Track the remaining failure", proof_refs: ["differential-test:candidate still fails"] }] },
-		evidenceDocument: "  focused verification failed\n\n",
-		failed: true,
 	}]);
+	assert.equal(finalizes, 0, "role vectors never route through document finalize");
+	assert.equal(statusCalls, 2, "STATUS must be re-queried after the vector executes");
+	const details = result.details as { provider_roles?: { transport?: string; executed_slots?: Array<Record<string, unknown>> } };
+	assert.equal(details.provider_roles?.transport, "go_owned_pi_process");
+	assert.deepEqual(details.provider_roles?.executed_slots?.map((slot) => slot.role), ["refuter"]);
 });
 
-test("native FINALIZE rejects unpublished reviewer enums and empty arrays before native calls", async (t) => {
+test("provider targeted-validator vector keeps the frozen request hash token verbatim", async (t) => {
 	const cwd = repository(t);
-	let finalizes = 0;
-	const { controller } = runtime(fakeNative({ finalize: async () => {
-		finalizes += 1;
-		return { lineageId: "native-lineage", state: "validating", action: "continue", storeRevision: "r1" };
-	} }));
-	const finding = { id: "RISK-001", lens: "review-risk", location: "lib/a.ts:1", severity: "CRITICAL", claim: "Candidate fails", evidence_class: "inferential", causal_disposition: "introduced", proof_refs: ["differential-test:candidate still fails"] };
-	for (const lensResult of [
-		{ lens: "review-unknown", findings: [finding], evidence: ["reviewed"] },
-		{ lens: "review-risk", findings: [{ ...finding, lens: "review-unknown" }], evidence: ["reviewed"] },
-		{ lens: "review-risk", findings: [{ ...finding, severity: "INFO" }], evidence: ["reviewed"] },
-		{ lens: "review-risk", findings: [{ ...finding, evidence_class: "info" }], evidence: ["reviewed"] },
-		{ lens: "review-risk", findings: [{ ...finding, evidence_class: "unknown" }], evidence: ["reviewed"] },
-		{ lens: "review-risk", findings: [{ ...finding, causal_disposition: "candidate-caused" }], evidence: ["reviewed"] },
-		{ lens: "review-risk", findings: [{ ...finding, proof_refs: [] }], evidence: ["reviewed"] },
-		{ lens: "review-risk", findings: [], evidence: [] },
-	]) {
-		await assert.rejects(controller.execute("invalid-reviewer", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({ review_result: { lens_results: [lensResult] } }) }, undefined, undefined, context(cwd)));
-	}
-	assert.equal(finalizes, 0);
-});
+	const executed: string[][] = [];
+	let statusCalls = 0;
+	const roleStatus = bindProviderRoleVector(targetStatusFixture({ lineageId: "native-lineage", authorityState: "validating" }), "targeted-validator");
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			statusCalls += 1;
+			return statusCalls === 1 ? roleStatus : targetStatusFixture({ lineageId: "native-lineage" });
+		},
+		captureProviderRole: async (request) => {
+			executed.push([...request.argumentTokens]);
+			return { schema: "gentle-ai.review-provider-role-capture/v1", lineageId: "native-lineage", targetIdentity: roleStatus.targetIdentity, role: "targeted-validator", captured: true };
+		},
+	}));
+	await controller.execute("validator-vector", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({}) }, undefined, undefined, context(cwd));
+	assert.equal(executed.length, 1);
+	assert.ok(executed[0]!.includes(`--request-hash=sha256:${"9".repeat(64)}`), "the frozen request hash token must pass through verbatim");
+	assert.ok(executed[0]!.includes("--execute=true"));
+});
 
-test("native FINALIZE validates refuter request binding, completeness, and rows before native calls", async (t) => {
+test("a failed provider role vector surfaces the typed error and never auto-relaunches", async (t) => {
+	const cwd = repository(t);
+	let captures = 0;
+	let statusCalls = 0;
+	const roleStatus = bindProviderRoleVector(targetStatusFixture({ lineageId: "native-lineage" }), "refuter");
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			statusCalls += 1;
+			return roleStatus;
+		},
+		captureProviderRole: async () => {
+			captures += 1;
+			throw new NativeReviewCliError(NATIVE_REVIEW_ERROR_CODE.NON_ZERO, NATIVE_REVIEW_OPERATION.CAPTURE_PROVIDER_ROLE, true, "provider refused the role capture");
+		},
+	}));
+	const result = await controller.execute("role-vector-failure", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({}) }, undefined, undefined, context(cwd));
+	const details = result.details as Record<string, unknown>;
+	assert.equal(details.outcome, "provider-role-vector-failed");
+	assert.equal(details.status, "blocked");
+	assert.match(String(details.retry_discipline), /Re-query negotiated STATUS/);
+	assert.equal(captures, 1, "a failed vector must not be relaunched from transcript inference");
+	assert.equal(statusCalls, 1, "the failure envelope is surfaced without a blind relaunch loop");
+});
+
+test("negotiated FINALIZE executes the provider-rendered captured-results transition verbatim", async (t) => {
+	const cwd = repository(t);
+	const transitions: Array<{ cwd: string; argumentTokens: readonly string[] }> = [];
+	let finalizes = 0;
+	const status = targetStatusFixture({ lineageId: "native-lineage" });
+	status.nextTransition = {
+		kind: "execute",
+		reasonCode: "captured_results_ready",
+		execute: {
+			operation: "review.finalize",
+			// The second argument deliberately omits `token` to pin the
+			// provider's published hyphenation fallback (captured_results ->
+			// --captured-results=true); the host never invents another form.
+			arguments: [
+				{ name: "lineage", value: "native-lineage", token: "--lineage=native-lineage" },
+				{ name: "captured_results", value: "true" },
+			],
+			preconditions: [{ name: "state", value: "reviewing" }],
+			binding: { targetIdentity: status.targetIdentity, lineageId: "native-lineage" },
+		},
+	};
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => status,
+		finalize: async () => {
+			finalizes += 1;
+			return { lineageId: "native-lineage", state: "approved", action: "approved", storeRevision: "r1" };
+		},
+		finalizeTransition: async (request) => {
+			transitions.push({ cwd: request.cwd, argumentTokens: request.argumentTokens });
+			return { lineageId: "native-lineage", state: "approved", action: "approved", storeRevision: "r1", receiptPath: "/opaque/receipt" };
+		},
+	}));
+	const result = await controller.execute("captured-results-finalize", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({}) }, undefined, undefined, context(cwd));
+	assert.deepEqual(transitions, [{ cwd, argumentTokens: ["--lineage=native-lineage", "--captured-results=true"] }]);
+	assert.equal(finalizes, 0, "the provider-driven lane never assembles a document finalize");
+	assert.deepEqual(result.details, { operation: "finalize", result: { lineage_id: "native-lineage", state: "approved", action: "approved", store_revision: "r1", receipt_path: "/opaque/receipt" } });
+});
+
+test("negotiated FINALIZE refuses a finalize transition bound to a different lineage", async (t) => {
+	const cwd = repository(t);
+	let transitions = 0;
+	const status = targetStatusFixture({ lineageId: "native-lineage" });
+	status.nextTransition = {
+		kind: "execute",
+		reasonCode: "captured_results_ready",
+		execute: {
+			operation: "review.finalize",
+			arguments: [{ name: "lineage", value: "other-lineage", token: "--lineage=other-lineage" }],
+			preconditions: [],
+			binding: { targetIdentity: status.targetIdentity, lineageId: "other-lineage" },
+		},
+	};
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => status,
+		finalizeTransition: async () => {
+			transitions += 1;
+			return { lineageId: "other-lineage", state: "approved", action: "approved", storeRevision: "r1" };
+		},
+	}));
+	const result = await controller.execute("foreign-transition", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({}) }, undefined, undefined, context(cwd));
+	assert.equal((result.details as { outcome?: string }).outcome, "native-operation-failed");
+	assert.match(JSON.stringify(result.details), /finalize-transition-binding-drift/);
+	assert.equal(transitions, 0);
+});
+
+test("native FINALIZE rejects the retired Pi-authored payload fields before native calls", async (t) => {
 	const cwd = repository(t);
 	let finalizes = 0;
 	const { controller } = runtime(fakeNative({ finalize: async () => {
 		finalizes += 1;
 		return { lineageId: "native-lineage", state: "validating", action: "continue", storeRevision: "r1" };
 	} }));
-	const expectedHash = "a".repeat(64);
-	const proof = "differential-test:candidate still fails";
-	const finding = { id: "RISK-001", lens: "review-risk", location: "lib/a.ts:1", severity: "CRITICAL", claim: "Candidate fails", evidence_class: "inferential", causal_disposition: "introduced", proof_refs: [proof] };
-	const row = { finding_id: finding.id, outcome: "corroborated", proof_refs: [proof] };
-	for (const refuter_batch of [
-		{ schema: "gentle-ai.refuter-result-batch/v1", request_hash: "b".repeat(64), results: [row] },
-		{ schema: "gentle-ai.refuter-result-batch/v1", request_hash: expectedHash, results: [] },
-		{ schema: "gentle-ai.refuter-result-batch/v1", request_hash: expectedHash, results: [row, row] },
-		{ schema: "gentle-ai.refuter-result-batch/v1", request_hash: expectedHash, results: [{ ...row, finding_id: "RISK-002" }] },
-		{ schema: "gentle-ai.refuter-result-batch/v1", request_hash: expectedHash, results: [{ ...row, proof_refs: [] }] },
+	for (const retired of [
+		{ review_result: { lens_results: [{ lens: "review-risk", findings: [], evidence: ["reviewed"] }] } },
+		{ refuter_batch: { schema: "gentle-ai.refuter-result-batch/v1", request_hash: "a".repeat(64), results: [] } },
+		{ validation_proof: { original_criteria: { passed: true, evidence: ["ok"] }, correction_regression: { passed: true, evidence: ["ok"] } } },
 	]) {
-		await assert.rejects(controller.execute("invalid-refuter", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({
-			review_result: { lens_results: [{ lens: "review-risk", findings: [finding], evidence: ["reviewed"] }], refuter_request_hash: expectedHash },
-			refuter_batch,
-		}) }, undefined, undefined, context(cwd)));
+		await assert.rejects(controller.execute("retired-field", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify(retired) }, undefined, undefined, context(cwd)));
 	}
 	assert.equal(finalizes, 0);
 });
@@ -1452,17 +1814,19 @@ test("controller rejects zero-length final evidence before native calls", async
 	assert.equal(finalizes, 0);
 });
 
-test("repeated native FINALIZE keeps initial lenses one-shot", async (t) => {
+test("native FINALIZE never assembles reviewer documents and forwards only the correction forecast", async (t) => {
 	const cwd = repository(t);
 	const requests: Parameters<NativeReviewCli["finalize"]>[0][] = [];
 	const { controller } = runtime(fakeNative({ finalize: async (request) => {
 		requests.push(request);
 		return { lineageId: "native-lineage", state: "correction_required", action: "continue correction", storeRevision: `r${requests.length}` };
 	} }));
-	await controller.execute("initial", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({ review_result: { lens_results: [{ findings: [], evidence: ["complete candidate reviewed"] }] } }) }, undefined, undefined, context(cwd));
+	await controller.execute("initial", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({}) }, undefined, undefined, context(cwd));
 	await controller.execute("retry", { operation: "finalize", lineageId: "native-lineage", input: JSON.stringify({ correction_line_forecast: 1 }) }, undefined, undefined, context(cwd));
-	assert.equal(requests[0]?.lensResults?.length, 1);
+	assert.equal(requests[0]?.lensResults, undefined, "lens results are admitted natively, never Pi-assembled");
+	assert.equal(requests[0]?.refuterDocument, undefined);
 	assert.equal(requests[1]?.lensResults, undefined);
+	assert.equal(requests[1]?.correctionLines, 1);
 });
 
 test("native error has no compact fallback and ambiguous mutation demands target status", async (t) => {
@@ -1510,6 +1874,35 @@ test("native START preserves a candidate-view diagnostic before native invocatio
 	assert.equal(starts, 0);
 });
 
+test("native START returns a structured pre-native candidate-view output-limit diagnostic without calling native START", async (t) => {
+	const cwd = repository(t);
+	let starts = 0;
+	const candidateViews = new CandidateViewRegistry(() => {
+		throw Object.assign(new Error("sensitive stderr and candidate bytes"), { code: "ENOBUFS", stderr: Buffer.from("sensitive stderr and candidate bytes") });
+	});
+	const { controller } = runtime(fakeNative({
+		start: async () => {
+			starts += 1;
+			return { lineageId: "must-not-start", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: true };
+		},
+	}), undefined, undefined, undefined, candidateViews);
+	const result = await controller.execute("candidate-view-output-limit", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
+	const details = result.details as Record<string, unknown>;
+	assert.equal(details.outcome, "native-operation-failed");
+	assert.equal(details.lineage_created, false);
+	assert.equal(details.mutation_outcome, "none");
+	assert.deepEqual(details.diagnostics, {
+		phase: "candidate-view",
+		category: "output-limit",
+		git_subcommand: "rev-parse",
+		timeout_ms: 10_000,
+		max_buffer_bytes: 64 * 1024 * 1024,
+		message: "candidate-view Git command rev-parse exceeded the 67108864-byte output limit; inspect the candidate state before any new START",
+	});
+	assert.doesNotMatch(JSON.stringify(details), /sensitive stderr|candidate bytes/);
+	assert.equal(starts, 0);
+});
+
 test("ambiguous native START failure preserves rebuilt sanitized diagnostics across duplicated module instances", async (t) => {
 	const cwd = mkdtempSync(join(tmpdir(), "gentle-pi-native-controller-"));
 	t.after(() => rmSync(cwd, { recursive: true, force: true }));
@@ -1607,6 +2000,83 @@ test("native START uses the default policy or a canonical safe policy path, and
 	assert.equal(requests.length, 2);
 });
 
+test("native ordinary START forwards every allowed focus and leaves the native default omitted", async (t) => {
+	const cwd = repository(t);
+	const requests: Parameters<NativeReviewCli["start"]>[0][] = [];
+	const { controller } = runtime(fakeNative({
+		start: async (request) => {
+			requests.push(request);
+			return { lineageId: `native-${request.focus ?? "default"}`, state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 2, changedLines: 7, correctionBudget: 4, action: "created", lensesRequired: true };
+		},
+		targetStatus: async () => targetStatusFixture({ applicability: "unrelated", action: "start" }),
+	}));
+	for (const focus of ["risk", "resilience", "readability", "reliability"] as const) {
+		await controller.execute(`focused-${focus}`, { operation: "start", input: JSON.stringify({ mode: "ordinary", focus }) }, undefined, undefined, context(cwd));
+	}
+	await controller.execute("default-focus", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
+	assert.deepEqual(requests, [
+		...(["risk", "resilience", "readability", "reliability"] as const).map((focus) => ({ cwd, focus, targetIdentity: `sha256:${"a".repeat(64)}`, projection: "workspace" as const })),
+		{ cwd, targetIdentity: `sha256:${"a".repeat(64)}`, projection: "workspace" },
+	]);
+});
+
+test("native ordinary START rejects invalid focus before native calls", async (t) => {
+	const cwd = repository(t);
+	let starts = 0;
+	const { controller } = runtime(fakeNative({
+		start: async () => {
+			starts += 1;
+			return { lineageId: "must-not-start", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: true };
+		},
+		targetStatus: async () => targetStatusFixture({ applicability: "unrelated", action: "start" }),
+	}));
+	for (const focus of ["", "risk ", "RISK", "all", 42, null, [], {}]) {
+		const rejected = await controller.execute("invalid-focus", { operation: "start", input: JSON.stringify({ mode: "ordinary", focus }) }, undefined, undefined, context(cwd));
+		assert.deepEqual(rejected.details, {
+			operation: "start",
+			status: "blocked",
+			outcome: "native-start-input-invalid",
+			reason: "focus-invalid",
+			lineage_created: false,
+			mutation_performed: false,
+			mutation_outcome: "none",
+			reset_eligible: false,
+		});
+	}
+	assert.equal(starts, 0);
+});
+
+test("native ordinary START rejects malformed input before resolving the review-mode gate", async (t) => {
+	const cwd = repository(t);
+	let reviewModeCalls = 0;
+	let starts = 0;
+	const { controller } = runtime(fakeNative({
+		reviewMode: async () => {
+			reviewModeCalls += 1;
+			throw new Error("review mode must not be resolved for malformed ordinary START input");
+		},
+		start: async () => {
+			starts += 1;
+			return { lineageId: "must-not-start", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: true };
+		},
+	}));
+	for (const [input, reason] of [
+		[{ mode: "ordinary", policyHash: "legacy" }, "legacy-policy-hash-unsupported"],
+		[{ mode: "ordinary", focus: "all" }, "focus-invalid"],
+		[{ mode: "ordinary", unexpected: true }, "unknown-field"],
+		[{ mode: "ordinary", policyPath: "outside.json" }, "policy-path-outside-scope"],
+		[{ mode: "ordinary", baseRef: " " }, "base-ref-invalid"],
+		[{ mode: "ordinary", baseRef: "origin/main" }, "committed-only-required"],
+		[{ mode: "ordinary", committedOnly: true }, "committed-only-invalid"],
+		[{ mode: "ordinary", baseRef: "refs/heads/missing", committedOnly: true }, "base-ref-unresolvable"],
+	] as const) {
+		const rejected = await controller.execute("malformed-start", { operation: "start", input: JSON.stringify(input) }, undefined, undefined, context(cwd));
+		assert.equal((rejected.details as { reason?: unknown }).reason, reason);
+	}
+	assert.equal(reviewModeCalls, 0);
+	assert.equal(starts, 0);
+});
+
 test("native START preserves the default dirty-inclusive candidate without base flags", async (t) => {
 	const cwd = repository(t);
 	writeFileSync(join(cwd, "app.ts"), "export const value = 2;\n");
@@ -1662,6 +2132,47 @@ test("native START binds an acknowledged committed range and native identity to
 	}
 });
 
+test("native START binds a default dirty-inclusive candidate on an unborn repository against Git's empty tree", async (t) => {
+	// Unborn repository: symbolic HEAD, no commits, staged + untracked content.
+	// The default targetStatus helper builds a REAL candidate view from this
+	// repo, so this exercises the real resolveCandidateBase/materializeCandidate
+	// path on an unborn repository, not a synthetic adapter stub.
+	const cwd = mkdtempSync(join(tmpdir(), "gentle-pi-native-controller-unborn-"));
+	t.after(() => rmSync(cwd, { recursive: true, force: true }));
+	execFileSync("git", ["init", "-b", "main"], { cwd });
+	writeFileSync(join(cwd, "staged.txt"), "first staged\n");
+	execFileSync("git", ["add", "staged.txt"], { cwd });
+	writeFileSync(join(cwd, "untracked.ts"), "export const untracked = true;\n");
+	const emptyTree = execFileSync("git", ["-C", cwd, "mktree"], { encoding: "utf8", input: "" }).trim();
+	const candidateViews = new CandidateViewRegistry();
+	const requests: Parameters<NativeReviewCli["start"]>[0][] = [];
+	const { controller } = runtime(fakeNative({
+		start: async (request) => {
+			requests.push(request);
+			return { lineageId: "unborn-lineage", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 2, changedLines: 2, correctionBudget: 1, action: "created", lensesRequired: true };
+		},
+	}), undefined, undefined, undefined, candidateViews);
+	const started = await controller.execute("unborn-start", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
+	const view = candidateViews.resolveForLens("unborn-lineage", "review-reliability");
+	try {
+		// The unborn candidate base is Git's empty tree, not a phantom commit.
+		assert.equal(view.baseTree, emptyTree);
+		assert.equal(view.baseCommit, "HEAD");
+		assert.equal(view.committedOnly, false);
+		// Staged and untracked workspace content is preserved in the candidate.
+		assert.deepEqual(view.paths, ["staged.txt", "untracked.ts"]);
+		// No baseRef is sent to native START: the unborn default uses the
+		// workspace projection only, exactly as the provider expects.
+		assert.deepEqual(requests, [{ cwd, targetIdentity: `sha256:${"a".repeat(64)}`, projection: "workspace" }]);
+		const actorBinding = (started.details as { actor_binding: { workspace_root: string; candidate_root: string; candidate_tree: string; candidate_paths: readonly string[] } }).actor_binding;
+		assert.equal(actorBinding.workspace_root, cwd);
+		assert.equal(actorBinding.candidate_tree, view.candidateTree);
+		assert.deepEqual(actorBinding.candidate_paths, view.paths);
+	} finally {
+		view.cleanup();
+	}
+});
+
 test("native START fails closed before mutation when the workspace target and immutable candidate view differ", async (t) => {
 	const cwd = repository(t);
 	writeFileSync(join(cwd, "app.ts"), "export const value = 2;\n");
@@ -1718,6 +2229,52 @@ test("native START re-verifies candidate-view integrity before granting workspac
 	assert.equal(starts, 0);
 });
 
+test("native START preserves an explicit base-resolution timeout diagnostic without native START", async (t) => {
+	const cwd = repository(t);
+	const bin = join(cwd, "test-bin");
+	mkdirSync(bin);
+	const fakeGit = join(bin, "git");
+	writeFileSync(fakeGit, "#!/bin/sh\nexec sleep 1\n");
+	chmodSync(fakeGit, 0o755);
+	const previousPath = process.env.PATH;
+	const previousTimeout = process.env.GENTLE_PI_CANDIDATE_GIT_TIMEOUT_MS;
+	t.after(() => {
+		if (previousPath === undefined) delete process.env.PATH;
+		else process.env.PATH = previousPath;
+		if (previousTimeout === undefined) delete process.env.GENTLE_PI_CANDIDATE_GIT_TIMEOUT_MS;
+		else process.env.GENTLE_PI_CANDIDATE_GIT_TIMEOUT_MS = previousTimeout;
+	});
+	process.env.PATH = `${bin}${delimiter}${previousPath ?? ""}`;
+	process.env.GENTLE_PI_CANDIDATE_GIT_TIMEOUT_MS = "1";
+	let starts = 0;
+	let statuses = 0;
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			statuses += 1;
+			throw new Error("target status must not run after base resolution fails");
+		},
+		start: async () => {
+			starts += 1;
+			return { lineageId: "must-not-start", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: true };
+		},
+	}), undefined, undefined, undefined, new CandidateViewRegistry());
+	const result = await controller.execute("base-resolution-timeout", { operation: "start", input: JSON.stringify({ mode: "ordinary", baseRef: "refs/heads/main", committedOnly: true }) }, undefined, undefined, context(cwd));
+	const details = result.details as Record<string, unknown>;
+	assert.equal(details.outcome, "native-operation-failed");
+	assert.equal(details.lineage_created, false);
+	assert.equal(details.mutation_outcome, "none");
+	assert.deepEqual(details.diagnostics, {
+		phase: "candidate-view",
+		category: "timeout",
+		git_subcommand: "for-each-ref",
+		timeout_ms: 1,
+		max_buffer_bytes: 64 * 1024 * 1024,
+		message: "candidate-view Git command for-each-ref timed out after 1ms; inspect the candidate state before any new START",
+	});
+	assert.equal(statuses, 0);
+	assert.equal(starts, 0);
+});
+
 test("native START rejects an unresolvable explicit base before native mutation", async (t) => {
 	const cwd = repository(t);
 	let starts = 0;
@@ -1852,33 +2409,294 @@ test("native ordinary START blocks unknown input fields before native calls", as
 	const { controller } = runtime(fakeNative({
 		start: async () => {
 			starts += 1;
-			return { lineageId: "native-lineage", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 2, changedLines: 7, correctionBudget: 4, action: "created", lensesRequired: true };
+			return { lineageId: "native-lineage", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 2, changedLines: 7, correctionBudget: 4, action: "created", lensesRequired: true };
+		},
+	}));
+	for (const field of ["base_ref", "focus_mode", "unexpected"]) {
+		const rejected = await controller.execute("unknown-start-field", { operation: "start", input: JSON.stringify({ mode: "ordinary", [field]: "origin/main" }) }, undefined, undefined, context(cwd));
+		assert.deepEqual(rejected.details, {
+			operation: "start",
+			status: "blocked",
+			outcome: "native-start-input-invalid",
+			reason: "unknown-field",
+			field,
+			lineage_created: false,
+			mutation_performed: false,
+			mutation_outcome: "none",
+			reset_eligible: false,
+		});
+	}
+	assert.equal(starts, 0);
+});
+
+test("ordinary START rejects a legacy policy hash before native availability", async (t) => {
+	const cwd = repository(t);
+	const { controller } = runtime(null);
+	const result = await controller.execute("legacy-start", { operation: "start", input: JSON.stringify({ mode: "ordinary", policyHash: "a".repeat(64) }) }, undefined, undefined, context(cwd));
+	assert.equal((result.details as { outcome?: string }).outcome, "native-start-legacy-policy-hash-unsupported");
+});
+
+test("INSPECT reports a missing package-local native binary with fail-closed reinstall guidance", async (t) => {
+	const cwd = repository(t);
+	const rawPath = "/private/workspace/.gentle-ai/gentle-ai";
+	const rawSecret = "package-binary-secret";
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			throw new NativeReviewCliError(
+				NATIVE_REVIEW_ERROR_CODE.PACKAGE_BINARY_MISSING,
+				NATIVE_REVIEW_OPERATION.VERSION,
+				false,
+				false,
+				`missing ${rawPath} token=${rawSecret}`,
+			);
+		},
+	}));
+	const response = await controller.execute("inspect-package-binary-missing", { operation: "inspect" }, undefined, undefined, context(cwd));
+	const details = response.details as Record<string, unknown>;
+	assert.equal(details.status, "blocked");
+	assert.equal(details.outcome, "native-status-package-binary-missing");
+	assert.deepEqual(details.diagnostics, {
+		operation: NATIVE_REVIEW_OPERATION.VERSION,
+		error_code: NATIVE_REVIEW_ERROR_CODE.PACKAGE_BINARY_MISSING,
+		timed_out: false,
+		output_limit_exceeded: false,
+	});
+	assert.equal(details.inventory_complete, false);
+	assert.equal(details.mutation_performed, false);
+	assert.equal(details.mutation_outcome, "none");
+	assert.equal(details.next_action, "reinstall-package-local-gentle-ai");
+	assert.doesNotMatch(JSON.stringify(details), new RegExp(`${rawPath}|${rawSecret}`));
+});
+
+test("START reports a missing package-local native binary before any native mutation", async (t) => {
+	const cwd = repository(t);
+	let starts = 0;
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			throw new NativeReviewCliError(
+				NATIVE_REVIEW_ERROR_CODE.PACKAGE_BINARY_MISSING,
+				NATIVE_REVIEW_OPERATION.VERSION,
+				false,
+				false,
+				"package-local binary missing",
+			);
+		},
+		start: async () => {
+			starts += 1;
+			return { lineageId: "must-not-start", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: true };
+		},
+	}));
+	const response = await controller.execute("start-package-binary-missing", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
+	const details = response.details as Record<string, unknown>;
+	assert.equal(details.status, "blocked");
+	assert.equal(details.outcome, "native-status-package-binary-missing");
+	assert.equal(details.inventory_complete, false);
+	assert.equal(details.lineage_created, false);
+	assert.equal(details.mutation_performed, false);
+	assert.equal(details.mutation_outcome, "none");
+	assert.equal(details.next_action, "reinstall-package-local-gentle-ai");
+	assert.equal(starts, 0);
+});
+
+test("REPAIR reports a missing package-local native binary without touching authority", async (t) => {
+	const cwd = repository(t);
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			throw new NativeReviewCliError(
+				NATIVE_REVIEW_ERROR_CODE.PACKAGE_BINARY_MISSING,
+				NATIVE_REVIEW_OPERATION.VERSION,
+				false,
+				false,
+				"package-local binary missing",
+			);
+		},
+	}));
+	const response = await controller.execute("repair-package-binary-missing", { operation: "repair" }, undefined, undefined, context(cwd));
+	const details = response.details as Record<string, unknown>;
+	assert.equal(details.status, "blocked");
+	assert.equal(details.outcome, "native-status-package-binary-missing");
+	assert.equal(details.inventory_complete, false);
+	assert.equal(details.mutation_performed, false);
+	assert.equal(details.mutation_outcome, "none");
+	assert.equal(details.next_action, "reinstall-package-local-gentle-ai");
+});
+
+test("START preserves bounded sanitized version-process diagnostics before native mutation", async (t) => {
+	const cwd = repository(t);
+	const rawPath = "/private/workspace/gentle-ai";
+	const rawSecret = "version-process-secret";
+	const stderr = `version process failed token=${rawSecret}\n${"x".repeat(5_000)}`;
+	const foreignError = Object.assign(new Error(`version process failed at ${rawPath} token=${rawSecret}`), {
+		name: "NativeReviewCliError",
+		code: NATIVE_REVIEW_ERROR_CODE.NON_ZERO,
+		diagnostics: {
+			operation: NATIVE_REVIEW_OPERATION.VERSION,
+			error_code: NATIVE_REVIEW_ERROR_CODE.NON_ZERO,
+			exit_code: 17,
+			timed_out: false,
+			output_limit_exceeded: false,
+			stderr,
+		},
+	});
+	let starts = 0;
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => { throw foreignError; },
+		start: async () => {
+			starts += 1;
+			return { lineageId: "must-not-start", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: true };
+		},
+	}));
+	const response = await controller.execute("start-version-process-failure", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
+	const details = response.details as Record<string, unknown>;
+	const diagnostics = details.diagnostics as { operation?: string; error_code?: string; stderr?: string };
+	assert.equal(details.status, "blocked");
+	assert.equal(details.outcome, "native-operation-failed");
+	assert.equal(diagnostics.operation, NATIVE_REVIEW_OPERATION.VERSION);
+	assert.equal(diagnostics.error_code, NATIVE_REVIEW_ERROR_CODE.NON_ZERO);
+	assert.match(diagnostics.stderr ?? "", /token=\[REDACTED\]/);
+	assert.ok((diagnostics.stderr?.length ?? 0) <= 4_096);
+	assert.equal(details.lineage_created, false);
+	assert.equal(details.mutation_performed, false);
+	assert.equal(details.mutation_outcome, "none");
+	assert.equal(starts, 0);
+	assert.doesNotMatch(JSON.stringify(details), new RegExp(`${rawPath}|${rawSecret}`));
+
+	const inspect = await controller.execute("inspect-version-process-failure", { operation: "inspect" }, undefined, undefined, context(cwd));
+	const inspectDetails = inspect.details as Record<string, unknown>;
+	assert.equal(inspectDetails.status, "blocked");
+	assert.equal(inspectDetails.outcome, "native-status-unavailable");
+	assert.deepEqual(inspectDetails.diagnostics, details.diagnostics);
+	assert.equal(inspectDetails.inventory_complete, false);
+	assert.equal(inspectDetails.mutation_performed, false);
+	assert.equal(inspectDetails.mutation_outcome, "none");
+	assert.doesNotMatch(JSON.stringify(inspectDetails), new RegExp(`${rawPath}|${rawSecret}`));
+});
+
+test("INSPECT preserves bounded sanitized review/status process diagnostics and remains fail-closed", async (t) => {
+	const cwd = repository(t);
+	const rawPath = "/private/workspace/review-status";
+	const rawSecret = "review-status-secret";
+	const stderr = `review status failed token=${rawSecret}\n${"x".repeat(5_000)}`;
+	const foreignError = Object.assign(new Error(`review status failed at ${rawPath} token=${rawSecret}`), {
+		name: "NativeReviewCliError",
+		code: NATIVE_REVIEW_ERROR_CODE.NON_ZERO,
+		diagnostics: {
+			operation: NATIVE_REVIEW_OPERATION.STATUS,
+			error_code: NATIVE_REVIEW_ERROR_CODE.NON_ZERO,
+			exit_code: 18,
+			timed_out: false,
+			output_limit_exceeded: false,
+			stderr,
+		},
+	});
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => { throw foreignError; },
+	}));
+	const response = await controller.execute("inspect-review-status-process-failure", { operation: "inspect" }, undefined, undefined, context(cwd));
+	const details = response.details as Record<string, unknown>;
+	const diagnostics = details.diagnostics as { operation?: string; error_code?: string; stderr?: string };
+	assert.equal(details.status, "blocked");
+	assert.equal(details.outcome, "native-status-unavailable");
+	assert.equal(diagnostics.operation, NATIVE_REVIEW_OPERATION.STATUS);
+	assert.equal(diagnostics.error_code, NATIVE_REVIEW_ERROR_CODE.NON_ZERO);
+	assert.match(diagnostics.stderr ?? "", /token=\[REDACTED\]/);
+	assert.ok((diagnostics.stderr?.length ?? 0) <= 4_096);
+	assert.equal(details.inventory_complete, false);
+	assert.equal(details.mutation_performed, false);
+	assert.equal(details.mutation_outcome, "none");
+	assert.doesNotMatch(JSON.stringify(details), new RegExp(`${rawPath}|${rawSecret}`));
+});
+
+test("INSPECT keeps version-incompatible target status failures mapped to native-status-unsupported", async (t) => {
+	const cwd = repository(t);
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			throw new NativeReviewCliError(
+				NATIVE_REVIEW_ERROR_CODE.VERSION_INCOMPATIBLE,
+				NATIVE_REVIEW_OPERATION.VERSION,
+				true,
+				false,
+				"native version is incompatible",
+			);
+		},
+	}));
+	const response = await controller.execute("inspect-version-incompatible", { operation: "inspect" }, undefined, undefined, context(cwd));
+	const details = response.details as Record<string, unknown>;
+	assert.equal(details.status, "blocked");
+	assert.equal(details.outcome, "native-status-unsupported");
+	assert.equal(details.inventory_complete, false);
+	assert.equal(details.mutation_performed, false);
+	assert.equal(details.mutation_outcome, undefined);
+});
+
+test("INSPECT preserves output-limit diagnostics from native review status and remains fail-closed", async (t) => {
+	const cwd = repository(t);
+	const diagnostics = {
+		operation: NATIVE_REVIEW_OPERATION.STATUS,
+		error_code: NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT,
+		output_limit_exceeded: true,
+		timed_out: false,
+	};
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			throw new NativeReviewCliError(
+				NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT,
+				NATIVE_REVIEW_OPERATION.STATUS,
+				true,
+				false,
+				"native process output exceeded limit",
+				diagnostics,
+			);
+		},
+	}));
+	const response = await controller.execute("inspect-output-limit", { operation: "inspect" }, undefined, undefined, context(cwd));
+	const details = response.details as Record<string, unknown>;
+	assert.equal(details.status, "blocked");
+	assert.equal(details.outcome, "native-status-unavailable");
+	assert.deepEqual(details.diagnostics, diagnostics);
+	assert.equal(details.inventory_complete, false);
+	assert.equal(details.next_action, "require-complete-native-authority-inventory");
+	assert.equal(details.mutation_performed, false);
+	assert.equal(details.mutation_outcome, "none");
+});
+
+test("START preserves actionable review/status output-limit diagnostics before native mutation", async (t) => {
+	const cwd = repository(t);
+	const diagnostics = {
+		operation: NATIVE_REVIEW_OPERATION.STATUS,
+		error_code: NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT,
+		output_limit_exceeded: true,
+		timed_out: false,
+		max_buffer_bytes: 16 * 1024 * 1024,
+		configuration_hint: "Inspect native review state before any new START; GENTLE_PI_REVIEW_MAX_BUFFER_BYTES accepts a positive decimal up to 67108864.",
+	};
+	let starts = 0;
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			throw new NativeReviewCliError(
+				NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT,
+				NATIVE_REVIEW_OPERATION.STATUS,
+				true,
+				false,
+				"native process output exceeded limit",
+				diagnostics,
+			);
+		},
+		start: async () => {
+			starts += 1;
+			return { lineageId: "must-not-start", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: true };
 		},
 	}));
-	for (const field of ["base_ref", "unexpected"]) {
-		const rejected = await controller.execute("unknown-start-field", { operation: "start", input: JSON.stringify({ mode: "ordinary", [field]: "origin/main" }) }, undefined, undefined, context(cwd));
-		assert.deepEqual(rejected.details, {
-			operation: "start",
-			status: "blocked",
-			outcome: "native-start-input-invalid",
-			reason: "unknown-field",
-			field,
-			lineage_created: false,
-			mutation_performed: false,
-			mutation_outcome: "none",
-			reset_eligible: false,
-		});
-	}
+	const response = await controller.execute("start-status-output-limit", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
+	const details = response.details as Record<string, unknown>;
+	assert.equal(details.status, "blocked");
+	assert.equal(details.outcome, "native-operation-failed");
+	assert.deepEqual(details.diagnostics, diagnostics);
+	assert.equal(details.lineage_created, false);
+	assert.equal(details.mutation_outcome, "none");
 	assert.equal(starts, 0);
 });
 
-test("ordinary START fails closed before legacy policy handling when target status is unavailable", async (t) => {
-	const cwd = repository(t);
-	const { controller } = runtime(null);
-	const result = await controller.execute("legacy-start", { operation: "start", input: JSON.stringify({ mode: "ordinary", policyHash: "a".repeat(64) }) }, undefined, undefined, context(cwd));
-	assert.equal((result.details as { outcome?: string }).outcome, "native-status-unsupported");
-});
-
 test("general STATUS and INSPECT use negotiated target status without mutation or inventory reads", async (t) => {
 	const cwd = mkdtempSync(join(tmpdir(), "gentle-pi-native-controller-"));
 	t.after(() => rmSync(cwd, { recursive: true, force: true }));
@@ -1922,7 +2740,7 @@ test("legacy compact FINALIZE is a typed read-only rejection without native fall
 	}));
 	const result = await controller.execute(
 		"legacy-finalize",
-		{ operation: "finalize", lineageId, input: JSON.stringify({ review_result: { lens_results: [] } }) },
+		{ operation: "finalize", lineageId, input: JSON.stringify({}) },
 		undefined,
 		undefined,
 		context(cwd),
@@ -1962,7 +2780,7 @@ test("legacy graph-v1 FINALIZE is a typed read-only rejection without native fal
 	}));
 	const result = await controller.execute(
 		"legacy-graph-finalize",
-		{ operation: "finalize", lineageId, input: JSON.stringify({ review_result: { lens_results: [] } }) },
+		{ operation: "finalize", lineageId, input: JSON.stringify({}) },
 		undefined,
 		undefined,
 		context(cwd),
@@ -2253,7 +3071,7 @@ test("native pre-commit rejects an unproven staged projection before native auth
 	}), undefined, undefined, undefined, candidateViews);
 	const started = await controller.execute("start", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
 	const lineageId = (started.details as { result: { lineage_id: string } }).result.lineage_id;
-	await controller.execute("finalize", { operation: "finalize", lineageId, input: JSON.stringify({ review_result: { lens_results: [{ findings: [], evidence: ["candidate reviewed"] }] } }) }, undefined, undefined, context(cwd));
+	await controller.execute("finalize", { operation: "finalize", lineageId, input: JSON.stringify({}) }, undefined, undefined, context(cwd));
 	writeFileSync(join(cwd, "app.ts"), "export const value = 3;\n");
 	git(cwd, "add", "--", "app.ts", "initially-untracked.ts");
 	const result = await controller.execute("validate", { operation: "validate", lineageId, idempotencyKey: "projection-drift", command: "git commit -m native", input: "{}" }, undefined, undefined, context(cwd));
@@ -2276,7 +3094,7 @@ test("native pre-commit binds the exact tracked and initially-untracked projecti
 	const { controller, toolCall } = runtime(native, undefined, undefined, undefined, candidateViews);
 	const started = await controller.execute("start", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
 	const lineageId = (started.details as { result: { lineage_id: string } }).result.lineage_id;
-	await controller.execute("finalize", { operation: "finalize", lineageId, input: JSON.stringify({ review_result: { lens_results: [{ findings: [], evidence: ["candidate reviewed"] }] } }) }, undefined, undefined, context(cwd));
+	await controller.execute("finalize", { operation: "finalize", lineageId, input: JSON.stringify({}) }, undefined, undefined, context(cwd));
 	git(cwd, "add", "--", "app.ts", "initially-untracked.ts");
 	const command = "git commit -m exact-projection";
 	const allowed = await controller.execute("validate", { operation: "validate", lineageId, idempotencyKey: "exact-projection", command, input: "{}" }, undefined, undefined, context(cwd));
@@ -3687,7 +4505,7 @@ test("controller preserves every historical response-schema empty-context pre-PR
 	}
 });
 
-test("parallel 4R dispatch receives one compact changed scope and blocks oversized scope before any actor", async (t) => {
+test("parallel 4R dispatch receives readable and compact changed scopes before any actor", async (t) => {
 	const cwd = repository(t);
 	for (let index = 0; index < 248; index += 1) {
 		writeFileSync(join(cwd, `unchanged-${String(index).padStart(3, "0")}.txt`), "base\n");
@@ -3724,9 +4542,24 @@ test("parallel 4R dispatch receives one compact changed scope and blocks oversiz
 		start: async () => ({ lineageId: "c4-oversized", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 80, changedLines: 80, correctionBudget: 40, action: "created", lensesRequired: true }),
 	}), undefined, undefined, undefined, oversizedViews);
 	await oversized.controller.execute("c4-oversized-start", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, context(cwd));
-	const rejected = await oversized.toolCall({ toolName: "subagent_run", input: { agent: "review-reliability", task: "Review oversized scope", mode: "task" } }, context(cwd)) as { block?: boolean };
-	assert.equal(rejected.block, true, "oversized scope blocks before an actor can launch");
-	oversizedViews.resolveForLens("c4-oversized", "review-reliability").cleanup();
+	const oversizedDispatch = { agent: "review-reliability", task: "Review oversized scope", mode: "task" };
+	assert.equal(await oversized.toolCall({ toolName: "subagent_run", input: oversizedDispatch }, context(cwd)), undefined, "a compressible oversized scope reaches the actor through its compact manifest");
+	assert.match(oversizedDispatch.task, /Frozen changed scope manifest \(gzip\+base64url\):/);
+	assert.match(oversizedDispatch.task, /Call `gentle_review_scope`/);
+	assert.ok(Buffer.byteLength(oversizedDispatch.task, "utf8") <= 4_096 + "Review oversized scope".length);
+	const compact = compactCandidateContextManifest(oversizedDispatch.task);
+	const actorEntries: Array<{ path: string; mode: string; gitlinkObjectId?: string }> = [];
+	let cursor: number | undefined = 0;
+	while (cursor !== undefined) {
+		const result = await oversized.scopeReader.execute("actor-scope", { manifest: compact.encoded, sha256: compact.sha256, cursor }, undefined, undefined, context(cwd));
+		const page = result.details as { entries: typeof actorEntries; nextCursor?: number; totalPaths: number };
+		actorEntries.push(...page.entries);
+		cursor = page.nextCursor;
+	}
+	const actorCandidate = oversizedViews.resolveForLens("c4-oversized", "review-reliability");
+	assert.deepEqual(actorEntries.map((entry) => entry.path).sort(), [...actorCandidate.paths].sort(), "the actual actor tool recovers every compressed changed path");
+	assert.equal(actorEntries.some((entry) => entry.path.startsWith("unchanged-")), false, "the actor tool never falls back to the ambient or full candidate tree");
+	actorCandidate.cleanup();
 });
 
 test("INSPECT relays negotiated target status without inventory reconstruction or mutation", async (t) => {
@@ -3754,26 +4587,6 @@ test("INSPECT relays negotiated target status without inventory reconstruction o
 	assert.equal(mutations, 0);
 });
 
-test("native remediation classification accepts only invalid legacy, compact, collision, or reset evidence", () => {
-	const status = (authorityStatus: NativeReviewStatusResult["status"], entries: NativeReviewStatusResult["entries"]): NativeReviewStatusResult => ({
-		repository: "/repo",
-		complete: authorityStatus !== "invalid",
-		authoritative: authorityStatus !== "invalid",
-		status: authorityStatus,
-		entries,
-		locks: [],
-		diagnostics: [],
-		raw: {},
-	});
-	assert.equal(classifyNativeReviewRemediation(status("invalid", [{ version: "legacy-v1", lineageId: "current", path: "/repo/legacy", status: "invalid", problems: [] }]), ["current"]).kind, NATIVE_REVIEW_REMEDIATION.LEGACY);
-	assert.equal(classifyNativeReviewRemediation(status("invalid", [{ version: "compact-v2", lineageId: "current", path: "/repo/compact", status: "invalid", problems: [] }]), ["current"]).kind, NATIVE_REVIEW_REMEDIATION.INVALID_OR_MIXED);
-	assert.equal(classifyNativeReviewRemediation({ ...status("same-lineage-mixed-collision", []), complete: false, authoritative: false }, ["current"]).kind, NATIVE_REVIEW_REMEDIATION.NONE);
-	assert.equal(classifyNativeReviewRemediation(status("reset-in-progress", [])).kind, NATIVE_REVIEW_REMEDIATION.NONE);
-	assert.equal(classifyNativeReviewRemediation(status("invalid", [])).kind, NATIVE_REVIEW_REMEDIATION.NONE);
-	assert.equal(classifyNativeReviewRemediation({ ...status("invalid", [{ version: "legacy-v1", path: "/repo/legacy", status: "invalid", problems: [] }]), complete: true }).kind, NATIVE_REVIEW_REMEDIATION.NONE);
-	assert.equal(classifyNativeReviewRemediation(status("approved", [{ version: "legacy-v1", path: "/repo/legacy", status: "approved", problems: [] }])).kind, NATIVE_REVIEW_REMEDIATION.NONE);
-});
-
 test("native INSPECT never reconstructs reset material from raw Pi corruption", async (t) => {
 	const nativeStatus = (cwd: string, entries: NativeReviewStatusResult["entries"]): NativeReviewStatusResult => ({
 		repository: cwd,
@@ -4276,3 +5089,635 @@ test("successful /gentle:review-mode disable clears pending authorizations even
 	assert.equal(result.block, true);
 	assert.match(result.reason, /receipt consumption failed closed/, "re-enabled delivery must perform fresh receipt discovery rather than reuse the pre-disable authorization");
 });
+
+function gitStdin(cwd: string, arguments_: readonly string[], input: string): string {
+	return execFileSync("git", [...arguments_], { cwd, encoding: "utf8", input }).trim();
+}
+
+test("large repository end-to-end: tiny candidate diff reaches START, reviewer dispatch, FINALIZE, and the validation delivery gate", async (t) => {
+	// Build a genuinely large synthetic repository (5000 unchanged entries) from a single
+	// blob via `git mktree`, avoiding thousands of per-file filesystem writes/subprocesses.
+	// The candidate diff is exactly one modified entry — the smallest review scope — so the
+	// frozen candidate view materializes the full 5000-entry tree through the production
+	// checkout-index path while the reviewer dispatch carries only the one changed path.
+	const cwd = mkdtempSync(join(tmpdir(), "gentle-pi-large-repo-e2e-"));
+	t.after(() => rmSync(cwd, { recursive: true, force: true }));
+	git(cwd, "init", "-b", "main");
+	const baseBlob = gitStdin(cwd, ["hash-object", "-w", "--stdin"], "base\n");
+	const largeCount = 5_000;
+	const baseTreeInput = Array.from({ length: largeCount }, (_, index) =>
+		`100644 blob ${baseBlob}\tunchanged-${String(index).padStart(4, "0")}.txt`,
+	).join("\n");
+	const baseTree = gitStdin(cwd, ["mktree"], baseTreeInput);
+	const candidateBlob = gitStdin(cwd, ["hash-object", "-w", "--stdin"], "candidate\n");
+	const candidateTreeInput = Array.from({ length: largeCount }, (_, index) =>
+		index === 0
+			? `100644 blob ${candidateBlob}\tunchanged-0000.txt`
+			: `100644 blob ${baseBlob}\tunchanged-${String(index).padStart(4, "0")}.txt`,
+	).join("\n");
+	const candidateTree = gitStdin(cwd, ["mktree"], candidateTreeInput);
+	const commitIdentity = ["-c", "user.name=Large Repo E2E", "-c", "user.email=large@example.invalid"];
+	const baseCommit = git(cwd, ...commitIdentity, "commit-tree", baseTree, "-m", "large base");
+	const candidateCommit = git(cwd, ...commitIdentity, "commit-tree", candidateTree, "-p", baseCommit, "-m", "tiny candidate");
+	git(cwd, "update-ref", "refs/heads/main", candidateCommit);
+
+	const candidateViews = new CandidateViewRegistry();
+	const lenses = ["review-risk", "review-resilience", "review-readability", "review-reliability"] as const;
+	const lineageId = "large-repo-e2e";
+	let starts = 0;
+	let finalizes = 0;
+	let validates = 0;
+	let finalizeRoot: string | undefined;
+	const { controller, toolCall } = runtime(fakeNative({
+		start: async () => {
+			starts += 1;
+			return { lineageId, state: "reviewing", riskLevel: "high", selectedLenses: lenses, changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: true };
+		},
+		finalize: async (request) => {
+			finalizes += 1;
+			finalizeRoot = request.cwd;
+			return { lineageId, state: "approved", action: "approved", storeRevision: "r1" };
+		},
+		validate: async () => {
+			validates += 1;
+			return { allowed: true, result: "allow", action: "continue", reason: "native receipt matches the frozen large-repo candidate", gateContext: nativeGateContext(lineageId, "r1", candidateTree) };
+		},
+		targetStatus: async (request) => {
+			if (request.lineageId === undefined) return candidateStartTargetStatus(request);
+			const statusCandidate = new CandidateViewRegistry().create({ contributorRoot: request.cwd, baseRef: baseCommit });
+			try {
+				return targetStatusFixture({ lineageId, baseTree: statusCandidate.baseTree, currentCandidateTree: statusCandidate.candidateTree, paths: statusCandidate.paths });
+			} finally {
+				statusCandidate.cleanup();
+			}
+		},
+	}), undefined, undefined, undefined, candidateViews);
+
+	// START binds the frozen candidate view for the large repository.
+	const start = await controller.execute("large-repo-start", { operation: "start", input: JSON.stringify({ mode: "ordinary", baseRef: baseCommit, committedOnly: true }) }, undefined, undefined, context(cwd));
+	assert.equal(starts, 1);
+	assert.equal((start.details as { result: { lineage_id: string } }).result.lineage_id, lineageId);
+	const frozen = candidateViews.resolveForLens(lineageId, "review-risk");
+	try {
+		// Immutable candidate identity: the frozen view binds the exact synthetic trees.
+		assert.equal(frozen.baseTree, baseTree);
+		assert.equal(frozen.candidateTree, candidateTree);
+		assert.deepEqual(frozen.paths, ["unchanged-0000.txt"]);
+		assert.equal(readdirSync(frozen.root).filter((entry) => entry !== ".git").length, largeCount);
+		assert.equal(readFileSync(join(frozen.root, "unchanged-0000.txt"), "utf8"), "candidate\n");
+		assert.equal(readFileSync(join(frozen.root, "unchanged-4999.txt"), "utf8"), "base\n");
+
+		// Reviewer dispatch injects the controller-owned candidate view carrying only the
+		// tiny changed scope — never the 5000-entry unchanged repository bulk.
+		const dispatch = { agents: [...lenses], task: "Review the tiny candidate diff in a large repository", mode: "task" };
+		assert.equal(await toolCall({ toolName: "subagent_run", input: dispatch }, context(cwd)), undefined);
+		assert.match(dispatch.task, /## Controller-owned candidate view/);
+		assert.match(dispatch.task, new RegExp(`Frozen candidate tree: \`${candidateTree}\``));
+		assert.match(dispatch.task, /unchanged-0000\.txt/);
+		assert.doesNotMatch(dispatch.task, /unchanged-0001\.txt/);
+		assert.doesNotMatch(dispatch.task, /unchanged-0499\.txt/);
+		assert.ok(Buffer.byteLength(dispatch.task, "utf8") <= 4_096 + "Review the tiny candidate diff in a large repository".length);
+
+		// No live-worktree fallback: a rogue untracked file in the contributor working
+		// directory (invisible to the committedOnly candidate view) cannot reach the dispatch.
+		writeFileSync(join(cwd, "rogue-untracked.ts"), "export const rogue = true;\n");
+		const rogueDispatch = { agent: "review-risk", task: "review after rogue", mode: "task" };
+		assert.equal(await toolCall({ toolName: "subagent_run", input: rogueDispatch }, context(cwd)), undefined);
+		assert.doesNotMatch(rogueDispatch.task, /rogue-untracked\.ts/);
+		assert.match(rogueDispatch.task, new RegExp(`Frozen candidate tree: \`${candidateTree}\``));
+
+		// FINALIZE mutates against the frozen candidate root, not the contributor working directory.
+		const finalize = await controller.execute("large-repo-finalize", { operation: "finalize", lineageId, input: JSON.stringify({}) }, undefined, undefined, context(cwd));
+		assert.equal((finalize.details as { result: { state: string } }).result.state, "approved");
+		assert.equal(finalizes, 1);
+		assert.notEqual(finalizeRoot, cwd);
+		assert.equal(finalizeRoot, frozen.root);
+
+		// Validation delivery gate: stage the frozen candidate tree and authorize delivery.
+		git(cwd, "read-tree", candidateTree);
+		const command = "git commit -m large-repo-delivery";
+		const validated = await controller.execute("large-repo-validate", { operation: "validate", lineageId, idempotencyKey: "large-repo-delivery", command, input: "{}" }, undefined, undefined, context(cwd));
+		assert.ok(validates >= 1);
+		assert.notEqual((validated.details as { authorization?: unknown }).authorization, undefined);
+		assert.equal((validated.details as { result?: { allowed?: boolean } }).result?.allowed, true);
+		// The delivery gate allows the authorized command exactly once; replay is blocked.
+		assert.equal(await toolCall({ toolName: "bash", input: { command } }, interactiveContext(cwd)), undefined);
+		const replay = await toolCall({ toolName: "bash", input: { command } }, context(cwd)) as { block: boolean };
+		assert.equal(replay.block, true);
+	} finally {
+		frozen.cleanup();
+	}
+});
+
+// Field defect (fambig, 2026-08-16, dev binary 2.4.0-main): at every
+// evidence-pending sub-state the provider renders the `review.capture-evidence`
+// collect slot with the identity native demands — for a correction that is the
+// FIX-DIFF `--target` identity plus an opaque `--repository-context`, never the
+// top-level live workspace snapshot identity. Rebinding the capture to
+// `negotiatedStatus.targetIdentity` failed deterministically with
+// "verification evidence binding does not match the current authority
+// revision". Collect satisfaction must execute the slot's rendered submission
+// tokens verbatim, exactly like captureResult does.
+const EVIDENCE_SLOT_FIX_TARGET = `sha256:${"e".repeat(64)}`;
+const EVIDENCE_SLOT_REPOSITORY_CONTEXT = `rctx1_${"f".repeat(64)}`;
+
+function bindEvidenceSubmissionCollection(status: ReviewStatusV3, fixTargetIdentity = EVIDENCE_SLOT_FIX_TARGET, repositoryContext = EVIDENCE_SLOT_REPOSITORY_CONTEXT): ReviewStatusV3 {
+	const lineageId = status.authority!.lineageId;
+	const revision = status.authority!.revision;
+	const argumentTokens = [
+		`--lineage=${lineageId}`,
+		`--expected-revision=${revision}`,
+		`--target=${fixTargetIdentity}`,
+		`--repository-context=${repositoryContext}`,
+		"--outcome={{outcome}}",
+		"--input={{input}}",
+	];
+	status.nextTransition = {
+		kind: "collect",
+		reasonCode: "correction_repository_verification_required",
+		collect: { inputs: [{
+			name: "evidence",
+			schema: "https://gentle-ai.dev/schema/review/verification-evidence/v1",
+			captureOperation: "review.capture-evidence",
+			arguments: [
+				{ name: "lineage", value: lineageId, token: `--lineage=${lineageId}` },
+				{ name: "expected-revision", value: revision, token: `--expected-revision=${revision}` },
+				{ name: "target", value: fixTargetIdentity, token: `--target=${fixTargetIdentity}` },
+				{ name: "repository-context", value: repositoryContext, token: `--repository-context=${repositoryContext}` },
+			],
+			submissionDescriptor: {
+				operationToken: "capture-evidence",
+				argumentTokens,
+				values: [
+					{ slot: "outcome", domain: "verification_outcome", allowedValues: ["passed", "verification_failed", "procedural_tooling_failed"], substitutionLocation: 4 },
+					{ slot: "input", domain: "artifact_path_or_stdin", schema: "https://gentle-ai.dev/schema/review/verification-evidence/v1", substitutionLocation: 5 },
+				],
+			},
+		}] },
+	};
+	delete status.validationRequest;
+	return status;
+}
+
+// The record the live binary returns for a slot-bound capture: it binds the
+// slot's fix-diff target identity, and its paths digest covers the record's
+// own (fix-diff) paths — NOT the frozen projection digest (captured 2026-08-16,
+// lineage review-2b6206ed68fb9128: record paths ["calc.go"] against projection
+// paths ["calc.go", "util.go"]).
+function capturedSlotEvidence(status: ReviewStatusV3, outcome: "passed" | "verification_failed" | "procedural_tooling_failed", identityDigit: string) {
+	return {
+		...capturedCorrectionEvidence(status, outcome, identityDigit),
+		targetIdentity: EVIDENCE_SLOT_FIX_TARGET,
+		pathsDigest: `sha256:${identityDigit.repeat(64)}`,
+	};
+}
+
+test("correction evidence capture executes the collect slot's rendered submission tokens verbatim", async (t) => {
+	for (const [outcome, expectedKind] of [
+		["passed", "run-targeted-validation"],
+		["verification_failed", "recapture-required"],
+	] as const) {
+		await t.test(outcome, async (scenario) => {
+			const cwd = repository(scenario);
+			writeFileSync(join(cwd, "app.ts"), `export const outcome = ${JSON.stringify(outcome)};\n`);
+			const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
+			const beforeCapture = bindEvidenceSubmissionCollection(targetStatusFixture({
+				lineageId: `slot-correction-${outcome.replaceAll("_", "-")}`,
+				authorityState: "correction_required",
+				baseTree: frozen.baseTree,
+				currentCandidateTree: frozen.candidateTree,
+				paths: frozen.paths,
+			}));
+			const expectedTokens = beforeCapture.nextTransition!.collect!.inputs[0]!.submissionDescriptor!.argumentTokens;
+			const afterCapture = targetStatusFixture({
+				lineageId: beforeCapture.authority!.lineageId,
+				authorityState: outcome === "passed" ? "validating" : "correction_required",
+				baseTree: frozen.baseTree,
+				currentCandidateTree: frozen.candidateTree,
+				paths: frozen.paths,
+			});
+			if (outcome === "passed") bindTargetedValidation(afterCapture);
+			else bindEvidenceSubmissionCollection(afterCapture);
+			frozen.cleanup();
+			const misboundCaptures: Array<Record<string, unknown>> = [];
+			const submissions: Array<Record<string, unknown>> = [];
+			let statuses = 0;
+			let finalizes = 0;
+			const { controller } = runtime(fakeNative({
+				targetStatus: async () => {
+					statuses += 1;
+					return statuses === 1 ? beforeCapture : afterCapture;
+				},
+				captureEvidence: async (request) => {
+					misboundCaptures.push(request as unknown as Record<string, unknown>);
+					throw new Error("misbound capture: the collect slot's rendered submission tokens were bypassed");
+				},
+				captureEvidenceSubmission: async (request: Record<string, unknown>) => {
+					submissions.push(request);
+					return capturedSlotEvidence(beforeCapture, outcome, outcome === "passed" ? "1" : "2");
+				},
+				finalize: async () => {
+					finalizes += 1;
+					return { lineageId: beforeCapture.authority!.lineageId, state: "approved", action: "approved", storeRevision: "r-final" };
+				},
+			} as unknown as Partial<NativeReviewCli>), undefined, undefined, undefined, new CandidateViewRegistry());
+			const validation = outcome === "passed" ? {
+				request_hash: "9".repeat(64), correction_ids: [],
+				original_criteria: { passed: true, evidence: ["acceptance passes"] },
+				correction_regression: { passed: true, evidence: ["regression passes"] },
+				fix_caused_findings: [], follow_ups: [],
+			} : undefined;
+			const result = await controller.execute(`slot-correction-${outcome}`, {
+				operation: "finalize",
+				lineageId: beforeCapture.authority!.lineageId,
+				input: JSON.stringify({ final_evidence: `evidence: ${outcome}`, final_verification_outcome: outcome, ...(validation === undefined ? {} : { validation }) }),
+			}, undefined, undefined, context(cwd));
+			const details = result.details as Record<string, unknown>;
+			assert.deepEqual(misboundCaptures, [], "capture-evidence must never rebind to the top-level live workspace identity");
+			assert.equal(submissions.length, 1, "the slot submission must be executed exactly once");
+			const submission = submissions[0]!;
+			assert.deepEqual(submission.argumentTokens, expectedTokens, "the provider-rendered submission tokens must be passed verbatim, in provider order");
+			assert.equal(submission.outcomeSubstitutionLocation, 4);
+			assert.equal(submission.inputSubstitutionLocation, 5);
+			assert.equal(submission.cwd, undefined, "the slot's --repository-context is authoritative; never pass --cwd alongside it");
+			assert.equal(submission.outcome, outcome);
+			assert.equal(submission.evidenceDocument, `evidence: ${outcome}`);
+			assert.equal((details.correction_step as { kind?: string } | undefined)?.kind, expectedKind);
+			assert.equal(finalizes, outcome === "passed" ? 1 : 0);
+		});
+	}
+});
+
+test("ordinary final verification at validating captures evidence through the slot's rendered submission tokens", async (t) => {
+	const cwd = repository(t);
+	writeFileSync(join(cwd, "app.ts"), "export const finalSlot = true;\n");
+	const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
+	const beforeCapture = bindEvidenceSubmissionCollection(targetStatusFixture({
+		lineageId: "final-verification-slot",
+		authorityState: "validating",
+		baseTree: frozen.baseTree,
+		currentCandidateTree: frozen.candidateTree,
+		paths: frozen.paths,
+	}));
+	const expectedTokens = beforeCapture.nextTransition!.collect!.inputs[0]!.submissionDescriptor!.argumentTokens;
+	const afterCapture = bindFinalVerificationTransition(targetStatusFixture({
+		lineageId: "final-verification-slot",
+		authorityState: "validating",
+		baseTree: frozen.baseTree,
+		currentCandidateTree: frozen.candidateTree,
+		paths: frozen.paths,
+	}), "passed");
+	frozen.cleanup();
+	const misboundCaptures: Array<Record<string, unknown>> = [];
+	const submissions: Array<Record<string, unknown>> = [];
+	const transitions: Array<readonly string[]> = [];
+	let statuses = 0;
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			statuses += 1;
+			return statuses === 1 ? beforeCapture : afterCapture;
+		},
+		captureEvidence: async (request) => {
+			misboundCaptures.push(request as unknown as Record<string, unknown>);
+			throw new Error("misbound capture: the collect slot's rendered submission tokens were bypassed");
+		},
+		captureEvidenceSubmission: async (request: Record<string, unknown>) => {
+			submissions.push(request);
+			return capturedSlotEvidence(beforeCapture, "passed", "3");
+		},
+		finalizeTransition: async (request) => {
+			transitions.push(request.argumentTokens);
+			return { lineageId: "final-verification-slot", state: "approved", action: "terminal", storeRevision: "r2", receiptPath: "/opaque/receipt" };
+		},
+	} as unknown as Partial<NativeReviewCli>), undefined, undefined, undefined, new CandidateViewRegistry());
+	const result = await controller.execute("final-verification-slot", {
+		operation: "finalize",
+		lineageId: "final-verification-slot",
+		input: JSON.stringify({ final_evidence: "verification run: passed", final_verification_outcome: "passed" }),
+	}, undefined, undefined, context(cwd));
+	const details = result.details as Record<string, unknown>;
+	assert.deepEqual(misboundCaptures, [], "capture-evidence must never rebind to the top-level live workspace identity");
+	assert.equal(submissions.length, 1);
+	assert.deepEqual(submissions[0]!.argumentTokens, expectedTokens);
+	assert.equal(submissions[0]!.cwd, undefined, "the slot's --repository-context is authoritative; never pass --cwd alongside it");
+	assert.deepEqual(transitions, [["--lineage=final-verification-slot", "--captured-evidence=true"]]);
+	assert.equal((details.result as { state?: string } | undefined)?.state, "approved");
+});
+
+// Field defect amplifier (fambig, 2026-08-16): an envelope-less mutating
+// failure is stamped mutationOutcome "unknown", and the reconciler KEPT
+// "unknown" even after fresh STATUS proved the authority revision identical to
+// the pre-operation revision — reporting a replay prohibition for an operation
+// that provably never mutated. A proven non-mutation must be reported as
+// mutation_outcome none with the proof named; a genuinely ambiguous result
+// (revision moved, or STATUS unavailable) stays fail-closed unknown.
+test("finalize reconciliation downgrades an envelope-less unknown to proven non-mutation when the authority revision is unchanged", async (t) => {
+	const cwd = repository(t);
+	let statuses = 0;
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			statuses += 1;
+			return targetStatusFixture({ lineageId: "unchanged-revision" });
+		},
+		finalize: async () => {
+			throw Object.assign(new Error("stderr-only native failure without a typed envelope"), { mutationOutcome: "unknown", nextAction: "review.status" });
+		},
+	}));
+	const details = (await controller.execute("proven-none", { operation: "finalize", lineageId: "unchanged-revision", input: "{}" }, undefined, undefined, context(cwd))).details as Record<string, unknown>;
+	assert.equal(details.outcome, "native-mutation-status-reconciled");
+	assert.equal(details.mutation_performed, false, "a reconciled unchanged revision proves the operation did not mutate");
+	assert.equal(details.mutation_outcome, "none");
+	assert.match(String(details.mutation_outcome_reason), /revision unchanged/i, "the downgrade must name its proof");
+	assert.equal("replayability" in details, false, "a proven non-mutation must not claim replay prohibition");
+	assert.equal(details.next_action, "finalize");
+	assert.equal(statuses, 2);
+});
+
+test("finalize reconciliation preserves fail-closed unknown when the reconciled authority revision moved", async (t) => {
+	const cwd = repository(t);
+	const moved = targetStatusFixture({ lineageId: "moved-revision" });
+	moved.authority!.revision = `sha256:${"b".repeat(64)}`;
+	let statuses = 0;
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			statuses += 1;
+			return statuses === 1 ? targetStatusFixture({ lineageId: "moved-revision" }) : moved;
+		},
+		finalize: async () => {
+			throw Object.assign(new Error("stderr-only native failure without a typed envelope"), { mutationOutcome: "unknown", nextAction: "review.status" });
+		},
+	}));
+	const details = (await controller.execute("kept-unknown", { operation: "finalize", lineageId: "moved-revision", input: "{}" }, undefined, undefined, context(cwd))).details as Record<string, unknown>;
+	assert.equal(details.outcome, "native-mutation-status-reconciled");
+	assert.equal(details.mutation_outcome, "unknown", "a moved revision is genuinely ambiguous and must stay fail-closed");
+	assert.equal(details.replayability, "not_replayable");
+});
+
+// Same misbinding class, remaining finalize-form slots (live smoke,
+// 2026-08-16, dev binary 2.4.0-main): the correction PLAN and TARGETED
+// VALIDATION collect slots render `finalize` submission descriptors whose
+// tokens carry --contract/--lineage/--expected-revision/--target/
+// --request-hash/--repository-context plus one {{value}} slot. The legacy
+// reconstructed `finalize --correction-lines/--validation` argv fails on the
+// live emitter with "reconcile compact predecessor effects: repository
+// context effect binding or payload does not match committed intent". Collect
+// satisfaction must execute the rendered tokens verbatim.
+function bindPlanSubmissionCollection(status: ReviewStatusV3, repositoryContext = EVIDENCE_SLOT_REPOSITORY_CONTEXT): ReviewStatusV3 {
+	const lineageId = status.authority!.lineageId;
+	const revision = status.authority!.revision;
+	status.nextTransition = {
+		kind: "collect",
+		reasonCode: "correction_plan_required",
+		collect: { inputs: [{
+			name: "correction_lines",
+			schema: "gentle-ai.review-correction-plan/v1",
+			captureOperation: "external.plan_correction",
+			arguments: [
+				{ name: "lineage", value: lineageId, token: `--lineage=${lineageId}` },
+				{ name: "expected-revision", value: revision, token: `--expected-revision=${revision}` },
+				{ name: "target", value: status.targetIdentity, token: `--target=${status.targetIdentity}` },
+			],
+			submissionDescriptor: {
+				operationToken: "finalize",
+				argumentTokens: [
+					"--contract=gentle-ai.review-integration/v2",
+					`--lineage=${lineageId}`,
+					`--expected-revision=${revision}`,
+					`--target=${status.targetIdentity}`,
+					`--request-hash=sha256:${"c".repeat(64)}`,
+					`--repository-context=${repositoryContext}`,
+					"--correction-lines={{value}}",
+				],
+				value: { slot: "correction_lines", domain: "positive_correction_lines", minimum: 1, maximum: 9, substitutionLocation: 6 },
+			},
+		}] },
+	};
+	delete status.validationRequest;
+	return status;
+}
+
+test("correction plan forecast executes the collect slot's rendered finalize submission tokens verbatim", async (t) => {
+	const cwd = repository(t);
+	writeFileSync(join(cwd, "app.ts"), "export const plan = true;\n");
+	const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
+	const status = bindPlanSubmissionCollection(targetStatusFixture({
+		lineageId: "plan-submission",
+		authorityState: "correction_required",
+		baseTree: frozen.baseTree,
+		currentCandidateTree: frozen.candidateTree,
+		paths: frozen.paths,
+	}));
+	const expectedTokens = status.nextTransition!.collect!.inputs[0]!.submissionDescriptor!.argumentTokens;
+	frozen.cleanup();
+	const legacyFinalizes: Array<Record<string, unknown>> = [];
+	const submissions: Array<Record<string, unknown>> = [];
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => status,
+		finalize: async (request) => {
+			legacyFinalizes.push(request as unknown as Record<string, unknown>);
+			throw new Error("misbound plan: the collect slot's rendered finalize submission tokens were bypassed");
+		},
+		finalizeSubmission: async (request: Record<string, unknown>) => {
+			submissions.push(request);
+			return { lineageId: "plan-submission", state: "correction_required", action: "continue the current review state", storeRevision: "r-plan" };
+		},
+	} as unknown as Partial<NativeReviewCli>), undefined, undefined, undefined, new CandidateViewRegistry());
+	const planned = await controller.execute("plan-submission", {
+		operation: "finalize",
+		lineageId: "plan-submission",
+		input: JSON.stringify({ correction_line_forecast: 2 }),
+	}, undefined, undefined, context(cwd));
+	const details = planned.details as Record<string, unknown>;
+	assert.deepEqual(legacyFinalizes, [], "the legacy reconstructed --correction-lines argv must never run when the slot renders submission tokens");
+	assert.equal(submissions.length, 1);
+	assert.deepEqual(submissions[0]!.argumentTokens, expectedTokens, "the provider-rendered submission tokens must be passed verbatim, in provider order");
+	assert.equal(submissions[0]!.valueSubstitutionLocation, 6);
+	assert.equal(submissions[0]!.valueLiteral, "2");
+	assert.equal((details.result as { state?: string } | undefined)?.state, "correction_required");
+
+	// An out-of-bounds forecast fails closed before any native launch.
+	const outOfBounds = await controller.execute("plan-submission-oob", {
+		operation: "finalize",
+		lineageId: "plan-submission",
+		input: JSON.stringify({ correction_line_forecast: 99 }),
+	}, undefined, undefined, context(cwd));
+	assert.equal((outOfBounds.details as { outcome?: string }).outcome, "native-operation-failed");
+	assert.match(JSON.stringify(outOfBounds.details), /correction-forecast-out-of-bounds/);
+	assert.equal(submissions.length, 1);
+	assert.deepEqual(legacyFinalizes, []);
+	execFileSync("chmod", ["-R", "u+w", cwd]);
+});
+
+function bindTargetedValidationSubmission(status: ReviewStatusV3): ReviewStatusV3 {
+	bindTargetedValidation(status);
+	const input = status.nextTransition!.collect!.inputs[0]! as { submissionDescriptor?: unknown };
+	const lineageId = status.authority!.lineageId;
+	const revision = status.authority!.revision;
+	input.submissionDescriptor = {
+		operationToken: "finalize",
+		argumentTokens: [
+			"--contract=gentle-ai.review-integration/v2",
+			`--lineage=${lineageId}`,
+			`--expected-revision=${revision}`,
+			`--target=${status.targetIdentity}`,
+			`--request-hash=${status.validationRequest!.requestHash}`,
+			`--repository-context=${EVIDENCE_SLOT_REPOSITORY_CONTEXT}`,
+			"--validation={{value}}",
+		],
+		value: { slot: "validation", domain: "artifact_path_or_stdin", substitutionLocation: 6 },
+	};
+	return status;
+}
+
+test("targeted validation executes the collect slot's rendered finalize submission tokens verbatim", async (t) => {
+	const cwd = repository(t);
+	writeFileSync(join(cwd, "app.ts"), "export const validated = true;\n");
+	const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
+	const beforeCapture = bindEvidenceSubmissionCollection(targetStatusFixture({
+		lineageId: "validation-submission",
+		authorityState: "correction_required",
+		baseTree: frozen.baseTree,
+		currentCandidateTree: frozen.candidateTree,
+		paths: frozen.paths,
+	}));
+	const afterCapture = bindTargetedValidationSubmission(targetStatusFixture({
+		lineageId: "validation-submission",
+		authorityState: "validating",
+		baseTree: frozen.baseTree,
+		currentCandidateTree: frozen.candidateTree,
+		paths: frozen.paths,
+	}));
+	const expectedTokens = (afterCapture.nextTransition!.collect!.inputs[0]! as { submissionDescriptor: { argumentTokens: readonly string[] } }).submissionDescriptor.argumentTokens;
+	frozen.cleanup();
+	const legacyFinalizes: Array<Record<string, unknown>> = [];
+	const submissions: Array<Record<string, unknown>> = [];
+	let statuses = 0;
+	const { controller } = runtime(fakeNative({
+		targetStatus: async () => {
+			statuses += 1;
+			return statuses === 1 ? beforeCapture : afterCapture;
+		},
+		captureEvidenceSubmission: async () => capturedSlotEvidence(beforeCapture, "passed", "7"),
+		finalize: async (request) => {
+			legacyFinalizes.push(request as unknown as Record<string, unknown>);
+			throw new Error("misbound validation: the collect slot's rendered finalize submission tokens were bypassed");
+		},
+		finalizeSubmission: async (request: Record<string, unknown>) => {
+			submissions.push(request);
+			return { lineageId: "validation-submission", state: "approved", action: "approved", storeRevision: "r-approved" };
+		},
+	} as unknown as Partial<NativeReviewCli>), undefined, undefined, undefined, new CandidateViewRegistry());
+	const completed = await controller.execute("validation-submission", {
+		operation: "finalize",
+		lineageId: "validation-submission",
+		input: JSON.stringify({
+			final_evidence: "evidence: passed",
+			final_verification_outcome: "passed",
+			validation: {
+				request_hash: "9".repeat(64), correction_ids: [],
+				original_criteria: { passed: true, evidence: ["acceptance passes"] },
+				correction_regression: { passed: true, evidence: ["regression passes"] },
+				fix_caused_findings: [], follow_ups: [],
+			},
+		}),
+	}, undefined, undefined, context(cwd));
+	const details = completed.details as Record<string, unknown>;
+	assert.deepEqual(legacyFinalizes, [], "the legacy reconstructed --validation argv must never run when the slot renders submission tokens");
+	assert.equal(submissions.length, 1);
+	assert.deepEqual(submissions[0]!.argumentTokens, expectedTokens, "the provider-rendered submission tokens must be passed verbatim, in provider order");
+	assert.equal(submissions[0]!.valueSubstitutionLocation, 6);
+	const staged = JSON.parse(String(submissions[0]!.valueDocument)) as Record<string, unknown>;
+	assert.equal(staged.targeted_validation_request_hash, afterCapture.validationRequest!.requestHash);
+	assert.equal(staged.correction_target_identity, afterCapture.validationRequest!.correctionTargetIdentity);
+	assert.deepEqual(staged.original_criteria, { passed: true, evidence: ["acceptance passes"] });
+	assert.equal((details.result as { state?: string } | undefined)?.state, "approved");
+});
+
+// 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. The finalize lane queries negotiated
+// STATUS from a frozen candidate-view root, so every rendered submission it
+// executed carried a context bound to the wrong root and failed the live
+// emitter's committed-intent reconciliation ("repository context effect
+// binding or payload does not match committed intent"). On v5 the lane must
+// rebind its negotiated STATUS to the workspace root before executing any
+// rendered payload; pinned pre-v5 emitters keep the frozen-view status.
+test("status/v5 finalize lane rebinds negotiated status to the workspace root before executing rendered payloads", async (t) => {
+	const cwd = repository(t);
+	writeFileSync(join(cwd, "app.ts"), "export const rebind = true;\n");
+	const frozen = new CandidateViewRegistry().create({ contributorRoot: cwd });
+	const viewContext = `rctx1_${"a".repeat(64)}`;
+	const workspaceContext = `rctx1_${"b".repeat(64)}`;
+	const makeBefore = (repositoryContext: string) => {
+		const status = bindEvidenceSubmissionCollection(targetStatusFixture({
+			lineageId: "v5-rebind",
+			authorityState: "correction_required",
+			baseTree: frozen.baseTree,
+			currentCandidateTree: frozen.candidateTree,
+			paths: frozen.paths,
+		}), EVIDENCE_SLOT_FIX_TARGET, repositoryContext);
+		(status.raw as Record<string, unknown>).schema = "gentle-ai.review-integration.status/v5";
+		return status;
+	};
+	const viewBefore = makeBefore(viewContext);
+	const workspaceBefore = makeBefore(workspaceContext);
+	const workspaceAfter = bindTargetedValidationSubmission(targetStatusFixture({
+		lineageId: "v5-rebind",
+		authorityState: "validating",
+		baseTree: frozen.baseTree,
+		currentCandidateTree: frozen.candidateTree,
+		paths: frozen.paths,
+	}));
+	(workspaceAfter.raw as Record<string, unknown>).schema = "gentle-ai.review-integration.status/v5";
+	// Live post-evidence shape (2026-08-16): the validation request binds the
+	// FROZEN authority target identity while the top-level target identity is
+	// the live workspace snapshot (which now contains the fix).
+	workspaceAfter.authorityTargetIdentity = workspaceAfter.validationRequest!.targetIdentity;
+	workspaceAfter.targetIdentity = `sha256:${"d".repeat(64)}`;
+	const expectedEvidenceTokens = workspaceBefore.nextTransition!.collect!.inputs[0]!.submissionDescriptor!.argumentTokens;
+	const expectedValidationTokens = (workspaceAfter.nextTransition!.collect!.inputs[0]! as { submissionDescriptor: { argumentTokens: readonly string[] } }).submissionDescriptor.argumentTokens;
+	frozen.cleanup();
+	const statusRoots: string[] = [];
+	const evidenceSubmissions: Array<Record<string, unknown>> = [];
+	const finalizeSubmissions: Array<Record<string, unknown>> = [];
+	let workspaceStatuses = 0;
+	const { controller } = runtime(fakeNative({
+		targetStatus: async (request) => {
+			statusRoots.push(request.cwd);
+			if (request.cwd !== cwd) return viewBefore;
+			workspaceStatuses += 1;
+			return workspaceStatuses === 1 ? workspaceBefore : workspaceAfter;
+		},
+		captureEvidenceSubmission: async (request: Record<string, unknown>) => {
+			evidenceSubmissions.push(request);
+			return capturedSlotEvidence(workspaceBefore, "passed", "8");
+		},
+		finalizeSubmission: async (request: Record<string, unknown>) => {
+			finalizeSubmissions.push(request);
+			return { lineageId: "v5-rebind", state: "approved", action: "approved", storeRevision: "r-approved" };
+		},
+	} as unknown as Partial<NativeReviewCli>), undefined, undefined, undefined, new CandidateViewRegistry());
+	const completed = await controller.execute("v5-rebind", {
+		operation: "finalize",
+		lineageId: "v5-rebind",
+		input: JSON.stringify({
+			final_evidence: "evidence: passed",
+			final_verification_outcome: "passed",
+			validation: {
+				request_hash: "9".repeat(64), correction_ids: [],
+				original_criteria: { passed: true, evidence: ["acceptance passes"] },
+				correction_regression: { passed: true, evidence: ["regression passes"] },
+				fix_caused_findings: [], follow_ups: [],
+			},
+		}),
+	}, undefined, undefined, context(cwd));
+	const details = completed.details as Record<string, unknown>;
+	assert.notEqual(statusRoots[0], cwd, "the first status query still freezes through the candidate view root");
+	assert.equal(statusRoots[1], cwd, "a v5 status must be rebound to the workspace root before any rendered payload executes");
+	assert.equal(evidenceSubmissions.length, 1);
+	assert.deepEqual(evidenceSubmissions[0]!.argumentTokens, expectedEvidenceTokens, "the evidence submission must carry the workspace-root-minted tokens");
+	assert.equal(finalizeSubmissions.length, 1);
+	assert.deepEqual(finalizeSubmissions[0]!.argumentTokens, expectedValidationTokens, "the validation submission must carry the workspace-root-minted tokens");
+	assert.equal(statusRoots.filter((root) => root === cwd).length, 2, "post-evidence status must also be workspace-bound");
+	assert.equal((details.result as { state?: string } | undefined)?.state, "approved");
+});