gentle-pi 2.1.2 → 2.3.0

package/lib/native-review-cli.ts

@@ -1,37 +1,56 @@
 import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { readFileSync, statSync } from "node:fs";
 import { chmod, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, posix, win32 } from "node:path";
 import { promisify } from "node:util";
-import { GENTLE_AI_VERSION, PackageLocalGentleAiBinaryMissingError, resolveGentleAiBinary } from "./gentle-ai-binary.ts";
+import { PackageLocalGentleAiBinaryMissingError, resolveGentleAiBinary } from "./gentle-ai-binary.ts";
+import { GENTLE_PI_REVIEW_RELAY_CONTRACT, GENTLE_PI_REVIEW_RELAY_CONTRACT_ENV } from "./review-relay-contract.ts";
 import {
 	REVIEW_INTEGRATION_CONTRACT,
-	decodeReviewCapabilitiesV2,
+	decodeReviewAcknowledgedV1,
 	decodeReviewConsentV2,
+	decodeReviewConsentV3,
 	decodeReviewFailureV2,
-	decodeReviewOperationV2,
+	decodeReviewLastEventClosureV1,
 	decodeReviewRepairV2,
+	decodeReviewResultArtifactV2,
 	decodeReviewStartV3,
+	decodeReviewStartV4,
 	decodeReviewStatusV3,
-	type ReviewCapabilitiesV2,
-	type ReviewConsentV2,
+	type ReviewAcknowledgedExpectationV1,
+	type ReviewAcknowledgedV1,
+	type ReviewConsentEnvelope,
 	type ReviewFailureV2,
 	type ReviewRepairV2,
+	type ReviewNextTransitionV3,
 	type ReviewStartState,
+	type ReviewStartV3,
+	type ReviewStartV4,
 	type ReviewStatusV3,
+	type ReviewLastEventClosureV1,
 } from "./review-integration-v2.ts";
 
 const execFileAsync = promisify(execFile);
 
+// Negotiated review/status responses can carry a complete authority inventory.
+// Keep the production default large enough for that payload while retaining a
+// hard 64 MiB ceiling even when GENTLE_PI_REVIEW_MAX_BUFFER_BYTES is set.
+export const NATIVE_REVIEW_DEFAULT_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+const NATIVE_REVIEW_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+const NATIVE_REVIEW_MAX_BUFFER_BYTES_ENV = "GENTLE_PI_REVIEW_MAX_BUFFER_BYTES";
+const NATIVE_REVIEW_MAX_BUFFER_CONFIGURATION_HINT = "Inspect native review state before any new START; GENTLE_PI_REVIEW_MAX_BUFFER_BYTES accepts a positive decimal up to 67108864.";
+
+function resolveNativeReviewMaxBufferBytes(environment: NodeJS.ProcessEnv = process.env): number {
+	const value = environment[NATIVE_REVIEW_MAX_BUFFER_BYTES_ENV];
+	if (value === undefined || !/^[1-9]\d*$/.test(value)) return NATIVE_REVIEW_DEFAULT_MAX_BUFFER_BYTES;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) && parsed <= NATIVE_REVIEW_MAX_BUFFER_BYTES
+		? parsed
+		: NATIVE_REVIEW_DEFAULT_MAX_BUFFER_BYTES;
+}
+
 export const NATIVE_REVIEW_OPERATION = {
-	VERSION: "version",
 	START: "review/start",
-	FINALIZE: "review/finalize",
-	VALIDATE: "review/validate",
-	BIND_SDD: "review/bind-sdd",
-	SDD_STATUS: "sdd-status",
 	STATUS: "review/status",
 	RECLAIM: "review/reclaim",
 	RECOVER: "review/recover",
@@ -41,8 +60,10 @@ export const NATIVE_REVIEW_OPERATION = {
 	REPAIR_LEGACY_ALIAS: "review/repair-legacy-alias",
 	MODE: "review/mode",
 	REPAIR: "review/repair",
-	CAPTURE_EVIDENCE: "review/capture-evidence",
 	CAPTURE_RESULT: "review/capture-result",
+	CAPTURE_CORRECTION_PLAN: "review/capture-correction-plan",
+	CAPTURE_PROVIDER_ROLE: "review/capture-provider-role",
+	ACKNOWLEDGE_APPROVED: "review/acknowledge-approved",
 } as const;
 export type NativeReviewOperation = (typeof NATIVE_REVIEW_OPERATION)[keyof typeof NATIVE_REVIEW_OPERATION];
 
@@ -68,43 +89,9 @@ export interface ExecFileRequest { file: string; arguments: readonly string[]; c
 export interface ExecFileResult { stdout: string; stderr: string; exitCode: number; signal: NodeJS.Signals | null; timedOut: boolean; outputLimitExceeded: boolean; }
 export type ExecFileAdapter = (request: ExecFileRequest) => Promise<ExecFileResult>;
 
-export const NATIVE_SDD_ARTIFACT_STORE = {
-	OPENSPEC: "openspec",
-	ENGRAM: "engram",
-	NONE: "none",
-} as const;
-export type NativeSddArtifactStore = (typeof NATIVE_SDD_ARTIFACT_STORE)[keyof typeof NATIVE_SDD_ARTIFACT_STORE];
-
-export const NATIVE_SDD_ARTIFACT_STATE = {
-	MISSING: "missing",
-	DONE: "done",
-	PARTIAL: "partial",
-} as const;
-export type NativeSddArtifactState = (typeof NATIVE_SDD_ARTIFACT_STATE)[keyof typeof NATIVE_SDD_ARTIFACT_STATE];
-
-export interface NativeSddArtifactStates {
-	proposal: NativeSddArtifactState;
-	specs: NativeSddArtifactState;
-	design: NativeSddArtifactState;
-	tasks: NativeSddArtifactState;
-	applyProgress: NativeSddArtifactState;
-	verifyReport: NativeSddArtifactState;
-	reviewPolicy?: NativeSddArtifactState;
-	reviewLedger: NativeSddArtifactState;
-	reviewReceipt: NativeSddArtifactState;
-	reviewBundle: NativeSddArtifactState;
-	reviewContext: NativeSddArtifactState;
-	reviewState: NativeSddArtifactState;
-}
-
 export interface NativeReviewCli {
 	start(request: NativeStartRequest): Promise<NativeStartResult>;
-	finalize(request: NativeFinalizeRequest): Promise<NativeFinalizeResult>;
-	validate(request: NativeValidateRequest): Promise<NativeValidateResult>;
-	bindSdd(request: NativeBindSddRequest): Promise<NativeBindSddResult>;
-	sddStatus(request: NativeSddStatusRequest): Promise<NativeSddStatusResult>;
 	reviewStatus(request: NativeReviewStatusRequest): Promise<NativeReviewStatusResult>;
-	capabilities?(request?: NativeCapabilitiesRequest): Promise<ReviewCapabilitiesV2>;
 	targetStatus?(request: NativeTargetStatusRequest): Promise<ReviewStatusV3>;
 	answerConsent?(request: NativeReviewConsentAnswerRequest): Promise<NativeReviewConsentAnswerResult>;
 	reclaim?(request: NativeReviewReclaimRequest): Promise<NativeReviewRecoveryResult>;
@@ -113,15 +100,14 @@ export interface NativeReviewCli {
 	quarantineLegacy?(request: NativeReviewLegacyQuarantineRequest): Promise<NativeReviewRecoveryResult>;
 	reconcileAuthority?(request: NativeReviewReconcileAuthorityRequest): Promise<NativeReviewRecoveryResult>;
 	repairLegacyAlias?(request: NativeReviewLegacyAliasRepairRequest): Promise<NativeReviewRecoveryResult>;
-	// Net-new negotiated operations (contract v2 only): `review.repair` is
-	// advertised in the v2 operation list; `capture-evidence` is the
-	// evidence-first correction lifecycle's collection step.
 	repair?(request: NativeReviewRepairRequest): Promise<ReviewRepairV2>;
-	captureEvidence?(request: NativeReviewCaptureEvidenceRequest): Promise<NativeReviewVerificationEvidenceV2>;
+	captureResult?(request: NativeReviewCaptureResultRequest): Promise<NativeReviewCaptureResultOutcome>;
+	captureCorrectionPlan?(request: NativeReviewCorrectionPlanCaptureRequest): Promise<ReviewLastEventClosureV1>;
+	captureProviderRole?(request: NativeReviewProviderRoleCaptureRequest): Promise<NativeReviewProviderRoleCaptureOutcome>;
 	// Dark until a negotiated version reports the `mode` capability true
 	// (Design Decision #7, organic-rdd-parity). Plain versioned CLI operation,
 	// outside the negotiated review-integration protocol — same shape as
-	// reviewStatus/sddStatus/reclaim above.
+	// reviewStatus/reclaim above.
 	reviewMode?(request: NativeReviewModeRequest): Promise<NativeReviewModeResult>;
 }
 
@@ -146,6 +132,12 @@ export const NATIVE_REVIEW_MODE_SOURCE = {
 } as const;
 export type NativeReviewModeSource = (typeof NATIVE_REVIEW_MODE_SOURCE)[keyof typeof NATIVE_REVIEW_MODE_SOURCE];
 
+export const NATIVE_REVIEW_MODE_REACH = {
+	MACHINE: "machine",
+	THIS_BUILD: "this_build",
+} as const;
+export type NativeReviewModeReach = (typeof NATIVE_REVIEW_MODE_REACH)[keyof typeof NATIVE_REVIEW_MODE_REACH];
+
 export const NATIVE_REVIEW_MODE_SCOPE = {
 	GLOBAL: "global",
 	CLONE: "clone",
@@ -165,6 +157,7 @@ export interface NativeReviewModeStatus {
 	effective: "on" | "off";
 	source: NativeReviewModeSource;
 	revision?: string;
+	reach?: NativeReviewModeReach;
 }
 
 export interface NativeReviewModeResult {
@@ -175,18 +168,24 @@ export interface NativeReviewModeResult {
 
 // Exact-match tolerated-stderr allowlist for START only, gated on the `mode`
 // capability being true (Design Decision #6, organic-rdd-parity). Byte-exact
-// against gentle-ai's headless notice (internal/cli/review_mode.go
-// reviewConsentSkippedNotice) written when the switch is on but no interactive
-// terminal answered the one-time consent question — which is always true when
-// Pi spawns gentle-ai without a TTY. Any other text still fails closed as
-// UNEXPECTED_STDERR.
-// Each entry is one whole line gentle-ai may write to the console stream while
-// still succeeding. The provenance line rides with the skip notice whenever the
-// resolved mode source is `default`, so a headless START legitimately emits two
-// lines; they are separate Fprintln calls, never one joined string.
+// against gentle-ai's headless notices (internal/cli/review_mode.go
+// reviewConsentSkippedNotice and its siblings) written when the switch is on
+// but no interactive terminal answered the one-time consent question — which
+// is always true when Pi spawns gentle-ai without a TTY. Any other text still
+// fails closed as UNEXPECTED_STDERR.
+//
+// Each entry is one whole line the PINNED gentle-ai may write to the console
+// stream while still succeeding. That last qualifier is what keeps this list
+// honest: v2.4.0 deleted reviewConsentSkippedDefaultProvenance ("Reviews are
+// on by default; this was never explicitly chosen. ..."), which used to ride
+// with the skip notice whenever the resolved mode source was `default`. Under
+// opt-in receipt-driven development a default-source clone is refused long
+// before the consent ceremony runs, so the pinned binary can no longer emit
+// that line and it is removed here rather than left as dead tolerance. Multi-
+// line stderr is still expected in principle — these are separate Fprintln
+// calls, never one joined string — which is why membership is per line.
 export const REVIEW_CONSENT_NOTICES = Object.freeze([
 	"Gentle AI reviewed this change without asking, because this session has no terminal to answer on. Run 'gentle-ai review mode disable' to turn reviews off, or 'gentle-ai review mode status' to see the current setting.",
-	"Reviews are on by default; this was never explicitly chosen. Run 'gentle-ai review mode enable' to make reviews an explicit choice, or 'gentle-ai review mode disable' to turn them off.",
 	"Gentle AI could not read an answer, so it reviewed this change and will ask again next time.",
 	"Gentle AI did not recognize that answer, so it reviewed this change and will ask again next time.",
 	"Review skipped for this candidate at your request. It will be offered again on the next change.",
@@ -201,6 +200,22 @@ function stderrIsTolerated(stderr: string, tolerated: readonly string[]): boolea
 	return lines.length > 0 && lines.every((line) => tolerated.includes(line));
 }
 
+// gentle-ai main narrates the negotiated STATUS forecast head to a human on
+// stderr while keeping the machine envelope on stdout (reviewNarrateForecast
+// in internal/cli/review_narration.go, ground-truthed live against a main-line
+// dev build). The pinned release does not emit it, so this narration is
+// tolerated only for negotiated STATUS while the dev-binary override is
+// configured; any other stderr keeps failing closed.
+const FORECAST_NARRATION_LINES = Object.freeze([
+	/^Forecast horizon: (?:partial|terminal)$/,
+	/^step [0-9]+: (?:execute|collect|stop); reason_code=[a-z0-9_]+; description=.+$/,
+	/^Re-query STATUS after completing this partial head\.$/,
+]);
+function stderrIsForecastNarration(stderr: string): boolean {
+	const lines = stderr.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+	return lines.length > 0 && lines.every((line) => FORECAST_NARRATION_LINES.some((pattern) => pattern.test(line)));
+}
+
 export const NATIVE_REVIEW_RECOVER_DISPOSITION = ["scope_changed", "invalidated", "escalated"] as const;
 export type NativeReviewRecoverDisposition = (typeof NATIVE_REVIEW_RECOVER_DISPOSITION)[number];
 
@@ -244,6 +259,9 @@ export interface NativeReviewAbandonRequest {
 	lineage: string;
 	expectedRevision: string;
 	snapshotIdentity: string;
+	capturedLensResults: readonly string[];
+	findingsPresent: boolean;
+	evidenceRecordsPresent: boolean;
 	actor: string;
 	reason: string;
 	maintainerAuthorization: string;
@@ -305,28 +323,12 @@ export interface NativeReviewRepairRequest {
 	signal?: AbortSignal;
 }
 
-// `review capture-evidence` argv and response shape are pinned to a real
-// v2.2.2 review run (lineage review-b39d803b68a90767): exactly
-// --cwd/--lineage/--target/--expected-revision/--outcome/--input, no
-// --contract, and the `gentle-ai.review-verification-evidence/v2` record
-// returned directly (not wrapped in an operation/v2 envelope).
-export const NATIVE_REVIEW_CAPTURE_OUTCOME = ["passed", "verification_failed", "procedural_tooling_failed"] as const;
-export type NativeReviewCaptureOutcome = (typeof NATIVE_REVIEW_CAPTURE_OUTCOME)[number];
-
 // `capture-result` is an additive headless command, NOT a negotiated
 // repository operation: it accepts no --contract, and the provider's own
 // transition tokens already carry the repository context -- it takes that or
 // --cwd, never both. So Pi passes the tokens through verbatim and adds only
 // --input. Reconstructing them would mean re-deriving a lineage, revision,
 // target, lens slot, and subject hash the provider already issued.
-// Added for the v2 finalize transport. `capturedResults` asks the provider to
-// discover every manifest it already admitted; `resultArtifactFiles` hands them
-// over explicitly in lens order. Both replace the retired `--result`.
-export interface NativeReviewFinalizeCapturedResults {
-	readonly capturedResults?: boolean;
-	readonly resultArtifactFiles?: readonly string[];
-}
-
 export interface NativeReviewCaptureResultRequest {
 	readonly argumentTokens: readonly string[];
 	readonly resultDocument: string;
@@ -345,36 +347,107 @@ export interface NativeReviewAdmittedResultManifest {
 	readonly reference?: string;
 }
 
-export interface NativeReviewCaptureEvidenceRequest {
-	cwd: string;
-	lineageId: string;
-	targetIdentity: string;
-	expectedRevision: string;
-	outcome: NativeReviewCaptureOutcome;
-	evidenceDocument: string;
-	signal?: AbortSignal;
+/** A non-final reviewer capture acknowledges an admitted artifact; final captures close natively. */
+export type NativeReviewCaptureResultOutcome = NativeReviewAdmittedResultManifest | ReviewLastEventClosureV1;
+
+// The one continuation that burns approved authority. Its tokens are rendered
+// by the provider in a closed order and are relayed verbatim: Pi never builds,
+// reorders, or substitutes one, because a synthesized acknowledgement would be
+// Pi deciding that a review is over. `binding` is the lineage, target, and
+// revision the caller already holds from STATUS: when the provider answers the
+// burn with a review-acknowledged/v1 envelope (gentle-ai #3947), that envelope
+// must name exactly this burn.
+export interface NativeReviewAcknowledgeApprovedRequest {
+	readonly argumentTokens: readonly string[];
+	readonly cwd: string;
+	readonly binding?: ReviewAcknowledgedExpectationV1;
+	readonly signal?: AbortSignal;
 }
 
-export interface NativeReviewVerificationEvidenceV2 {
-	schema: "gentle-ai.review-verification-evidence/v2";
-	version: 2;
-	lineageId: string;
-	authorityRevision: string;
-	targetIdentity: string;
-	candidateTree: string;
-	pathsDigest: string;
-	paths: readonly string[];
-	ledgerIds: readonly string[];
-	rawPayloadSha256: string;
-	rawPayloadBytes: number;
-	outcome: NativeReviewCaptureOutcome;
-	recordDigest: string;
+/** `undefined` is the pinned silent burn (every release up to v2.5.0-rc.3); an envelope is the #3947 typed burn. */
+export type NativeReviewAcknowledgeApprovedOutcome = ReviewAcknowledgedV1 | undefined;
+
+export interface NativeReviewCorrectionPlanCaptureRequest {
+	readonly argumentTokens: readonly string[];
+	readonly correctionLines: number;
+	readonly cwd: string;
+	readonly signal?: AbortSignal;
 }
 
-export interface NativeStartRequest { cwd: string; baseRef?: string; committedOnly?: boolean; lineageId?: string; policyPath?: string; focus?: string; targetIdentity?: string; projection?: "workspace" | "staged"; signal?: AbortSignal; }
+// gentle-pi#311 P4-roles: one Go-owned non-lens provider role capture. The
+// provider renders a SELF-CONTAINED authority-advancing vector
+// (`review.capture-refuter` / `review.capture-validation` with binding tokens
+// plus `--agent=pi --execute=true`, no submission descriptor); Pi executes the
+// exact rendered invocation verbatim, in the foreground, and Go materializes
+// the role prompt, spawns its own locked-down pi subprocess, and admits the
+// raw verdict. Nothing here authors, parses, or transports role output.
+export const NATIVE_REVIEW_PROVIDER_ROLE_CAPTURE_SCHEMA = "gentle-ai.review-provider-role-capture/v1";
+
+// Capture operations and their terminal closure operations are independently
+// named upstream. Keep this closed mapping explicit: capture-validation is the
+// intentionally nonuniform `review/capture-validation` closure operation.
+export const NATIVE_REVIEW_PROVIDER_ROLE_CAPTURE_CLOSURE_OPERATION = {
+	"review.capture-refuter": "review.capture-refuter",
+	"review.capture-validation": "review/capture-validation",
+} as const;
+type NativeReviewProviderRoleCaptureOperation = keyof typeof NATIVE_REVIEW_PROVIDER_ROLE_CAPTURE_CLOSURE_OPERATION;
+
+function isNativeReviewProviderRoleCaptureOperation(operation: string): operation is NativeReviewProviderRoleCaptureOperation {
+	return Object.hasOwn(NATIVE_REVIEW_PROVIDER_ROLE_CAPTURE_CLOSURE_OPERATION, operation);
+}
+
+export interface NativeReviewProviderRoleCaptureRequest {
+	/** The provider-named capture operation, e.g. `review.capture-refuter`. */
+	readonly captureOperation: string;
+	/** Every provider-issued argument token, verbatim, in provider order. */
+	readonly argumentTokens: readonly string[];
+	/** Process working directory only; never rendered into the invocation. */
+	readonly cwd: string;
+	readonly signal?: AbortSignal;
+}
+
+export interface NativeReviewProviderRoleCaptureArtifact {
+	readonly schema: typeof NATIVE_REVIEW_PROVIDER_ROLE_CAPTURE_SCHEMA;
+	readonly lineageId: string;
+	readonly targetIdentity: string;
+	readonly role: string;
+	readonly captured: true;
+}
+
+/** Refuter and validator captures close only when they are the native last event. */
+export type NativeReviewProviderRoleCaptureOutcome = NativeReviewProviderRoleCaptureArtifact | ReviewLastEventClosureV1;
+
+export const NATIVE_UNTRACKED_SCOPE = {
+	EXCLUDE: "exclude",
+	SELECT: "select",
+} as const;
+export type NativeUntrackedScope = (typeof NATIVE_UNTRACKED_SCOPE)[keyof typeof NATIVE_UNTRACKED_SCOPE];
+
+export interface NativeIntendedUntrackedSelectionSubmission {
+	readonly argumentTokens: readonly string[];
+	readonly value: string;
+}
+interface NativeUntrackedSelectionRequest {
+	untrackedScope?: NativeUntrackedScope;
+	expectedUntrackedInventory?: string;
+	intendedUntracked?: readonly string[];
+	intendedUntrackedSelection?: NativeIntendedUntrackedSelectionSubmission;
+}
+
+export interface NativeStartRequest extends NativeUntrackedSelectionRequest {
+	cwd: string;
+	baseRef?: string;
+	committedOnly?: boolean;
+	lineageId?: string;
+	policyPath?: string;
+	focus?: string;
+	targetIdentity?: string;
+	projection?: "workspace" | "staged";
+	signal?: AbortSignal;
+}
 export const NATIVE_REVIEW_CONSENT_ANSWER = { GRANTED: "granted", DECLINED: "declined" } as const;
 export type NativeReviewConsentAnswer = (typeof NATIVE_REVIEW_CONSENT_ANSWER)[keyof typeof NATIVE_REVIEW_CONSENT_ANSWER];
-export interface NativeReviewConsentAnswerRequest { cwd: string; consent: ReviewConsentV2; answer: NativeReviewConsentAnswer; signal?: AbortSignal; }
+export interface NativeReviewConsentAnswerRequest { cwd: string; consent: ReviewConsentEnvelope; answer: NativeReviewConsentAnswer; signal?: AbortSignal; }
 export interface NativeReviewConsentDeclinedResult {
 	kind: "declined";
 	targetIdentity: string;
@@ -387,30 +460,25 @@ export interface NativeReviewConsentDeclinedResult {
 }
 export interface NativeReviewConsentStartedResult { kind: "started"; start: NativeStartResult; }
 export type NativeReviewConsentAnswerResult = NativeReviewConsentStartedResult | NativeReviewConsentDeclinedResult;
-export interface NativeFinalizeLensResult { lens: string; document: unknown; }
-export interface NativeFinalizeRequest extends NativeReviewFinalizeCapturedResults {
+export interface NativeReviewStatusRequest { cwd: string; signal?: AbortSignal; }
+export interface NativeTargetStatusRequest extends NativeUntrackedSelectionRequest {
 	cwd: string;
 	lineageId?: string;
-	resultFiles?: readonly string[];
-	lensResults?: readonly NativeFinalizeLensResult[];
-	refuterFile?: string;
-	refuterDocument?: unknown;
-	correctionLines?: number;
-	validationFile?: string;
-	validationDocument?: unknown;
-	evidenceFile?: string;
-	evidenceDocument?: string;
-	failed?: boolean;
+	baseRef?: string;
+	committedOnly?: boolean;
+	projection?: "workspace" | "staged";
+	/**
+	 * The immutable reviewer runtime this host provides. Measured against the
+	 * live 2.4.0-main provider: the materialize-marked relay slot (agent=pi,
+	 * materialize=true, plus the provider submission) is offered ONLY when the
+	 * caller names its agent; an agent-less status returns a bare
+	 * capture-result input the host relay cannot consume. Providers older than
+	 * v2.4.0 do not define the flag and refuse it, so callers probe and fall
+	 * back rather than version-sniff.
+	 */
+	agent?: "pi";
 	signal?: AbortSignal;
 }
-export interface NativeValidateRequest { cwd: string; gate: string; lineageId?: string; flags?: readonly string[]; signal?: AbortSignal; }
-export interface NativeBindSddRequest { cwd: string; change: string; lineage: string; expectedBindingRevision: string; signal?: AbortSignal; }
-export interface NativeSddStatusRequest { cwd: string; change: string; signal?: AbortSignal; }
-export interface NativeReviewStatusRequest { cwd: string; signal?: AbortSignal; }
-export interface NativeCapabilitiesRequest { cwd?: string; signal?: AbortSignal; }
-export interface NativeTargetStatusRequest { cwd: string; lineageId?: string; baseRef?: string; projection?: "workspace" | "staged"; signal?: AbortSignal; }
-export interface NativeGateContext { lineageId: string; storeRevision: string; raw: Record<string, unknown>; }
-
 export const NATIVE_REVIEW_AUTHORITY_STATUS = {
 	CLEAN: "clean",
 	ACTIVE: "active",
@@ -507,29 +575,60 @@ export interface NativeReviewStatusResult {
 	diagnostics: readonly NativeReviewAuthorityDiagnostic[];
 	raw: Record<string, unknown>;
 }
-export const NATIVE_START_ACTION = { CREATED: "created", RESUMED: "resumed", REUSE_RECEIPT: "reuse-receipt", BLOCKED_SCOPE_ACTION: "blocked-scope-action" } as const;
+export const NATIVE_START_ACTION = { CREATED: "created", RESUMED: "resumed", REPLAYED: "replayed", CLOSED: "closed", BLOCKED_SCOPE_ACTION: "blocked-scope-action" } as const;
 export type NativeStartAction = (typeof NATIVE_START_ACTION)[keyof typeof NATIVE_START_ACTION];
-export interface NativeStartResult { lineageId: string; state: ReviewStartState; riskLevel: string; selectedLenses: readonly string[]; changedFiles: number; changedLines: number; correctionBudget: number; action: NativeStartAction; lensesRequired: boolean; riskReasons?: readonly Record<string, unknown>[]; raw?: Readonly<Record<string, unknown>>; riskEvidence?: readonly string[]; hint?: string; }
-export interface NativeValidateResult { allowed: boolean; result: "allow" | "scope-changed" | "invalidated" | "escalated"; action: string; reason: string; gateContext: NativeGateContext; delivery?: "disabled/unmanaged"; }
-export interface NativeFinalizeResult { lineageId: string; state: string; action: string; storeRevision: string; receiptPath?: string; validationRequest?: Readonly<Record<string, unknown>>; escalation?: string; }
-export interface NativeBindSddResult {
-	revision: string;
-	change: string;
-	lineage: string;
-	authorityRevision: string;
-	receiptHash: string;
-	gateContext: NativeGateContext;
+export interface NativeStartResult { lineageId: string; state: ReviewStartState; riskLevel: string; selectedLenses: readonly string[]; changedFiles: number; changedLines: number; correctionBudget: number; action: NativeStartAction; lensesRequired: boolean; riskReasons?: readonly Record<string, unknown>[]; nextTransition?: ReviewNextTransitionV3; raw?: Readonly<Record<string, unknown>>; riskEvidence?: readonly string[]; hint?: string; }
+export function isCanonicalProcessString(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0 && value.trim() === value && !/[\u0000-\u001f\u007f]/.test(value);
 }
-export interface NativeSddStatusResult {
-	ready: boolean;
-	artifactStore: NativeSddArtifactStore;
-	artifacts: NativeSddArtifactStates;
-	nextRecommended: string;
-	[key: string]: unknown;
+
+interface NativeUntrackedSelection {
+	untrackedScope?: NativeUntrackedScope;
+	expectedUntrackedInventory?: string;
+	intendedUntracked?: readonly string[];
 }
 
-export function isCanonicalProcessString(value: unknown): value is string {
-	return typeof value === "string" && value.length > 0 && value.trim() === value && !/[\u0000-\u001f\u007f]/.test(value);
+function isNativeUntrackedPath(value: unknown): value is string {
+	return isCanonicalProcessString(value)
+		&& !posix.isAbsolute(value)
+		&& !win32.isAbsolute(value)
+		&& !value.includes("\\")
+		&& value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+
+function nativeUntrackedSelection(request: NativeUntrackedSelectionRequest): NativeUntrackedSelection {
+	const { untrackedScope, expectedUntrackedInventory, intendedUntracked } = request;
+	const declared = untrackedScope !== undefined || expectedUntrackedInventory !== undefined || intendedUntracked !== undefined;
+	if (!declared) return {};
+	if (
+		(untrackedScope !== NATIVE_UNTRACKED_SCOPE.EXCLUDE && untrackedScope !== NATIVE_UNTRACKED_SCOPE.SELECT) ||
+		!isCanonicalProcessString(expectedUntrackedInventory) ||
+		(intendedUntracked !== undefined && (!Array.isArray(intendedUntracked) || intendedUntracked.some((path) => !isNativeUntrackedPath(path) || intendedUntracked.indexOf(path) !== intendedUntracked.lastIndexOf(path))))
+	) {
+		throw new TypeError("Native untracked selection must declare one scope, one inventory digest, and unique repository-relative paths");
+	}
+	if (untrackedScope === NATIVE_UNTRACKED_SCOPE.EXCLUDE && (intendedUntracked?.length ?? 0) > 0) {
+		throw new TypeError("Native exclude untracked selection cannot include paths");
+	}
+	if (untrackedScope === NATIVE_UNTRACKED_SCOPE.SELECT && (intendedUntracked?.length ?? 0) === 0) {
+		throw new TypeError("Native select untracked selection requires at least one path");
+	}
+	return {
+		untrackedScope,
+		expectedUntrackedInventory,
+		intendedUntracked: intendedUntracked === undefined ? undefined : [...intendedUntracked],
+	};
+}
+
+function nativeUntrackedSelectionArguments(selection: NativeUntrackedSelection): readonly string[] {
+	if (selection.untrackedScope === undefined) return [];
+	return [
+		`--untracked-scope=${selection.untrackedScope}`,
+		`--expected-untracked-inventory=${selection.expectedUntrackedInventory!}`,
+		...(selection.untrackedScope === NATIVE_UNTRACKED_SCOPE.SELECT
+			? selection.intendedUntracked!.map((path) => `--intended-untracked=${path}`)
+			: []),
+	];
 }
 
 const NATIVE_RISK_LEVEL = ["low", "medium", "high"] as const;
@@ -610,28 +709,21 @@ export function nativeRiskEvidencePhrases(riskLevel: string, reasons: readonly N
 	return riskLevel === "medium" ? [REVIEW_MEDIUM_RISK_REASON, ...phrases] : phrases;
 }
 const NATIVE_REVIEW_LENS = ["review-risk", "review-resilience", "review-readability", "review-reliability"] as const;
-const NATIVE_FINALIZE_STATE = ["reviewing", "correction_required", "validating", "approved", "escalated"] as const;
 const NATIVE_START_ACTION_VALUES = Object.values(NATIVE_START_ACTION);
-const NATIVE_GATE_RESULT = ["allow", "scope-changed", "invalidated", "escalated"] as const;
-const NATIVE_GATE = ["post-apply", "pre-commit", "pre-push", "pre-pr", "release"] as const;
-const NATIVE_SDD_NEXT_ACTION = ["apply", "verify", "remediate", "archive", "review", "resolve-review", "resolve-blockers", "sdd-new", "select-change", "propose", "spec", "design", "tasks"] as const;
-const NATIVE_SDD_POST_REVIEW_ACTION = ["verify", "archive"] as const;
-
-// Organic-parity columns (mode, riskEvidence, hint, delivery) stay false on
-// every shipped row, including "2.1.11". PI-2 adds the first capability-true
-// row (and bumps the triple pin) in one dedicated commit — never one without
-// the other. See Design Decision #1 (organic-rdd-parity).
+// The pin table is intentionally preserved unchanged while #3587 is
+// unpublished. Last-event capture support is exercised through the explicit
+// dev-binary override; no source-level pin or contract-row mutation is allowed.
 const ORGANIC_PARITY_DARK = { mode: false, riskEvidence: false, hint: false, delivery: false } as const;
 
 export const NATIVE_CLI_CONTRACTS = Object.freeze({
-	"2.1.4": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: false, inventory: false, reclaim: false, recover: false, abandon: false, quarantineLegacy: false, reconcileAuthority: false, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
-	"2.1.5": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: true, inventory: true, reclaim: false, recover: false, abandon: false, quarantineLegacy: false, reconcileAuthority: false, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
-	"2.1.6": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: true, inventory: true, reclaim: false, recover: false, abandon: false, quarantineLegacy: false, reconcileAuthority: false, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
-	"2.1.7": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: true, inventory: true, reclaim: false, recover: false, abandon: false, quarantineLegacy: false, reconcileAuthority: false, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
-	"2.1.8": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: true, inventory: true, reclaim: true, recover: true, abandon: false, quarantineLegacy: false, reconcileAuthority: true, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
-	"2.1.9": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
-	"2.1.10": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, ...ORGANIC_PARITY_DARK }),
-	"2.1.11": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, ...ORGANIC_PARITY_DARK }),
+	"2.1.4": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: false, inventory: false, reclaim: false, recover: false, abandon: false, quarantineLegacy: false, reconcileAuthority: false, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
+	"2.1.5": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: false, recover: false, abandon: false, quarantineLegacy: false, reconcileAuthority: false, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
+	"2.1.6": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: false, recover: false, abandon: false, quarantineLegacy: false, reconcileAuthority: false, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
+	"2.1.7": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: false, recover: false, abandon: false, quarantineLegacy: false, reconcileAuthority: false, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
+	"2.1.8": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: false, quarantineLegacy: false, reconcileAuthority: true, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
+	"2.1.9": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: false, ...ORGANIC_PARITY_DARK }),
+	"2.1.10": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, ...ORGANIC_PARITY_DARK }),
+	"2.1.11": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, ...ORGANIC_PARITY_DARK }),
 	// First capability-true row, paired with the triple pin bump in this same
 	// commit as Design Decision #1 requires.
 	//
@@ -652,7 +744,7 @@ export const NATIVE_CLI_CONTRACTS = Object.freeze({
 	// needs the negotiated start envelope extended upstream, which moves a
 	// byte-pinned fixture and therefore belongs to a gentle-ai release, not to
 	// a Pi capability flip.
-	"2.2.0": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
+	"2.2.0": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
 	// 2.2.1 repeats 2.2.0 because the wire did not move for the lane Pi speaks.
 	// v2.2.1 advertises capabilities/v1.5 (protocol minor 5) on
 	// review-integration/v1, but the negotiated start envelope is still the
@@ -660,35 +752,44 @@ export const NATIVE_CLI_CONTRACTS = Object.freeze({
 	// they are dark on 2.2.0. The release does publish a second contract,
 	// review-integration/v2, whose `start/v3` carries base/candidate trees --
 	// but Pi does not negotiate it yet, and a row must describe the lane in use.
-	"2.2.1": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
+	"2.2.1": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
 	// 2.2.2 repeats 2.2.1 for the same reason, confirmed against the released
 	// v2.2.2 binary rather than assumed: on review-integration/v1 it still
 	// advertises capabilities/v1.5 and the negotiated start envelope is still
 	// the closed `start/v2`, so riskEvidence and hint still cannot arrive.
-	"2.2.2": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, sddStatus: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
+	"2.2.2": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
+	// Ground-truthed against the released v2.2.3 binary: the v2 lane remains
+	// protocol 2.0 with the same operation set and closed START fields consumed
+	// by Pi, so the existing capability columns are unchanged.
+	"2.2.3": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
+	// Ground-truthed against the released v2.4.0 binary: the v2 lane advertises
+	// capabilities/v2.2 and answers status/v5 and consent/v3, all of which the
+	// existing decoders already read, and the START envelope Pi consumes is
+	// still `start/v3` carrying `risk_reasons` with no `risk_evidence` and no
+	// `hint`, so the existing capability columns are unchanged. v2.4.0 also
+	// made receipt-driven development opt-in, which changes what the mode
+	// envelope reports, not whether it reports it. v2.2.4 and v2.3.0 shipped
+	// while Pi stayed on 2.2.3; they were never pinned or probed, so they get
+	// no row.
+	"2.4.0": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
+	// Ground-truthed by driving the exact v2.5.0-rc.3 tagged build through the
+	// gentle-ai-bench driven journey corpus (exit 0), which exercises the
+	// start/status/capture/validate/mode/delivery lifecycles Pi consumes. The
+	// v2 lane advertises capabilities/v2.3 and its reviewing START is the
+	// `start/v4` continuation envelope that #499 already decodes; the closed
+	// fields Pi consumes are unchanged, so the columns match the 2.4.0 row.
+	// riskEvidence and hint stay dark: still not proven to reach the
+	// negotiated path Pi reads.
+	"2.5.0-rc.3": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
+	// Ground-truthed against the published v2.5.0 binary installed from its
+	// signed archive: `review capabilities` on the v2 lane advertises
+	// capabilities/v2.4 (protocol minor 4) and answers status/v6, consent/v3,
+	// and the `start/v4` continuation, all of which the decoders already read.
+	// The closed fields Pi consumes did not change between rc.3 and stable, so
+	// the columns match the 2.5.0-rc.3 row. riskEvidence and hint stay dark:
+	// still not proven to reach the negotiated START path Pi reads.
+	"2.5.0": Object.freeze({ start: true, finalize: true, validate: true, bindSdd: true, status: true, inventory: true, reclaim: true, recover: true, abandon: true, quarantineLegacy: true, reconcileAuthority: true, repairLegacyAlias: true, mode: true, riskEvidence: false, hint: false, delivery: true }),
 });
-type NativeCliCapability = keyof (typeof NATIVE_CLI_CONTRACTS)[keyof typeof NATIVE_CLI_CONTRACTS];
-
-// Testing-only capability overlay: lets tests exercise mode/riskEvidence/hint/
-// delivery decode paths under a synthetic version key without ever making a
-// shipped row (including "2.1.11") capability-true. Production code never
-// calls the setter, so this is inert outside test files.
-const nativeCliContractsTestingOverlay = new Map<string, Record<NativeCliCapability, boolean>>();
-export function setNativeCliContractForTesting(version: string, contract: Record<NativeCliCapability, boolean> | undefined): void {
-	if (contract === undefined) nativeCliContractsTestingOverlay.delete(version);
-	else nativeCliContractsTestingOverlay.set(version, contract);
-}
-function resolvedNativeCliContract(version: string): Record<NativeCliCapability, boolean> | undefined {
-	return nativeCliContractsTestingOverlay.get(version) ?? (NATIVE_CLI_CONTRACTS as Record<string, Record<NativeCliCapability, boolean> | undefined>)[version];
-}
-
-export interface NativeReviewStructuredDenial {
-	schema: "gentle-ai.review-gate-result/v1";
-	result: "scope-changed" | "invalidated" | "escalated";
-	action: string;
-	reason: string;
-	denial?: { stage: string; code: string };
-}
 
 export interface NativeReviewProcessDiagnostics {
 	operation: NativeReviewOperation;
@@ -697,8 +798,9 @@ export interface NativeReviewProcessDiagnostics {
 	signal?: NodeJS.Signals;
 	timed_out: boolean;
 	output_limit_exceeded: boolean;
+	max_buffer_bytes?: number;
+	configuration_hint?: string;
 	stderr?: string;
-	denial?: NativeReviewStructuredDenial;
 }
 
 export class NativeReviewCliError extends Error {
@@ -724,15 +826,25 @@ export class NativeReviewCliError extends Error {
 	}
 }
 
+// The one central runner for every gentle-ai CLI invocation the extension
+// makes. It declares the Pi host relay handshake on each spawn: gentle-ai
+// refuses pi admission pre-authority without it (gentle-pi#311 P4), and a
+// single injection point keeps the declaration impossible to forget on any
+// individual operation.
+export function gentleAiProcessEnvironment(base: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+	return { ...base, [GENTLE_PI_REVIEW_RELAY_CONTRACT_ENV]: GENTLE_PI_REVIEW_RELAY_CONTRACT };
+}
+
 export function createNodeExecFileAdapter(): ExecFileAdapter {
 	return async (request) => {
 		try {
-			const output = await execFileAsync(request.file, [...request.arguments], { cwd: request.cwd, encoding: "utf8", shell: false, windowsHide: true, timeout: request.timeoutMs, maxBuffer: request.maxBufferBytes, signal: request.signal });
+			const output = await execFileAsync(request.file, [...request.arguments], { cwd: request.cwd, encoding: "utf8", shell: false, windowsHide: true, timeout: request.timeoutMs, maxBuffer: request.maxBufferBytes, signal: request.signal, env: gentleAiProcessEnvironment() });
 			return { stdout: output.stdout, stderr: output.stderr, exitCode: 0, signal: null, timedOut: false, outputLimitExceeded: false };
 		} catch (error) {
 			const detail = error as NodeJS.ErrnoException & { stdout?: string; stderr?: string; code?: string | number; signal?: NodeJS.Signals; killed?: boolean };
 			if (detail.code === "ENOENT" || detail.code === "EACCES" || detail.name === "AbortError") throw error;
-			return { stdout: detail.stdout ?? "", stderr: detail.stderr ?? "", exitCode: typeof detail.code === "number" ? detail.code : 1, signal: detail.signal ?? null, timedOut: detail.killed === true, outputLimitExceeded: detail.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" };
+			const outputLimitExceeded = detail.code === "ENOBUFS" || detail.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+			return { stdout: detail.stdout ?? "", stderr: detail.stderr ?? "", exitCode: typeof detail.code === "number" ? detail.code : 1, signal: detail.signal ?? null, timedOut: !outputLimitExceeded && detail.killed === true, outputLimitExceeded };
 		}
 	};
 }
@@ -760,7 +872,6 @@ function decodeSelectedLenses(value: unknown, riskLevel: string, lensesRequired:
 }
 function enumString(value: unknown, allowed: readonly string[]): string { const parsed = stringValue(value); if (!allowed.includes(parsed)) throw new Error("unsupported enum"); return parsed; }
 const NATIVE_DIAGNOSTIC_TEXT_LIMIT = 4_096;
-const NATIVE_REVIEW_DENIAL_TEXT_LIMIT = 1_024;
 
 function sanitizeNativeDiagnosticText(value: string, limit = NATIVE_DIAGNOSTIC_TEXT_LIMIT): string {
 	const normalized = value
@@ -775,70 +886,46 @@ function sanitizeNativeDiagnosticText(value: string, limit = NATIVE_DIAGNOSTIC_T
 	return normalized.length <= limit ? normalized : `${normalized.slice(0, limit - 14)}…[truncated]`;
 }
 
-function parseStructuredNativeDenial(stdout: string): NativeReviewStructuredDenial | undefined {
-	if (Buffer.byteLength(stdout, "utf8") > NATIVE_DIAGNOSTIC_TEXT_LIMIT * 4) return undefined;
-	try {
-		const value = exactObject(JSON.parse(stdout), ["schema", "result", "allowed", "action", "reason", "context"]);
-		const result = enumString(value.result, ["scope-changed", "invalidated", "escalated"] as const) as NativeReviewStructuredDenial["result"];
-		const action = sanitizeNativeDiagnosticText(requiredString(value.action), NATIVE_REVIEW_DENIAL_TEXT_LIMIT);
-		const reason = sanitizeNativeDiagnosticText(requiredString(value.reason), NATIVE_REVIEW_DENIAL_TEXT_LIMIT);
-		const expectedAction = { "scope-changed": "create-new-lineage", invalidated: "explicit-maintainer-action", escalated: "stop" }[result];
-		if (
-			value.schema !== "gentle-ai.review-gate-result/v1" ||
-			value.allowed !== false ||
-			action !== expectedAction ||
-			!isCanonicalProcessString(action) ||
-			!isCanonicalProcessString(reason)
-		) return undefined;
-		const context = decodeGateContext(value.context).raw;
-		const rawDenial = context.denial;
-		const denial = rawDenial === undefined
-			? undefined
-			: (() => {
-				const parsed = exactObject(rawDenial, ["stage", "code"]);
-				const stage = sanitizeNativeDiagnosticText(requiredString(parsed.stage), NATIVE_REVIEW_DENIAL_TEXT_LIMIT);
-				const code = sanitizeNativeDiagnosticText(requiredString(parsed.code), NATIVE_REVIEW_DENIAL_TEXT_LIMIT);
-				if (!isCanonicalProcessString(stage) || !isCanonicalProcessString(code)) throw new Error("non-canonical denial evidence");
-				return { stage, code };
-			})();
-		return { schema: "gentle-ai.review-gate-result/v1", result, action, reason, ...(denial === undefined ? {} : { denial }) };
-	} catch { return undefined; }
-}
-
 // Rebuild diagnostics from a duplicated module instance before facade output.
 export function sanitizeForeignNativeReviewDiagnostics(value: unknown): NativeReviewProcessDiagnostics | undefined {
 	try {
-		const raw = exactObject(value, ["operation", "error_code", "timed_out", "output_limit_exceeded"], ["exit_code", "signal", "stderr", "denial"]);
+		const raw = exactObject(value, ["operation", "error_code", "timed_out", "output_limit_exceeded"], ["exit_code", "signal", "max_buffer_bytes", "configuration_hint", "stderr"]);
 		const operation = enumString(raw.operation, Object.values(NATIVE_REVIEW_OPERATION)) as NativeReviewOperation;
 		const errorCode = enumString(raw.error_code, Object.values(NATIVE_REVIEW_ERROR_CODE)) as NativeReviewErrorCode;
 		const signal = raw.signal === undefined ? undefined : requiredString(raw.signal);
-		if (signal !== undefined && !/^SIG[A-Z0-9]{1,12}$/.test(signal)) return undefined;
-		return { operation, error_code: errorCode, ...(raw.exit_code === undefined ? {} : { exit_code: nonNegativeInteger(raw.exit_code) }), ...(signal === undefined ? {} : { signal: signal as NodeJS.Signals }), timed_out: booleanValue(raw.timed_out), output_limit_exceeded: booleanValue(raw.output_limit_exceeded), ...(raw.stderr === undefined ? {} : { stderr: sanitizeNativeDiagnosticText(stringValue(raw.stderr)) }), ...(raw.denial === undefined ? {} : { denial: sanitizeForeignStructuredDenial(raw.denial) }) };
+		const maxBufferBytes = raw.max_buffer_bytes === undefined ? undefined : positiveInteger(raw.max_buffer_bytes);
+		const configurationHint = raw.configuration_hint === undefined ? undefined : stringValue(raw.configuration_hint);
+		if (
+			(signal !== undefined && !/^SIG[A-Z0-9]{1,12}$/.test(signal)) ||
+			(maxBufferBytes === undefined) !== (configurationHint === undefined) ||
+			(configurationHint !== undefined && (errorCode !== NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT || configurationHint !== NATIVE_REVIEW_MAX_BUFFER_CONFIGURATION_HINT))
+		) return undefined;
+		return {
+			operation,
+			error_code: errorCode,
+			...(raw.exit_code === undefined ? {} : { exit_code: nonNegativeInteger(raw.exit_code) }),
+			...(signal === undefined ? {} : { signal: signal as NodeJS.Signals }),
+			timed_out: booleanValue(raw.timed_out),
+			output_limit_exceeded: booleanValue(raw.output_limit_exceeded),
+			...(maxBufferBytes === undefined ? {} : { max_buffer_bytes: maxBufferBytes, configuration_hint: configurationHint! }),
+			...(raw.stderr === undefined ? {} : { stderr: sanitizeNativeDiagnosticText(stringValue(raw.stderr)) }),
+		};
 	} catch { return undefined; }
 }
 
-function sanitizeForeignStructuredDenial(value: unknown): NativeReviewStructuredDenial {
-	const parsed = exactObject(value, ["schema", "result", "action", "reason"], ["denial"]);
-	if (parsed.schema !== "gentle-ai.review-gate-result/v1") throw new Error("invalid denial schema");
-	const result = enumString(parsed.result, ["scope-changed", "invalidated", "escalated"] as const) as NativeReviewStructuredDenial["result"];
-	const action = sanitizeNativeDiagnosticText(requiredString(parsed.action), NATIVE_REVIEW_DENIAL_TEXT_LIMIT);
-	const reason = sanitizeNativeDiagnosticText(requiredString(parsed.reason), NATIVE_REVIEW_DENIAL_TEXT_LIMIT);
-	const expectedAction = { "scope-changed": "create-new-lineage", invalidated: "explicit-maintainer-action", escalated: "stop" }[result];
-	if (action !== expectedAction || !isCanonicalProcessString(action) || !isCanonicalProcessString(reason)) throw new Error("non-canonical denial evidence");
-	const denial = parsed.denial === undefined ? undefined : (() => { const nested = exactObject(parsed.denial, ["stage", "code"]); const stage = sanitizeNativeDiagnosticText(requiredString(nested.stage), NATIVE_REVIEW_DENIAL_TEXT_LIMIT); const code = sanitizeNativeDiagnosticText(requiredString(nested.code), NATIVE_REVIEW_DENIAL_TEXT_LIMIT); if (!isCanonicalProcessString(stage) || !isCanonicalProcessString(code)) throw new Error("non-canonical denial evidence"); return { stage, code }; })();
-	return { schema: "gentle-ai.review-gate-result/v1", result, action, reason, ...(denial === undefined ? {} : { denial }) };
-}
-
-function nativeProcessDiagnostics(operation: NativeReviewOperation, code: NativeReviewErrorCode, result?: ExecFileResult): NativeReviewProcessDiagnostics {
+function nativeProcessDiagnostics(operation: NativeReviewOperation, code: NativeReviewErrorCode, result?: ExecFileResult, maxBufferBytes?: number): NativeReviewProcessDiagnostics {
+	const outputLimitExceeded = result?.outputLimitExceeded === true;
 	return {
 		operation,
 		error_code: code,
 		...(result === undefined ? {} : { exit_code: result.exitCode }),
 		...(result?.signal === null || result?.signal === undefined ? {} : { signal: result.signal }),
-		timed_out: result?.timedOut === true,
-		output_limit_exceeded: result?.outputLimitExceeded === true,
+		timed_out: !outputLimitExceeded && result?.timedOut === true,
+		output_limit_exceeded: outputLimitExceeded,
+		...(code === NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT && maxBufferBytes !== undefined
+			? { max_buffer_bytes: maxBufferBytes, configuration_hint: NATIVE_REVIEW_MAX_BUFFER_CONFIGURATION_HINT }
+			: {}),
 		...(result?.stderr.trim() ? { stderr: sanitizeNativeDiagnosticText(result.stderr) } : {}),
-		...(result === undefined ? {} : { denial: parseStructuredNativeDenial(result.stdout) }),
 	};
 }
 
@@ -857,39 +944,13 @@ function decodeLegacyReconcileAudit(value: unknown): NativeReviewRecoveryResult
 	for (const field of ["predecessor_lineage", "successor_lineage", "outcome"]) requiredString(record[field]);
 	return { record };
 }
-function decodeNativeReviewVerificationEvidence(value: unknown): NativeReviewVerificationEvidenceV2 {
-	const body = exactObject(value, ["schema", "version", "lineage_id", "authority_revision", "target_identity", "candidate_tree", "paths_digest", "paths", "ledger_ids", "raw_payload_sha256", "raw_payload_bytes", "outcome", "record_digest"]);
-	if (body.schema !== "gentle-ai.review-verification-evidence/v2") throw new Error("wrong verification evidence schema");
-	return {
-		schema: "gentle-ai.review-verification-evidence/v2",
-		// verification-evidence.schema.json pins `version` to {"const": 2} -- the
-		// NUMBER two, not the string. It was written as a string from a handoff
-		// that listed the observed field NAMES without their types.
-		version: (() => { if (body.version !== 2) throw new Error(`native verification evidence version must be the number 2, received ${JSON.stringify(body.version)}`); return 2 as const; })(),
-		lineageId: requiredString(body.lineage_id),
-		authorityRevision: requiredString(body.authority_revision),
-		targetIdentity: requiredString(body.target_identity),
-		candidateTree: requiredString(body.candidate_tree),
-		pathsDigest: requiredString(body.paths_digest),
-		paths: stringArray(body.paths),
-		// The schema requires ledger_ids to be an array, but v2.2.2 emits null when
-		// there are none. Tolerated deliberately: refusing here would reject a
-		// response the provider actually sends, and the provider violating its own
-		// published schema is its defect to fix, not a reason to break the client.
-		ledgerIds: body.ledger_ids === null || body.ledger_ids === undefined ? [] : stringArray(body.ledger_ids),
-		rawPayloadSha256: requiredString(body.raw_payload_sha256),
-		rawPayloadBytes: nonNegativeInteger(body.raw_payload_bytes),
-		outcome: enumString(body.outcome, NATIVE_REVIEW_CAPTURE_OUTCOME) as NativeReviewCaptureOutcome,
-		recordDigest: requiredString(body.record_digest),
-	};
-}
 // Unimplemented next_transition.execute.operation values must never reach
 // argv synthesis. Checked against the raw pre-decode body so an operation
 // gentle-pi does not implement (e.g. a future `dispose-result`) fails with a
 // named, typed refusal instead of a generic schema-incompatible error, and
 // before any client ever tries to build an invocation for it (Design
 // Decision #6, migrate-review-integration-v2).
-const NATIVE_REVIEW_SUPPORTED_TRANSITION_OPERATIONS = new Set(["review.start", "review.finalize", "review.recover", "review.repair", "review.validate"]);
+const NATIVE_REVIEW_SUPPORTED_TRANSITION_OPERATIONS = new Set(["review.start", "review.recover", "review.repair", "review.acknowledge-approved"]);
 function assertSupportedNextTransitionOperation(body: Record<string, unknown>): void {
 	const nextTransition = body.next_transition;
 	if (typeof nextTransition !== "object" || nextTransition === null || Array.isArray(nextTransition)) return;
@@ -903,11 +964,23 @@ function assertSupportedNextTransitionOperation(body: Record<string, unknown>):
 function decode<T>(operation: NativeReviewOperation, mutating: boolean, callback: () => T, diagnostics = nativeProcessDiagnostics(operation, NATIVE_REVIEW_ERROR_CODE.SCHEMA_INCOMPATIBLE)): T {
 	try { return callback(); } catch (error) { if (error instanceof NativeReviewCliError) throw error; throw new NativeReviewCliError(NATIVE_REVIEW_ERROR_CODE.SCHEMA_INCOMPATIBLE, operation, true, mutating, "native response is schema incompatible", { ...diagnostics, error_code: NATIVE_REVIEW_ERROR_CODE.SCHEMA_INCOMPATIBLE }); }
 }
+function decodeReviewStartResponse(value: unknown): ReviewStartV3 | ReviewStartV4 {
+	const body = object(value);
+	return body.schema === "gentle-ai.review-integration.start/v4"
+		? decodeReviewStartV4(body)
+		: decodeReviewStartV3(body);
+}
 function decodeReleaseEvidence(value: unknown): void {
 	const release = exactObject(value, ["release_tree", "configuration_hash", "generated_artifact_hash", "provenance_hash", "publication_boundary_hash", "publication_state", "evidence_freshness_hash", "evidence_freshness_state"]);
 	for (const field of ["release_tree", "configuration_hash", "generated_artifact_hash", "provenance_hash", "publication_boundary_hash", "evidence_freshness_hash"]) requiredString(release[field]);
 	if (release.publication_state !== "sealed" || release.evidence_freshness_state !== "current") throw new Error("invalid release evidence");
 }
+function decodeNonDecidingGateContext(value: unknown, expectedGate: string): NativeGateContext {
+	const context = exactObject(value, ["gate"]);
+	const gate = enumString(context.gate, NATIVE_GATE);
+	if (gate !== expectedGate) throw new Error("native non-deciding gate context does not match the requested gate");
+	return { lineageId: "", storeRevision: "", raw: context };
+}
 function decodeGateContext(value: unknown): NativeGateContext {
 	const context = exactObject(
 		value,
@@ -1000,7 +1073,7 @@ function decodeNativeReviewStatusDiagnostic(value: unknown): NativeReviewAuthori
 	return { path: requiredString(diagnostic.path), problem: requiredString(diagnostic.problem) };
 }
 function decodeNativeReviewModeStatus(value: unknown): NativeReviewModeStatus {
-	const status = exactObject(value, ["schema", "global", "clone_local", "effective", "source"], ["revision"]);
+	const status = exactObject(value, ["schema", "global", "clone_local", "effective", "source"], ["revision", "reach"]);
 	if (status.schema !== "gentle-ai.rdd-mode-status/v1") throw new Error("wrong review mode status schema");
 	return {
 		global: enumString(status.global, Object.values(NATIVE_REVIEW_MODE_VALUE)) as NativeReviewModeValue,
@@ -1008,6 +1081,7 @@ function decodeNativeReviewModeStatus(value: unknown): NativeReviewModeStatus {
 		effective: enumString(status.effective, ["on", "off"]) as "on" | "off",
 		source: enumString(status.source, Object.values(NATIVE_REVIEW_MODE_SOURCE)) as NativeReviewModeSource,
 		...(status.revision === undefined ? {} : { revision: requiredString(status.revision) }),
+		...(status.reach === undefined ? {} : { reach: enumString(status.reach, Object.values(NATIVE_REVIEW_MODE_REACH)) as NativeReviewModeReach }),
 	};
 }
 
@@ -1150,12 +1224,11 @@ function hasValidLensesRequired(action: NativeStartAction, state: string, riskLe
 	if (riskLevel === "low") return !lensesRequired;
 	if (action === NATIVE_START_ACTION.CREATED) return state === "reviewing" && lensesRequired;
 	if (action === NATIVE_START_ACTION.RESUMED) return !lensesRequired || state === "reviewing";
-	if (action === NATIVE_START_ACTION.REUSE_RECEIPT) return state === "approved" && !lensesRequired;
 	return !lensesRequired;
 }
 
-function nativeError(code: NativeReviewErrorCode, operation: NativeReviewOperation, mutating: boolean, message: string, result?: ExecFileResult, launchAttempted = true, auditRecord?: Record<string, unknown>): NativeReviewCliError {
-	return new NativeReviewCliError(code, operation, launchAttempted, mutating, message, nativeProcessDiagnostics(operation, code, result), auditRecord);
+function nativeError(code: NativeReviewErrorCode, operation: NativeReviewOperation, mutating: boolean, message: string, result?: ExecFileResult, launchAttempted = true, auditRecord?: Record<string, unknown>, maxBufferBytes?: number): NativeReviewCliError {
+	return new NativeReviewCliError(code, operation, launchAttempted, mutating, message, nativeProcessDiagnostics(operation, code, result, maxBufferBytes), auditRecord);
 }
 
 interface NativeJsonExecution {
@@ -1164,13 +1237,13 @@ interface NativeJsonExecution {
 	process: ExecFileResult;
 }
 
-export class NativeReviewCliV214 {
+class NativeReviewPlainCli {
 	private readonly adapter: ExecFileAdapter;
 	private readonly executable: string | (() => string);
 	private readonly timeoutMs: number;
 	private readonly maxBufferBytes: number;
 	private readonly cleanupDirectory: (directory: string) => Promise<void>;
-	constructor(adapter: ExecFileAdapter, executable: string | (() => string) = resolveGentleAiBinary, timeoutMs = 30_000, maxBufferBytes = 1024 * 1024, cleanupDirectory = (directory: string) => rm(directory, { recursive: true, force: true })) {
+	constructor(adapter: ExecFileAdapter, executable: string | (() => string) = resolveGentleAiBinary, timeoutMs = 30_000, maxBufferBytes = resolveNativeReviewMaxBufferBytes(), cleanupDirectory = (directory: string) => rm(directory, { recursive: true, force: true })) {
 		if (typeof executable === "string" && (!isAbsolute(executable) || executable === "gentle-ai")) throw new TypeError("Native review requires an absolute package-local executable");
 		this.adapter = adapter;
 		this.executable = executable;
@@ -1207,165 +1280,17 @@ export class NativeReviewCliV214 {
 			throw nativeError(NATIVE_REVIEW_ERROR_CODE.UNAVAILABLE, operation, mutating, "native process could not start");
 		}
 		const diagnostics = nativeProcessDiagnostics(operation, NATIVE_REVIEW_ERROR_CODE.NON_ZERO, result);
+		if (result.outputLimitExceeded) throw nativeError(NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT, operation, mutating, "native process output exceeded limit", result, true, undefined, this.maxBufferBytes);
 		if (result.timedOut) throw nativeError(NATIVE_REVIEW_ERROR_CODE.TIMEOUT, operation, mutating, "native process timed out", result);
-		if (result.outputLimitExceeded) throw nativeError(NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT, operation, mutating, "native process output exceeded limit", result);
 		if (result.signal) throw nativeError(NATIVE_REVIEW_ERROR_CODE.SIGNAL, operation, mutating, "native process was signalled", result);
-		const structuredValidateDenial = operation === NATIVE_REVIEW_OPERATION.VALIDATE && result.exitCode === 1;
 		const maintenancePartialFailure = [NATIVE_REVIEW_OPERATION.ABANDON, NATIVE_REVIEW_OPERATION.QUARANTINE_LEGACY, NATIVE_REVIEW_OPERATION.RECONCILE_AUTHORITY, NATIVE_REVIEW_OPERATION.REPAIR_LEGACY_ALIAS].includes(operation) && result.exitCode !== 0;
 		const toleratedNotice = stderrIsTolerated(result.stderr, toleratedStderr);
-		if (result.exitCode !== 0 && !structuredValidateDenial && !maintenancePartialFailure) throw nativeError(NATIVE_REVIEW_ERROR_CODE.NON_ZERO, operation, mutating, "native process failed", result);
-		if (result.stderr.trim().length > 0 && !structuredValidateDenial && !maintenancePartialFailure && !toleratedNotice) throw nativeError(NATIVE_REVIEW_ERROR_CODE.UNEXPECTED_STDERR, operation, mutating, "native process wrote stderr", result);
+		if (result.exitCode !== 0 && !maintenancePartialFailure) throw nativeError(NATIVE_REVIEW_ERROR_CODE.NON_ZERO, operation, mutating, "native process failed", result);
+		if (result.stderr.trim().length > 0 && !maintenancePartialFailure && !toleratedNotice) throw nativeError(NATIVE_REVIEW_ERROR_CODE.UNEXPECTED_STDERR, operation, mutating, "native process wrote stderr", result);
 		return { body: parseJson(result.stdout, operation, mutating, diagnostics), exitCode: result.exitCode, process: result };
 	}
 
-	private async verifyVersion(cwd: string, signal: AbortSignal | undefined, capabilities: readonly NativeCliCapability[]): Promise<keyof typeof NATIVE_CLI_CONTRACTS> {
-		let result: ExecFileResult;
-		try { result = await this.adapter({ file: this.executablePath(NATIVE_REVIEW_OPERATION.VERSION, false), arguments: ["version"], cwd, timeoutMs: this.timeoutMs, maxBufferBytes: this.maxBufferBytes, signal }); }
-		catch (error) {
-			if (error instanceof NativeReviewCliError) throw error;
-			if (error instanceof Error && error.name === "AbortError") throw nativeError(NATIVE_REVIEW_ERROR_CODE.CANCELLED, NATIVE_REVIEW_OPERATION.VERSION, false, "version process was cancelled");
-			throw nativeError(NATIVE_REVIEW_ERROR_CODE.UNAVAILABLE, NATIVE_REVIEW_OPERATION.VERSION, false, "gentle-ai is unavailable");
-		}
-		if (result.timedOut) throw nativeError(NATIVE_REVIEW_ERROR_CODE.TIMEOUT, NATIVE_REVIEW_OPERATION.VERSION, false, "version process timed out", result);
-		if (result.outputLimitExceeded) throw nativeError(NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT, NATIVE_REVIEW_OPERATION.VERSION, false, "version process output exceeded limit", result);
-		if (result.signal) throw nativeError(NATIVE_REVIEW_ERROR_CODE.SIGNAL, NATIVE_REVIEW_OPERATION.VERSION, false, "version process was signalled", result);
-		if (result.exitCode !== 0) throw nativeError(NATIVE_REVIEW_ERROR_CODE.NON_ZERO, NATIVE_REVIEW_OPERATION.VERSION, false, "version process failed", result);
-		const version = /^gentle-ai ([0-9]+\.[0-9]+\.[0-9]+)\n$/.exec(result.stdout.replace(/\r\n$/, "\n"))?.[1];
-		const contract = version === undefined ? undefined : resolvedNativeCliContract(version);
-		if (result.stderr.trim().length > 0 || contract === undefined || capabilities.some((capability) => !contract[capability])) throw nativeError(NATIVE_REVIEW_ERROR_CODE.VERSION_INCOMPATIBLE, NATIVE_REVIEW_OPERATION.VERSION, false, `native gentle-ai lacks required capabilities: expected v${GENTLE_AI_VERSION}, found v${version ?? "unparseable"}`);
-		return version as keyof typeof NATIVE_CLI_CONTRACTS;
-	}
-
-	async start(request: NativeStartRequest): Promise<NativeStartResult> {
-		if (request.baseRef !== undefined && !isCanonicalProcessString(request.baseRef)) throw new TypeError("Native START baseRef must be a non-empty, trimmed, NUL-free string");
-		if (request.committedOnly !== undefined && typeof request.committedOnly !== "boolean") throw new TypeError("Native START committedOnly must be a boolean when supplied");
-		if (request.baseRef !== undefined && request.committedOnly !== true) throw new TypeError("Native START baseRef requires explicit committedOnly acknowledgement");
-		if (request.baseRef === undefined && request.committedOnly !== undefined) throw new TypeError("Native START committedOnly requires an explicit baseRef");
-		const version = await this.verifyVersion(request.cwd, request.signal, ["start"]);
-		const toleratedStderr = resolvedNativeCliContract(version)?.mode === true ? REVIEW_CONSENT_NOTICES : [];
-		const { body: result } = await this.execute(NATIVE_REVIEW_OPERATION.START, request.cwd, ["review", "start", "--cwd", request.cwd, ...(request.baseRef === undefined ? [] : ["--base-ref", request.baseRef, "--committed-only"]), ...(request.lineageId ? ["--lineage", request.lineageId] : []), ...(request.policyPath ? ["--policy", request.policyPath] : []), ...(request.focus ? ["--focus", request.focus] : [])], true, request.signal, toleratedStderr);
-		return decode(NATIVE_REVIEW_OPERATION.START, true, () => {
-			// `target_identity` and `lens_bindings` are real, unconditionally-present
-			// fields on gentle-ai's plain (non-negotiated) `review start` JSON output
-			// (confirmed against the pinned v2.1.11 Go source and live against a dev
-			// build during Phase 6 dev-binary ground-truthing, organic-rdd-parity) —
-			// tolerated here but not consumed: Pi's negotiated-contract client
-			// (NativeReviewCliV216, the production default) carries lineage/target
-			// identity through its own `review-integration/v1` decoder instead.
-			const body = exactObject(result, ["operation", "lineage_id", "state", "risk_level", "selected_lenses", "changed_files", "changed_lines", "correction_budget", "action", "lenses_required", "projection"], ["risk_evidence", "hint", "target_identity", "lens_bindings"]);
-			if (body.operation !== "review/start" || body.projection !== "workspace" || !(NATIVE_FINALIZE_STATE as readonly string[]).includes(stringValue(body.state))) throw new Error("wrong start discriminator");
-			const lineageId = requiredString(body.lineage_id);
-			if (request.lineageId && lineageId !== request.lineageId) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native start lineage mismatch");
-			const riskLevel = requiredString(body.risk_level);
-			const action = enumString(body.action, NATIVE_START_ACTION_VALUES) as NativeStartAction;
-			const lensesRequired = booleanValue(body.lenses_required);
-			const selectedLenses = decodeSelectedLenses(body.selected_lenses, riskLevel, lensesRequired);
-			if (
-				!(NATIVE_RISK_LEVEL as readonly string[]).includes(riskLevel) ||
-				selectedLenses.some((lens) => !(NATIVE_REVIEW_LENS as readonly string[]).includes(lens)) ||
-				!hasCanonicalSelectedLenses(riskLevel, selectedLenses) ||
-				!hasValidLensesRequired(action, body.state as string, riskLevel, lensesRequired)
-			) throw new Error("unknown or contradictory start enum");
-			return {
-				lineageId, state: body.state as NativeStartResult["state"], riskLevel, selectedLenses, changedFiles: nonNegativeInteger(body.changed_files), changedLines: nonNegativeInteger(body.changed_lines), correctionBudget: nonNegativeInteger(body.correction_budget), action, lensesRequired,
-				...(body.risk_evidence === undefined ? {} : { riskEvidence: stringArray(body.risk_evidence) }),
-				...(body.hint === undefined ? {} : { hint: requiredString(body.hint) }),
-			};
-		});
-	}
-
-	private async stageDocument(directory: string, name: string, document: unknown): Promise<string> {
-		const path = join(directory, `${name}.json`);
-		await writeFile(path, JSON.stringify(document), { encoding: "utf8", mode: 0o600 });
-		await chmod(path, 0o600);
-		return path;
-	}
-	private async stageEvidence(directory: string, evidence: string): Promise<string> {
-		const path = join(directory, "evidence.txt");
-		await writeFile(path, evidence, { encoding: "utf8", mode: 0o600 });
-		await chmod(path, 0o600);
-		return path;
-	}
-
-	async finalize(request: NativeFinalizeRequest): Promise<NativeFinalizeResult> {
-		if (request.evidenceDocument !== undefined && (typeof request.evidenceDocument !== "string" || request.evidenceDocument.length === 0)) throw new TypeError("Native FINALIZE evidence must contain at least one byte");
-		await this.verifyVersion(request.cwd, request.signal, ["finalize"]);
-		const needsStaging = request.lensResults !== undefined || request.refuterDocument !== undefined || request.validationDocument !== undefined || request.evidenceDocument !== undefined;
-		const directory = needsStaging ? await mkdtemp(join(tmpdir(), "gentle-ai-finalize-")) : undefined;
-		try {
-			if (directory) await chmod(directory, 0o700);
-			const resultFiles = directory && request.lensResults ? await Promise.all(request.lensResults.map((entry, index) => this.stageDocument(directory, `result-${index}`, entry.document))) : request.resultFiles ?? [];
-			const refuterFile = directory && request.refuterDocument !== undefined ? await this.stageDocument(directory, "refuter", request.refuterDocument) : request.refuterFile;
-			const validationFile = directory && request.validationDocument !== undefined ? await this.stageDocument(directory, "validation", request.validationDocument) : request.validationFile;
-			const evidenceFile = directory && request.evidenceDocument !== undefined ? await this.stageEvidence(directory, request.evidenceDocument) : request.evidenceFile;
-			const { body: result } = await this.execute(NATIVE_REVIEW_OPERATION.FINALIZE, request.cwd, ["review", "finalize", "--cwd", request.cwd, ...(request.lineageId ? ["--lineage", request.lineageId] : []), ...resultFiles.flatMap((path) => ["--result", path]), ...(refuterFile ? ["--refuter", refuterFile] : []), ...(request.correctionLines === undefined ? [] : ["--correction-lines", String(request.correctionLines)]), ...(validationFile ? ["--validation", validationFile] : []), ...(evidenceFile ? ["--evidence", evidenceFile] : []), ...(request.failed ? ["--failed"] : [])], true, request.signal);
-			return decode(NATIVE_REVIEW_OPERATION.FINALIZE, true, () => {
-				const body = exactObject(result, ["operation", "lineage_id", "state", "action", "store_revision"], ["receipt_path"]);
-				if (body.operation !== "review/finalize") throw new Error("wrong finalize discriminator");
-				const lineageId = requiredString(body.lineage_id);
-				if (request.lineageId && lineageId !== request.lineageId) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.FINALIZE, true, "native finalize lineage mismatch");
-				const state = requiredString(body.state);
-				if (!(NATIVE_FINALIZE_STATE as readonly string[]).includes(state)) throw new Error("unknown finalize state");
-				return { lineageId, state, action: requiredString(body.action), storeRevision: requiredString(body.store_revision), ...(body.receipt_path === undefined ? {} : { receiptPath: requiredString(body.receipt_path) }) };
-			});
-		} finally { if (directory) await this.cleanupDirectory(directory).catch(() => undefined); }
-	}
-
-	async validate(request: NativeValidateRequest): Promise<NativeValidateResult> {
-		await this.verifyVersion(request.cwd, request.signal, ["validate"]);
-		const execution = await this.execute(NATIVE_REVIEW_OPERATION.VALIDATE, request.cwd, ["review", "validate", "--gate", request.gate, "--cwd", request.cwd, ...(request.lineageId ? ["--lineage", request.lineageId] : []), ...(request.flags ?? [])], false, request.signal);
-		return decode(NATIVE_REVIEW_OPERATION.VALIDATE, false, () => {
-			const body = exactObject(execution.body, ["schema", "result", "allowed", "action", "reason", "context"], ["delivery"]);
-			const gateResult = enumString(body.result, NATIVE_GATE_RESULT) as NativeValidateResult["result"];
-			const action = sanitizeNativeDiagnosticText(requiredString(body.action), NATIVE_REVIEW_DENIAL_TEXT_LIMIT);
-			const reason = sanitizeNativeDiagnosticText(requiredString(body.reason), NATIVE_REVIEW_DENIAL_TEXT_LIMIT);
-			// `delivery` (Design Decision #9, organic-rdd-parity) is an alternate
-			// discriminator: when present it must be the single literal
-			// "disabled/unmanaged" (gentle-ai's RDDDeliveryDisabledUnmanaged — the
-			// kill switch is off and no receipt governs the candidate), paired
-			// exactly with result:invalidated, allowed:false, action:repository-policy,
-			// and exit 0 — never the strict continue/create-new-lineage/
-			// explicit-maintainer-action/stop pairing used when delivery is absent.
-			const delivery = body.delivery === undefined ? undefined : (enumString(body.delivery, ["disabled/unmanaged"]) as NativeValidateResult["delivery"]);
-			if (body.schema !== "gentle-ai.review-gate-result/v1" || !isCanonicalProcessString(action) || !isCanonicalProcessString(reason)) throw new Error("wrong validate discriminator");
-			if (delivery !== undefined) {
-				if (gateResult !== "invalidated" || body.allowed !== false || action !== "repository-policy" || execution.exitCode !== 0) throw new Error("wrong validate delivery discriminator");
-			} else {
-				const expectedAction = { allow: "continue", "scope-changed": "create-new-lineage", invalidated: "explicit-maintainer-action", escalated: "stop" }[gateResult];
-				const expectedExitCode = gateResult === "allow" ? 0 : 1;
-				if (typeof body.allowed !== "boolean" || body.allowed !== (gateResult === "allow") || action !== expectedAction || execution.exitCode !== expectedExitCode) throw new Error("wrong validate discriminator");
-			}
-			const gateContext = decodeGateContext(body.context);
-			const returnedGate = gateContext.raw.gate;
-			if (returnedGate !== request.gate && (gateResult === "allow" || returnedGate !== "")) throw new Error("native gate context does not match the requested gate");
-			if (request.lineageId && returnedGate !== "" && gateContext.lineageId !== request.lineageId) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.VALIDATE, false, "native gate lineage mismatch");
-			return { allowed: body.allowed as boolean, result: gateResult, action, reason, gateContext, ...(delivery === undefined ? {} : { delivery }) };
-		});
-	}
-
-	async bindSdd(request: NativeBindSddRequest): Promise<NativeBindSddResult> {
-		await this.verifyVersion(request.cwd, request.signal, ["bindSdd"]);
-		const { body: result } = await this.execute(NATIVE_REVIEW_OPERATION.BIND_SDD, request.cwd, ["review", "bind-sdd", "--cwd", request.cwd, "--change", request.change, "--lineage", request.lineage, `--expected-binding-revision=${request.expectedBindingRevision}`], true, request.signal);
-		return decode(NATIVE_REVIEW_OPERATION.BIND_SDD, true, () => {
-			const body = exactObject(result, ["schema", "revision", "change", "lineage", "authority_revision", "receipt_hash", "gate_context"]);
-			if (body.schema !== "gentle-ai.sdd-review-binding/v1" || body.change !== request.change || body.lineage !== request.lineage) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.BIND_SDD, true, "native binding identity mismatch");
-			const receiptHash = requiredString(body.receipt_hash);
-			const gateContext = decodeGateContext(body.gate_context);
-			const authorityRevision = requiredString(body.authority_revision);
-			if (gateContext.lineageId !== request.lineage || gateContext.storeRevision !== authorityRevision || gateContext.raw.gate !== "post-apply") throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.BIND_SDD, true, "native binding gate mismatch");
-			return {
-				revision: requiredString(body.revision),
-				change: requiredString(body.change),
-				lineage: requiredString(body.lineage),
-				authorityRevision,
-				receiptHash,
-				gateContext,
-			};
-		});
-	}
-
 	async reviewStatus(request: NativeReviewStatusRequest): Promise<NativeReviewStatusResult> {
-		await this.verifyVersion(request.cwd, request.signal, ["status", "inventory"]);
 		const { body: result } = await this.execute(NATIVE_REVIEW_OPERATION.STATUS, request.cwd, ["review", "status", "--cwd", request.cwd], false, request.signal);
 		const status = decode(NATIVE_REVIEW_OPERATION.STATUS, false, () => decodeNativeReviewStatus(result));
 		if (!await repositoriesMatch(request.cwd, status.repository)) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.STATUS, false, "native review status repository mismatch");
@@ -1379,7 +1304,6 @@ export class NativeReviewCliV214 {
 	// never mutates the operator's global gentle-ai state across other clones.
 	async reviewMode(request: NativeReviewModeRequest): Promise<NativeReviewModeResult> {
 		const cwd = await canonicalNativeReviewCwd(request.cwd);
-		await this.verifyVersion(cwd, request.signal, ["mode"]);
 		const mutating = request.operation !== NATIVE_REVIEW_MODE_OPERATION.STATUS;
 		const { body } = await this.execute(
 			NATIVE_REVIEW_OPERATION.MODE,
@@ -1391,77 +1315,10 @@ export class NativeReviewCliV214 {
 		return decode(NATIVE_REVIEW_OPERATION.MODE, mutating, () => decodeNativeReviewMode(body, request.operation));
 	}
 
-	async sddStatus(request: NativeSddStatusRequest): Promise<NativeSddStatusResult> {
-		await this.verifyVersion(request.cwd, request.signal, ["sddStatus"]);
-		const { body: result } = await this.execute(NATIVE_REVIEW_OPERATION.SDD_STATUS, request.cwd, ["sdd-status", request.change, "--cwd", request.cwd, "--json", "--instructions"], false, request.signal);
-		return decode(NATIVE_REVIEW_OPERATION.SDD_STATUS, false, () => {
-			const body = exactObject(result, ["schemaName", "schemaVersion", "changeName", "artifactStore", "planningHome", "changeRoot", "artifactPaths", "contextFiles", "artifacts", "taskProgress", "dependencies", "applyState", "actionContext", "relationships", "remediationState", "nextRecommended", "blockedReasons"], ["reviewGate", "reviewTransaction", "phaseInstructions"]);
-			if (body.schemaName !== "gentle-ai.sdd-status" || body.schemaVersion !== 1 || body.changeName !== request.change || !["openspec", "engram", "none"].includes(body.artifactStore as string) || !["blocked", "all_done", "ready"].includes(body.applyState as string)) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.SDD_STATUS, false, "native status identity mismatch");
-			const paths = ["proposal", "specs", "design", "tasks", "applyProgress", "verifyReport", "reviewPolicy", "reviewLedger", "reviewReceipt", "reviewBundle", "reviewContext", "reviewState"];
-			const pathMap = (value: unknown) => { const parsed = exactObject(value, paths); for (const path of paths) stringArray(parsed[path]); };
-			const planningHome = exactObject(body.planningHome, ["mode", "path"]);
-			if (planningHome.mode !== "repo-local") throw new Error("invalid planning home");
-			requiredString(planningHome.path); requiredString(body.changeRoot); pathMap(body.artifactPaths); pathMap(body.contextFiles);
-			const artifactStates = paths.filter((path) => path !== "reviewPolicy" || body.artifactStore === NATIVE_SDD_ARTIFACT_STORE.ENGRAM);
-			const artifacts = exactObject(body.artifacts, artifactStates);
-			for (const path of artifactStates) if (!Object.values(NATIVE_SDD_ARTIFACT_STATE).includes(artifacts[path] as NativeSddArtifactState)) throw new Error("invalid artifact state");
-			const taskProgress = exactObject(body.taskProgress, ["total", "completed", "pending", "allComplete"]);
-			const total = nonNegativeInteger(taskProgress.total), completed = nonNegativeInteger(taskProgress.completed), pending = nonNegativeInteger(taskProgress.pending);
-			if (typeof taskProgress.allComplete !== "boolean" || completed + pending !== total || taskProgress.allComplete !== (pending === 0)) throw new Error("invalid task progress");
-			const dependencies = exactObject(body.dependencies, ["proposal", "specs", "design", "tasks", "apply", "verify", "archive"]);
-			for (const phase of ["proposal", "specs", "design", "tasks", "apply", "verify", "archive"]) if (!["blocked", "ready", "all_done"].includes(dependencies[phase] as string)) throw new Error("invalid dependency state");
-			const actionContext = exactObject(body.actionContext, ["mode", "workspaceRoot", "allowedEditRoots"]);
-			if (actionContext.mode !== "repo-local" || requiredString(actionContext.workspaceRoot).length === 0 || stringArray(actionContext.allowedEditRoots).length === 0) throw new Error("invalid action context");
-			const relationships = exactObject(body.relationships, ["dependsOn", "supersedes", "amends", "conflictsWith", "sameDomainActiveChanges"]);
-			for (const field of ["dependsOn", "supersedes", "amends", "conflictsWith", "sameDomainActiveChanges"]) stringArray(relationships[field]);
-			const remediation = exactObject(body.remediationState, ["required", "complete", "failedEvidenceRevision", "lineageId", "generation", "fixBatch", "reason"], ["correctionBudget"]);
-			if (typeof remediation.required !== "boolean" || typeof remediation.complete !== "boolean" || ["failedEvidenceRevision", "lineageId", "reason"].some((field) => typeof remediation[field] !== "string")) throw new Error("invalid remediation state");
-			nonNegativeInteger(remediation.generation); nonNegativeInteger(remediation.fixBatch);
-			if (remediation.correctionBudget !== undefined) nonNegativeInteger(remediation.correctionBudget);
-			let reviewGateResult: string | undefined;
-			let reviewGateDelivery: string | undefined;
-			if (body.reviewGate !== undefined) {
-				// `delivery` (present since 09e4b14c, gentle-ai v2.2.0+) is emitted
-				// when the kill switch is off: gentle-ai's status struct carries
-				// `Delivery` with `json:"delivery,omitempty"`, so an exact-key decode
-				// without it rejects that payload outright. Pre-existing bug fix
-				// (Phase 13.13, migrate-review-integration-v2).
-				const gate = exactObject(body.reviewGate, ["result", "reason"], ["delivery"]);
-				reviewGateResult = enumString(gate.result, NATIVE_GATE_RESULT); requiredString(gate.reason);
-				if (gate.delivery !== undefined) reviewGateDelivery = enumString(gate.delivery, ["disabled/unmanaged"]);
-			}
-			if (body.reviewTransaction !== undefined) decodeReviewTransaction(body.reviewTransaction);
-			if (body.phaseInstructions !== undefined) {
-				const instructions = exactObject(body.phaseInstructions, ["apply", "verify", "remediate", "archive"]);
-				for (const phase of ["apply", "verify", "remediate", "archive"]) stringArray(instructions[phase]);
-			}
-			const nextRecommended = requiredString(body.nextRecommended);
-			if (!(NATIVE_SDD_NEXT_ACTION as readonly string[]).includes(nextRecommended)) throw new Error("unknown SDD next action");
-			const blockedReasons = stringArray(body.blockedReasons);
-			return {
-				...body,
-				artifactStore: body.artifactStore as NativeSddArtifactStore,
-				artifacts: artifacts as unknown as NativeSddArtifactStates,
-				nextRecommended,
-				ready:
-					(NATIVE_SDD_POST_REVIEW_ACTION as readonly string[]).includes(nextRecommended) &&
-					blockedReasons.length === 0 &&
-					// With the kill switch off, the gate result can never become
-					// "allow" (delivery follows ordinary repository policy instead) —
-					// gated only on `result === "allow"` this deadlocked `ready`
-					// forever, the same deadlock gentle-ai fixed upstream in 2c18fa10.
-					// `disabled/unmanaged` delivery is the legitimate non-blocking
-					// terminal state and must also unblock readiness.
-					(reviewGateResult === "allow" || reviewGateDelivery === "disabled/unmanaged"),
-			};
-		});
-	}
-
 	async reclaim(request: NativeReviewReclaimRequest): Promise<NativeReviewRecoveryResult> {
 		for (const [name, value] of [["lineage", request.lineage], ["actor", request.actor], ["reason", request.reason]] as const) {
 			if (!isCanonicalProcessString(value)) throw new TypeError(`Native RECLAIM ${name} must be a non-empty, trimmed, NUL-free string`);
 		}
-		await this.verifyVersion(request.cwd, request.signal, ["reclaim"]);
 		const { body } = await this.execute(NATIVE_REVIEW_OPERATION.RECLAIM, request.cwd, ["review", "reclaim", "--cwd", request.cwd, "--lineage", request.lineage, "--actor", request.actor, "--reason", request.reason], true, request.signal);
 		return { record: body };
 	}
@@ -1482,7 +1339,6 @@ export class NativeReviewCliV214 {
 			throw new TypeError("Native RECOVER maintainerAuthorization must be a non-empty LF-only binding");
 		}
 		if (!(NATIVE_REVIEW_RECOVER_DISPOSITION as readonly string[]).includes(request.disposition)) throw new TypeError("Native RECOVER disposition must be scope_changed, invalidated, or escalated");
-		await this.verifyVersion(request.cwd, request.signal, ["recover"]);
 		const { body } = await this.execute(NATIVE_REVIEW_OPERATION.RECOVER, request.cwd, [
 			"review", "recover", "--cwd", request.cwd,
 			"--predecessor-lineage", request.predecessorLineage,
@@ -1500,8 +1356,11 @@ export class NativeReviewCliV214 {
 		for (const [name, value] of [["lineage", request.lineage], ["expectedRevision", request.expectedRevision], ["snapshotIdentity", request.snapshotIdentity], ["actor", request.actor], ["reason", request.reason]] as const) {
 			if (!isCanonicalProcessString(value)) throw new TypeError(`Native ABANDON ${name} must be a non-empty, trimmed, NUL-free string`);
 		}
-		if (request.maintainerAuthorization !== nativeReviewAbandonAuthorization(request)) throw new TypeError("Native ABANDON maintainerAuthorization must match the exact lineage, revision, snapshot, actor, and reason binding");
-		await this.verifyVersion(request.cwd, request.signal, ["abandon"]);
+		if (!Array.isArray(request.capturedLensResults) || request.capturedLensResults.some((entry) => !isCanonicalProcessString(entry))) throw new TypeError("Native ABANDON capturedLensResults must be an array of non-empty, trimmed, NUL-free strings");
+		for (const [name, value] of [["findingsPresent", request.findingsPresent], ["evidenceRecordsPresent", request.evidenceRecordsPresent]] as const) {
+			if (typeof value !== "boolean") throw new TypeError(`Native ABANDON ${name} must be a boolean`);
+		}
+		if (request.maintainerAuthorization !== nativeReviewAbandonAuthorization(request)) throw new TypeError("Native ABANDON maintainerAuthorization must match the exact lineage, revision, snapshot, reason, discarded-work, and actor binding");
 		const execution = await this.execute(NATIVE_REVIEW_OPERATION.ABANDON, request.cwd, [
 			"review", "abandon", "--cwd", request.cwd,
 			"--lineage", request.lineage,
@@ -1521,7 +1380,6 @@ export class NativeReviewCliV214 {
 		}
 		if (request.diagnostic !== NATIVE_REVIEW_LEGACY_QUARANTINE.DIAGNOSTIC || request.disposition !== NATIVE_REVIEW_LEGACY_QUARANTINE.DISPOSITION) throw new TypeError("Native QUARANTINE_LEGACY supports only the published malformed freeze-findings diagnostic and disposition");
 		if (request.maintainerAuthorization !== nativeReviewLegacyQuarantineAuthorization(request)) throw new TypeError("Native QUARANTINE_LEGACY maintainerAuthorization must match the exact repository, lineage, revision, diagnostic, disposition, actor, and reason binding");
-		await this.verifyVersion(request.cwd, request.signal, ["quarantineLegacy"]);
 		const execution = await this.execute(NATIVE_REVIEW_OPERATION.QUARANTINE_LEGACY, request.cwd, [
 			"review", "quarantine-legacy", "--cwd", request.cwd,
 			"--lineage", request.lineage,
@@ -1553,7 +1411,6 @@ export class NativeReviewCliV214 {
 		if (request.maintainerAuthorization !== expectedAuthorization) {
 			throw new TypeError("Native RECONCILE_AUTHORITY maintainerAuthorization must match the exact target and revision binding");
 		}
-		const version = await this.verifyVersion(request.cwd, request.signal, ["reconcileAuthority"]);
 		const execution = await this.execute(NATIVE_REVIEW_OPERATION.RECONCILE_AUTHORITY, request.cwd, [
 			"review", "reconcile-authority", "--cwd", request.cwd,
 			"--predecessor-lineage", request.predecessorLineage,
@@ -1564,9 +1421,7 @@ export class NativeReviewCliV214 {
 			"--reason", request.reason,
 			"--maintainer-authorization", request.maintainerAuthorization,
 		], true, request.signal);
-		const result = decode(NATIVE_REVIEW_OPERATION.RECONCILE_AUTHORITY, true, () => version === "2.1.8"
-			? decodeLegacyReconcileAudit(execution.body)
-			: decodeNativeMaintenanceResult(execution.body, NATIVE_REVIEW_OPERATION.RECONCILE_AUTHORITY));
+		const result = decode(NATIVE_REVIEW_OPERATION.RECONCILE_AUTHORITY, true, () => decodeNativeMaintenanceResult(execution.body, NATIVE_REVIEW_OPERATION.RECONCILE_AUTHORITY));
 		if (execution.exitCode !== 0) throw nativeError(NATIVE_REVIEW_ERROR_CODE.NON_ZERO, NATIVE_REVIEW_OPERATION.RECONCILE_AUTHORITY, true, "native authority reconciliation partially failed", execution.process, true, result.record);
 		return result;
 	}
@@ -1577,7 +1432,6 @@ export class NativeReviewCliV214 {
 		}
 		if (request.diagnostic !== NATIVE_REVIEW_LEGACY_ALIAS_REPAIR.DIAGNOSTIC || request.disposition !== NATIVE_REVIEW_LEGACY_ALIAS_REPAIR.DISPOSITION) throw new TypeError("Native REPAIR_LEGACY_ALIAS supports only the published historical alias diagnostic and disposition");
 		if (request.maintainerAuthorization !== nativeReviewLegacyAliasRepairAuthorization(request)) throw new TypeError("Native REPAIR_LEGACY_ALIAS maintainerAuthorization must match the exact repository, lineage, revision, diagnostic, disposition, actor, and reason binding");
-		await this.verifyVersion(request.cwd, request.signal, ["repairLegacyAlias"]);
 		const execution = await this.execute(NATIVE_REVIEW_OPERATION.REPAIR_LEGACY_ALIAS, request.cwd, [
 			"review", "repair-legacy-alias", "--cwd", request.cwd,
 			"--lineage", request.lineage,
@@ -1594,14 +1448,17 @@ export class NativeReviewCliV214 {
 	}
 }
 
-export function nativeReviewAbandonAuthorization(request: Pick<NativeReviewAbandonRequest, "lineage" | "expectedRevision" | "snapshotIdentity" | "actor" | "reason">): string {
+export function nativeReviewAbandonAuthorization(request: Pick<NativeReviewAbandonRequest, "lineage" | "expectedRevision" | "snapshotIdentity" | "capturedLensResults" | "findingsPresent" | "evidenceRecordsPresent" | "actor" | "reason">): string {
 	return [
-		"gentle-ai.review-abandon-authorization/v1",
+		"gentle-ai.review-abandon-authorization/v2",
 		`lineage=${request.lineage}`,
 		`revision=${request.expectedRevision}`,
 		`snapshot_identity=${request.snapshotIdentity}`,
-		`actor=${request.actor}`,
 		`reason=${request.reason}`,
+		`captured_lens_results=${request.capturedLensResults.join(",")}`,
+		`findings_present=${request.findingsPresent}`,
+		`evidence_records_present=${request.evidenceRecordsPresent}`,
+		`actor=${request.actor.trim()}`,
 	].join("\n");
 }
 
@@ -1618,6 +1475,32 @@ export function nativeReviewLegacyQuarantineAuthorization(request: Pick<NativeRe
 	].join("\n");
 }
 
+/**
+ * The exact native `gentle-ai.review-recovery-authorization/v1` binding for one
+ * recovery edge.
+ *
+ * Native `review recover` accepts a caller-supplied authorization only when it
+ * reproduces this binding byte for byte, because it is copied verbatim into the
+ * recovery provenance and read afterwards as a maintainer attestation. Pi
+ * therefore derives it from freshly read native target status and never
+ * forwards a caller-supplied one: a wrong binding is worse than an absent one,
+ * since an absent field cannot lie about who approved what.
+ *
+ * `targetIdentity` is the live target identity the provider itself publishes in
+ * the `review.recover` eligibility binding (`status.target_identity`), which is
+ * the identity the successor's initial snapshot takes.
+ */
+export function nativeReviewRecoverAuthorization(request: Pick<NativeReviewRecoverRequest, "predecessorLineage" | "expectedPredecessorRevision" | "actor" | "reason"> & { targetIdentity: string }): string {
+	return [
+		"gentle-ai.review-recovery-authorization/v1",
+		`predecessor_lineage=${request.predecessorLineage}`,
+		`predecessor_revision=${request.expectedPredecessorRevision}`,
+		`target_identity=${request.targetIdentity}`,
+		`actor=${request.actor.trim()}`,
+		`reason=${request.reason.trim()}`,
+	].join("\n");
+}
+
 export function nativeReviewReconcileAuthorization(request: Pick<NativeReviewReconcileAuthorityRequest, "predecessorLineage" | "expectedPredecessorRevision" | "successorLineage" | "expectedSuccessorRevision" | "actor" | "reason" | "anomalies">): string {
 	return [
 		"gentle-ai.review-reconcile-authorization/v1",
@@ -1658,15 +1541,16 @@ export class NativeReviewIntegrationError extends Error {
 	}
 }
 
-// Raised when negotiated START answers `consent/v2` (action:
+// Raised when negotiated START answers a consent question (`consent/v2` from
+// the pinned line, `consent/v3` from gentle-ai >= 2.3.0; action:
 // "consent_required") instead of `start/v3`. The provider has frozen no
 // authority yet: Pi must relay this complete candidate-scoped question and may
 // answer only through one of the exact invocations carried by the envelope.
 export class NativeReviewConsentRequiredError extends Error {
-	readonly consent: ReviewConsentV2;
+	readonly consent: ReviewConsentEnvelope;
 	readonly launchAttempted = true;
 	readonly mutationOutcome = "none";
-	constructor(consent: ReviewConsentV2) {
+	constructor(consent: ReviewConsentEnvelope) {
 		super(consent.headline);
 		this.name = "NativeReviewConsentRequiredError";
 		this.consent = consent;
@@ -1750,7 +1634,44 @@ function exactConsentOption(arguments_: readonly string[], name: string): string
 	return values[0]!;
 }
 
-function consentInvocationArguments(request: NativeReviewConsentAnswerRequest): readonly string[] {
+// A Pi consent envelope is bound to Pi only when every exact provider replay
+// path carries exactly one `--agent pi` option. The outer envelope agent alone
+// cannot bind an omitted, embedded, duplicated, or conflicting invocation.
+function validatePiConsentChoiceAgentBindings(consent: ReviewConsentEnvelope): void {
+	if (!("agent" in consent) || consent.agent !== "pi") return;
+	for (const choice of consent.choices) {
+		const arguments_ = splitNativeConsentInvocation(choice.invocation).slice(1);
+		if (exactConsentOption(arguments_, "--agent") !== "pi") {
+			throw new NativeReviewConsentBindingError("consent-invocation-agent-changed", "Native Pi consent invocation agent binding changed");
+		}
+	}
+}
+
+function optionalConsentLineageOption(arguments_: readonly string[]): string | undefined {
+	const values: string[] = [];
+	for (let index = 0; index < arguments_.length; index += 1) {
+		const token = arguments_[index]!;
+		if (token === "--lineage") {
+			const value = arguments_[index + 1];
+			if (value === undefined || value.startsWith("--")) throw new NativeReviewConsentBindingError("consent-invocation-option-invalid", "Native consent invocation --lineage is missing its value");
+			values.push(value);
+			index += 1;
+		} else if (token.startsWith("--lineage=")) values.push(token.slice("--lineage=".length));
+	}
+	if (values.length > 1) throw new NativeReviewConsentBindingError("consent-invocation-option-invalid", "Native consent invocation permits at most one --lineage");
+	if (values.length === 0) return undefined;
+	const lineageId = values[0]!;
+	if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(lineageId)) throw new NativeReviewConsentBindingError("consent-invocation-option-invalid", "Native consent invocation --lineage is malformed");
+	return lineageId;
+}
+
+interface ConsentInvocation {
+	arguments_: readonly string[];
+	lineageId?: string;
+}
+
+function consentInvocationArguments(request: NativeReviewConsentAnswerRequest): ConsentInvocation {
+	validatePiConsentChoiceAgentBindings(request.consent);
 	const choice = request.consent.choices.find((candidate) => candidate.answer === request.answer);
 	if (choice === undefined) throw new NativeReviewConsentBindingError("consent-answer-unknown", "Native consent answer must be granted or declined");
 	const words = splitNativeConsentInvocation(choice.invocation);
@@ -1760,8 +1681,9 @@ function consentInvocationArguments(request: NativeReviewConsentAnswerRequest):
 	if (exactConsentOption(arguments_, "--cwd") !== request.cwd) throw new NativeReviewConsentBindingError("consent-invocation-cwd-changed", "Native consent invocation repository binding changed");
 	if (exactConsentOption(arguments_, "--target") !== request.consent.targetIdentity) throw new NativeReviewConsentBindingError("consent-invocation-target-changed", "Native consent invocation target binding changed");
 	if (exactConsentOption(arguments_, "--projection") !== request.consent.projection) throw new NativeReviewConsentBindingError("consent-invocation-projection-changed", "Native consent invocation projection binding changed");
+	const lineageId = optionalConsentLineageOption(arguments_);
 	if (exactConsentOption(arguments_, "--consent") !== request.answer || arguments_.at(-1) !== request.answer) throw new NativeReviewConsentBindingError("consent-invocation-answer-changed", "Native consent invocation answer binding changed");
-	return arguments_;
+	return { arguments_, ...(lineageId === undefined ? {} : { lineageId }) };
 }
 
 function decodeDeclinedConsentStart(value: unknown, expected: NativeReviewConsentAnswerRequest): NativeReviewConsentDeclinedResult {
@@ -1784,71 +1706,71 @@ function decodeDeclinedConsentStart(value: unknown, expected: NativeReviewConsen
 	};
 }
 
-type NativeExecutableDigestResolver = (path: string) => string;
-const nativeCapabilitiesByDigest = new Map<string, Promise<ReviewCapabilitiesV2>>();
-
-export function clearNativeReviewCapabilitiesCacheForTesting(): void {
-	nativeCapabilitiesByDigest.clear();
-}
-
-function defaultExecutableDigest(path: string): string {
-	const before = statSync(path);
-	const digest = createHash("sha256").update(readFileSync(path)).digest("hex");
-	const after = statSync(path);
-	if (
-		before.dev !== after.dev ||
-		before.ino !== after.ino ||
-		before.size !== after.size ||
-		before.mtimeMs !== after.mtimeMs
-	) throw new Error("native review executable changed during capability verification");
-	return digest;
-}
-
 interface NegotiatedExecution {
 	body: Record<string, unknown>;
 	exitCode: number;
+	// True only for a zero-exit bodyless operation that printed nothing: the
+	// pinned silent acknowledgement burn. A body is never synthesized for it.
+	silent?: true;
 }
 
 function decodeNativeAdmittedResultManifest(value: unknown): NativeReviewAdmittedResultManifest {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("native capture-result manifest must be an object");
+	// The admission answer routes through the exact-identity forward decoder
+	// (decoder-freshness discipline): the complete live envelope — identity
+	// constants, binding fields, and the exactly-one-locator rule — is
+	// validated before anything is handed to FINALIZE, and an unknown field
+	// grown by gentle-ai main is rejected instead of silently dropped.
+	const artifact = decodeReviewResultArtifactV2(value);
+	return Object.freeze({
+		schema: artifact.schema,
+		subjectHash: artifact.subjectHash,
+		admissionDecision: artifact.admissionDecision,
+		lens: artifact.lens,
+		...(artifact.path === undefined ? {} : { path: artifact.path }),
+		...(artifact.reference === undefined ? {} : { reference: artifact.reference }),
+	});
+}
+
+// gentle-pi#311 P4-roles: the strict acknowledgement for one executed
+// provider role vector. The immutable verdict bytes live in the Go-owned
+// compact store slot; this envelope only names the binding the capture
+// proved, so anything beyond that exact shape is refused.
+function decodeNativeProviderRoleCaptureArtifact(value: unknown): NativeReviewProviderRoleCaptureArtifact {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("native provider role capture artifact must be an object");
 	const body = value as Record<string, unknown>;
+	const allowed = new Set(["schema", "lineage_id", "target_identity", "role", "captured"]);
+	for (const key of Object.keys(body)) if (!allowed.has(key)) throw new TypeError(`native provider role capture artifact carries unexpected key ${key}`);
 	const text = (key: string): string => {
 		const found = body[key];
-		if (typeof found !== "string" || found.trim() !== found || found.length === 0) throw new TypeError(`native capture-result manifest ${key} must be a non-empty trimmed string`);
+		if (typeof found !== "string" || found.trim() !== found || found.length === 0) throw new TypeError(`native provider role capture artifact ${key} must be a non-empty trimmed string`);
 		return found;
 	};
-	const schema = text("schema");
-	if (schema !== "gentle-ai.review-result-artifact/v2") throw new TypeError(`native capture-result manifest schema must be gentle-ai.review-result-artifact/v2, received ${schema}`);
-	const admission = text("admission_decision");
-	if (admission !== "completed") throw new TypeError(`native capture-result manifest admission_decision must be completed, received ${admission}`);
-	// Exactly one locator: a provider-owned path OR an opaque reference. Both or
-	// neither means the manifest cannot be handed to FINALIZE.
-	const hasPath = body.path !== undefined, hasReference = body.reference !== undefined;
-	if (hasPath === hasReference) throw new TypeError("native capture-result manifest must carry exactly one of path or reference");
+	if (text("schema") !== NATIVE_REVIEW_PROVIDER_ROLE_CAPTURE_SCHEMA) throw new TypeError(`native provider role capture artifact schema must be ${NATIVE_REVIEW_PROVIDER_ROLE_CAPTURE_SCHEMA}`);
+	const role = text("role");
+	if (role !== "refuter" && role !== "targeted-validator") throw new TypeError(`native provider role capture artifact role must be refuter or targeted-validator, received ${role}`);
+	if (body.captured !== true) throw new TypeError("native provider role capture artifact must report captured: true");
 	return Object.freeze({
-		schema,
-		subjectHash: text("subject_hash"),
-		admissionDecision: admission,
-		...(body.lens === undefined ? {} : { lens: text("lens") }),
-		...(hasPath ? { path: text("path") } : { reference: text("reference") }),
+		schema: NATIVE_REVIEW_PROVIDER_ROLE_CAPTURE_SCHEMA,
+		lineageId: text("lineage_id"),
+		targetIdentity: text("target_identity"),
+		role,
+		captured: true,
 	});
 }
 
 export class NativeReviewCliV216 implements NativeReviewCli {
-	private readonly legacy: NativeReviewCliV214;
+	private readonly plain: NativeReviewPlainCli;
 	private readonly adapter: ExecFileAdapter;
 	private readonly executable: string | (() => string);
 	private readonly timeoutMs: number;
 	private readonly maxBufferBytes: number;
 	private readonly cleanupDirectory: (directory: string) => Promise<void>;
-	private readonly executableDigest: NativeExecutableDigestResolver;
 	constructor(
 		adapter: ExecFileAdapter,
 		executable: string | (() => string) = resolveGentleAiBinary,
 		timeoutMs = 30_000,
-		maxBufferBytes = 1024 * 1024,
+		maxBufferBytes = resolveNativeReviewMaxBufferBytes(),
 		cleanupDirectory: (directory: string) => Promise<void> = (directory) => rm(directory, { recursive: true, force: true }),
-		executableDigest: NativeExecutableDigestResolver = defaultExecutableDigest,
 	) {
 		if (typeof executable === "string" && (!isAbsolute(executable) || executable === "gentle-ai")) throw new TypeError("Native review requires an absolute package-local executable");
 		this.adapter = adapter;
@@ -1856,8 +1778,7 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 		this.timeoutMs = timeoutMs;
 		this.maxBufferBytes = maxBufferBytes;
 		this.cleanupDirectory = cleanupDirectory;
-		this.executableDigest = executableDigest;
-		this.legacy = new NativeReviewCliV214(adapter, executable, timeoutMs, maxBufferBytes, cleanupDirectory);
+		this.plain = new NativeReviewPlainCli(adapter, executable, timeoutMs, maxBufferBytes, cleanupDirectory);
 	}
 
 	private executablePath(operation: NativeReviewOperation, mutating: boolean): string {
@@ -1871,15 +1792,6 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 		}
 	}
 
-	private verifiedExecutable(operation: NativeReviewOperation, mutating: boolean): { path: string; digest: string } {
-		const path = this.executablePath(operation, mutating);
-		try {
-			return { path, digest: this.executableDigest(path) };
-		} catch {
-			throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, operation, mutating, "package-local native executable identity could not be verified", undefined, false);
-		}
-	}
-
 	private async invoke(
 		operation: NativeReviewOperation,
 		cwd: string,
@@ -1888,6 +1800,14 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 		signal: AbortSignal | undefined,
 		path: string,
 		toleratedStderr: readonly string[] = [],
+		// A successful acknowledgement burns its authority and, on every
+		// published release up to v2.5.0-rc.3, prints nothing: there is no
+		// receipt left to describe. Only that shape opts out of the body, and
+		// only for a zero exit. When such an operation does print, the bytes
+		// are handed back as a body for the caller to decode against the one
+		// identity it accepts (gentle-ai #3947); a non-zero exit still has to
+		// produce its typed failure envelope like every other operation.
+		expectsBody = true,
 	): Promise<NegotiatedExecution> {
 		let result: ExecFileResult;
 		try {
@@ -1896,10 +1816,14 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 			if (error instanceof Error && error.name === "AbortError") throw nativeError(NATIVE_REVIEW_ERROR_CODE.CANCELLED, operation, mutating, "native process was cancelled");
 			throw nativeError(NATIVE_REVIEW_ERROR_CODE.UNAVAILABLE, operation, mutating, "native process could not start");
 		}
+		if (result.outputLimitExceeded) throw nativeError(NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT, operation, mutating, "native process output exceeded limit", result, true, undefined, this.maxBufferBytes);
 		if (result.timedOut) throw nativeError(NATIVE_REVIEW_ERROR_CODE.TIMEOUT, operation, mutating, "native process timed out", result);
-		if (result.outputLimitExceeded) throw nativeError(NATIVE_REVIEW_ERROR_CODE.OUTPUT_LIMIT, operation, mutating, "native process output exceeded limit", result);
 		if (result.signal) throw nativeError(NATIVE_REVIEW_ERROR_CODE.SIGNAL, operation, mutating, "native process was signalled", result);
 		const diagnostics = nativeProcessDiagnostics(operation, NATIVE_REVIEW_ERROR_CODE.NON_ZERO, result);
+		if (!expectsBody && result.exitCode === 0 && result.stdout.trim().length === 0) {
+			if (result.stderr.trim().length > 0 && !stderrIsTolerated(result.stderr, toleratedStderr)) throw nativeError(NATIVE_REVIEW_ERROR_CODE.UNEXPECTED_STDERR, operation, mutating, "native process wrote stderr", result);
+			return { body: {}, exitCode: result.exitCode, silent: true };
+		}
 		const body = parseJson(result.stdout, operation, mutating, diagnostics);
 		if (result.exitCode !== 0) {
 			try {
@@ -1909,49 +1833,11 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 				throw nativeError(NATIVE_REVIEW_ERROR_CODE.NON_ZERO, operation, mutating, "native negotiated operation failed without a valid failure envelope", result);
 			}
 		}
-		if (result.stderr.trim().length > 0 && !stderrIsTolerated(result.stderr, toleratedStderr)) throw nativeError(NATIVE_REVIEW_ERROR_CODE.UNEXPECTED_STDERR, operation, mutating, "native process wrote stderr", result);
+		const forecastNarrationTolerated = operation === NATIVE_REVIEW_OPERATION.STATUS && stderrIsForecastNarration(result.stderr);
+		if (result.stderr.trim().length > 0 && !stderrIsTolerated(result.stderr, toleratedStderr) && !forecastNarrationTolerated) throw nativeError(NATIVE_REVIEW_ERROR_CODE.UNEXPECTED_STDERR, operation, mutating, "native process wrote stderr", result);
 		return { body, exitCode: result.exitCode };
 	}
 
-	async capabilities(request: NativeCapabilitiesRequest = {}): Promise<ReviewCapabilitiesV2> {
-		const executable = this.verifiedExecutable(NATIVE_REVIEW_OPERATION.VERSION, false);
-		const cached = nativeCapabilitiesByDigest.get(executable.digest);
-		if (cached !== undefined) return cached;
-		const negotiation = (async () => {
-			const execution = await this.invoke(
-				NATIVE_REVIEW_OPERATION.VERSION,
-				request.cwd ?? dirname(executable.path),
-				["review", "capabilities", "--contract", REVIEW_INTEGRATION_CONTRACT],
-				false,
-				request.signal,
-				executable.path,
-			);
-			// Two distinct half-upgraded-install failures (Design Decision #7,
-			// migrate-review-integration-v2): a decode failure means the installed
-			// runtime cannot even answer this shape (an older `.gentle-ai/` payload
-			// that still speaks `unsupported_contract` for v2); a successful decode
-			// whose package.version disagrees with the pin names both versions.
-			let capabilities: ReviewCapabilitiesV2;
-			try {
-				capabilities = decodeReviewCapabilitiesV2(execution.body, executable.digest);
-			} catch (error) {
-				if (error instanceof NativeReviewCliError) throw error;
-				throw nativeError(NATIVE_REVIEW_ERROR_CODE.SCHEMA_INCOMPATIBLE, NATIVE_REVIEW_OPERATION.VERSION, false, `expected gentle-ai v${GENTLE_AI_VERSION}; the installed runtime is incompatible — reinstall gentle-pi`);
-			}
-			if (capabilities.packageVersion !== GENTLE_AI_VERSION) {
-				throw nativeError(NATIVE_REVIEW_ERROR_CODE.VERSION_INCOMPATIBLE, NATIVE_REVIEW_OPERATION.VERSION, false, `expected gentle-ai v${GENTLE_AI_VERSION}, provider reported v${capabilities.packageVersion}`);
-			}
-			return capabilities;
-		})();
-		nativeCapabilitiesByDigest.set(executable.digest, negotiation);
-		try {
-			return await negotiation;
-		} catch (error) {
-			nativeCapabilitiesByDigest.delete(executable.digest);
-			throw error;
-		}
-	}
-
 	private async negotiated(
 		operation: NativeReviewOperation,
 		cwd: string,
@@ -1960,13 +1846,7 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 		signal?: AbortSignal,
 		toleratedStderr: readonly string[] = [],
 	): Promise<NegotiatedExecution> {
-		const executable = this.verifiedExecutable(operation, mutating);
-		await this.capabilities({ cwd, ...(signal === undefined ? {} : { signal }) });
-		const afterNegotiation = this.verifiedExecutable(operation, mutating);
-		if (afterNegotiation.path !== executable.path || afterNegotiation.digest !== executable.digest) {
-			throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, operation, mutating, "native executable was replaced after capability negotiation", undefined, false);
-		}
-		return this.invoke(operation, cwd, arguments_, mutating, signal, executable.path, toleratedStderr);
+		return this.invoke(operation, cwd, arguments_, mutating, signal, this.executablePath(operation, mutating), toleratedStderr);
 	}
 
 	async start(request: NativeStartRequest): Promise<NativeStartResult> {
@@ -1974,36 +1854,54 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 		if (request.baseRef !== undefined && request.committedOnly !== true) throw new TypeError("Native START baseRef requires explicit committedOnly acknowledgement");
 		if (request.baseRef === undefined && request.committedOnly !== undefined) throw new TypeError("Native START committedOnly requires an explicit baseRef");
 		if (request.targetIdentity !== undefined && !/^sha256:[0-9a-f]{64}$/.test(request.targetIdentity)) throw new TypeError("Native START targetIdentity must be a canonical sha256 identity");
-		// The controller supplies the target it already projected from the
-		// authority workspace after proving its immutable actor view is identical.
-		// Direct adapter callers may omit it and retain the same-root projection.
+		// STATUS owns the candidate binding and renders the only executable START
+		// vector. Callers may supply a previously observed identity only to detect
+		// drift; Pi never rebuilds that vector from request fields.
 		const projection = request.projection ?? "workspace";
-		const targetIdentity = request.targetIdentity ?? (await this.targetStatus({
+		const selection = nativeUntrackedSelection(request);
+		const status = await this.targetStatus({
 			cwd: request.cwd,
 			projection,
-			...(request.baseRef === undefined ? {} : { baseRef: request.baseRef }),
+			...(request.baseRef === undefined ? {} : { baseRef: request.baseRef, committedOnly: true }),
 			...(request.lineageId === undefined ? {} : { lineageId: request.lineageId }),
+			...selection,
+			...(request.intendedUntrackedSelection === undefined ? {} : { intendedUntrackedSelection: request.intendedUntrackedSelection }),
+			agent: "pi",
 			...(request.signal === undefined ? {} : { signal: request.signal }),
-		})).targetIdentity;
-		const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.START, request.cwd, [
-			"review", "start", "--contract", REVIEW_INTEGRATION_CONTRACT, "--cwd", request.cwd,
-			"--target", targetIdentity, "--projection", projection,
-			...(request.baseRef === undefined ? [] : ["--base-ref", request.baseRef, "--committed-only"]),
-			...(request.lineageId === undefined ? [] : ["--lineage", request.lineageId]),
-			...(request.policyPath === undefined ? [] : ["--policy", request.policyPath]),
-			...(request.focus === undefined ? [] : ["--focus", request.focus]),
-			"--consent", "relay",
-		], true, request.signal);
-		// A negotiated v2 START may answer `consent/v2` (action:
+		});
+		const transition = status.nextTransition?.kind === "execute" && status.nextTransition.execute?.operation === "review.start"
+			? status.nextTransition.execute
+			: undefined;
+		if (transition === undefined) throw nativeError(NATIVE_REVIEW_ERROR_CODE.SCHEMA_INCOMPATIBLE, NATIVE_REVIEW_OPERATION.START, false, "native STATUS did not offer an executable review.start transition", undefined, false);
+		if (status.projection.projection !== projection || transition.binding.targetIdentity !== status.targetIdentity || (request.targetIdentity !== undefined && request.targetIdentity !== status.targetIdentity)) {
+			throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, false, "native START transition target binding mismatch", undefined, false);
+		}
+		if (request.lineageId !== undefined && transition.binding.lineageId !== undefined && transition.binding.lineageId !== request.lineageId) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, false, "native START transition lineage binding mismatch", undefined, false);
+		const transitionTokens = transition.arguments.map((argument) => {
+			if (argument.token === undefined) throw nativeError(NATIVE_REVIEW_ERROR_CODE.SCHEMA_INCOMPATIBLE, NATIVE_REVIEW_OPERATION.START, false, "native START transition omitted an ordered argument token", undefined, false);
+			return argument.token;
+		});
+		const targetIdentity = status.targetIdentity;
+		const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.START, request.cwd, ["review", "start", ...transitionTokens], true, request.signal);
+		// A negotiated v2 START may answer a consent question (action:
 		// "consent_required") instead of `start/v3` when the provider needs an
 		// explicit answer it cannot infer. Discriminate before decode and surface
-		// the complete envelope; only the caller can map a human answer.
+		// the complete envelope; only the caller can map a human answer. The
+		// body's own schema string selects the identity-exact decoder: the
+		// pinned 2.2.x line emits consent/v2, gentle-ai >= 2.3.0 (capabilities
+		// v2.1+) emits consent/v3, and any other identity fails closed inside
+		// the v3 decoder's exact identity gate.
 		if (execution.body.action === "consent_required") {
-			const consent = decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeReviewConsentV2(execution.body));
+			const consent = decode(NATIVE_REVIEW_OPERATION.START, true, () => {
+				if (execution.body.schema === "gentle-ai.review-integration.consent/v2") return decodeReviewConsentV2(execution.body);
+				const decoded = decodeReviewConsentV3(execution.body, "pi");
+				validatePiConsentChoiceAgentBindings(decoded);
+				return decoded;
+			});
 			if (consent.targetIdentity !== targetIdentity || consent.projection !== projection) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native consent target binding mismatch");
 			throw new NativeReviewConsentRequiredError(consent);
 		}
-		const result = decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeReviewStartV3(execution.body));
+		const result = decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeReviewStartResponse(execution.body));
 		if (request.lineageId !== undefined && result.lineageId !== request.lineageId) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native start lineage mismatch");
 		const resultTarget = result.targetIdentity ?? result.repositoryContext?.targetIdentity;
 		if (resultTarget !== undefined && resultTarget !== targetIdentity) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native start target mismatch");
@@ -2018,6 +1916,7 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 			action: result.action as NativeStartAction,
 			lensesRequired: result.lensesRequired,
 			riskReasons: result.riskReasons.map((reason) => ({ ...reason })),
+			...("nextTransition" in result && result.nextTransition !== undefined ? { nextTransition: result.nextTransition } : {}),
 			// Derived, not received. `risk_reasons` is a required start/v2 field
 			// already recomputed against the authoritative frozen snapshot, so
 			// these phrases describe the same candidate the lenses will review.
@@ -2036,16 +1935,15 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 	}
 
 	async answerConsent(request: NativeReviewConsentAnswerRequest): Promise<NativeReviewConsentAnswerResult> {
-		const arguments_ = consentInvocationArguments(request);
-		const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.START, request.cwd, arguments_, true, request.signal);
+		const invocation = consentInvocationArguments(request);
+		const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.START, request.cwd, invocation.arguments_, true, request.signal);
 		if (request.answer === NATIVE_REVIEW_CONSENT_ANSWER.DECLINED) {
 			return decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeDeclinedConsentStart(execution.body, request));
 		}
-		const result = decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeReviewStartV3(execution.body));
+		const result = decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeReviewStartResponse(execution.body));
 		const answeredTarget = result.targetIdentity ?? result.repositoryContext?.targetIdentity;
 		if (answeredTarget !== request.consent.targetIdentity) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native consent answer target mismatch");
-		const lineageId = exactConsentOption(arguments_, "--lineage");
-		if (result.lineageId !== lineageId) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native consent answer lineage mismatch");
+		if (invocation.lineageId !== undefined && result.lineageId !== invocation.lineageId) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native consent answer lineage mismatch");
 		return { kind: "started", start: {
 			lineageId: result.lineageId,
 			state: result.state as NativeStartResult["state"],
@@ -2057,6 +1955,7 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 			action: result.action as NativeStartAction,
 			lensesRequired: result.lensesRequired,
 			riskReasons: result.riskReasons.map((reason) => ({ ...reason })),
+			...("nextTransition" in result && result.nextTransition !== undefined ? { nextTransition: result.nextTransition } : {}),
 			...(() => {
 				const evidence = nativeRiskEvidencePhrases(result.riskLevel, result.riskReasons);
 				return evidence.length === 0 ? {} : { riskEvidence: evidence };
@@ -2065,119 +1964,23 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 		} };
 	}
 
-	private async stageDocument(directory: string, name: string, document: unknown): Promise<string> {
-		const path = join(directory, `${name}.json`);
-		await writeFile(path, JSON.stringify(document), { encoding: "utf8", mode: 0o600 });
-		await chmod(path, 0o600);
-		return path;
-	}
-
-	private async stageEvidence(directory: string, evidence: string): Promise<string> {
-		const path = join(directory, "evidence.txt");
-		await writeFile(path, evidence, { encoding: "utf8", mode: 0o600 });
-		await chmod(path, 0o600);
-		return path;
-	}
-
-	async finalize(request: NativeFinalizeRequest): Promise<NativeFinalizeResult> {
-		if (request.evidenceDocument !== undefined && request.evidenceDocument.length === 0) throw new TypeError("Native FINALIZE evidence must contain at least one byte");
-		const needsStaging = request.lensResults !== undefined || request.refuterDocument !== undefined || request.validationDocument !== undefined || request.evidenceDocument !== undefined;
-		const directory = needsStaging ? await mkdtemp(join(tmpdir(), "gentle-ai-finalize-")) : undefined;
-		try {
-			if (directory !== undefined) await chmod(directory, 0o700);
-			const resultFiles = directory !== undefined && request.lensResults !== undefined ? await Promise.all(request.lensResults.map((entry, index) => this.stageDocument(directory, `result-${index}`, entry.document))) : request.resultFiles ?? [];
-			const refuterFile = directory !== undefined && request.refuterDocument !== undefined ? await this.stageDocument(directory, "refuter", request.refuterDocument) : request.refuterFile;
-			const validationFile = directory !== undefined && request.validationDocument !== undefined ? await this.stageDocument(directory, "validation", request.validationDocument) : request.validationFile;
-			const evidenceFile = directory !== undefined && request.evidenceDocument !== undefined ? await this.stageEvidence(directory, request.evidenceDocument) : request.evidenceFile;
-			const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.FINALIZE, request.cwd, [
-				"review", "finalize", "--contract", REVIEW_INTEGRATION_CONTRACT, "--cwd", request.cwd,
-				...(request.lineageId === undefined ? [] : ["--lineage", request.lineageId]),
-				// `--result` is RETIRED. A reviewer result supplied that way carries
-				// no provider-owned admission, so it cannot prove the lens inspected
-				// the frozen candidate. Results reach authority through
-				// `review capture-result`, and FINALIZE either discovers them
-				// (`--captured-results`) or is handed each manifest in lens order.
-				...(request.capturedResults === true ? ["--captured-results=true"] : []),
-				...(request.resultArtifactFiles ?? []).flatMap((path) => ["--result-artifact-file", path]),
-				...(refuterFile === undefined ? [] : ["--refuter", refuterFile]),
-				...(request.correctionLines === undefined ? [] : ["--correction-lines", String(request.correctionLines)]),
-				...(validationFile === undefined ? [] : ["--validation", validationFile]),
-				...(evidenceFile === undefined ? [] : ["--evidence", evidenceFile]),
-				...(request.failed === true ? ["--failed"] : []),
-			], true, request.signal);
-			const envelope = decode(NATIVE_REVIEW_OPERATION.FINALIZE, true, () => decodeReviewOperationV2(execution.body));
-			if (envelope.operation !== "review.finalize") throw new Error("wrong finalize operation envelope");
-			const body = envelope.result;
-			const lineageId = requiredString(body.lineage_id);
-			if (request.lineageId !== undefined && lineageId !== request.lineageId) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.FINALIZE, true, "native finalize lineage mismatch");
-			return {
-				lineageId,
-				state: requiredString(body.state),
-				action: requiredString(body.action),
-				storeRevision: requiredString(body.store_revision),
-				// Present only when state is correction_required (validated by
-				// decodeReviewOperationV2); carried through as the raw validated
-				// shape rather than re-decoded, since the typed decoder for this
-				// nested object is private to lib/review-integration-v2.ts.
-				...(body.validation_request === undefined ? {} : { validationRequest: body.validation_request as Readonly<Record<string, unknown>> }),
-				...(body.escalation === undefined ? {} : { escalation: requiredString(body.escalation) }),
-			};
-		} finally {
-			if (directory !== undefined) await this.cleanupDirectory(directory).catch(() => undefined);
-		}
-	}
-
-	async validate(request: NativeValidateRequest): Promise<NativeValidateResult> {
-		const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.VALIDATE, request.cwd, [
-			"review", "validate", "--contract", REVIEW_INTEGRATION_CONTRACT, "--gate", request.gate, "--cwd", request.cwd,
-			...(request.lineageId === undefined ? [] : ["--lineage", request.lineageId]),
-			...(request.flags ?? []),
-		], false, request.signal);
-		const envelope = decode(NATIVE_REVIEW_OPERATION.VALIDATE, false, () => decodeReviewOperationV2(execution.body));
-		if (envelope.operation !== "review.validate") throw new Error("wrong validate operation envelope");
-		const body = envelope.result;
-		const gateContext = decodeGateContext(body.context);
-		return {
-			allowed: booleanValue(body.allowed),
-			result: enumString(body.result, NATIVE_GATE_RESULT) as NativeValidateResult["result"],
-			action: requiredString(body.action),
-			reason: requiredString(body.reason),
-			gateContext,
-			...(body.delivery === undefined ? {} : { delivery: enumString(body.delivery, ["disabled/unmanaged"]) as NativeValidateResult["delivery"] }),
-		};
-	}
-
-	async bindSdd(request: NativeBindSddRequest): Promise<NativeBindSddResult> {
-		const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.BIND_SDD, request.cwd, [
-			"review", "bind-sdd", "--contract", REVIEW_INTEGRATION_CONTRACT, "--cwd", request.cwd,
-			"--change", request.change, "--lineage", request.lineage,
-			`--expected-binding-revision=${request.expectedBindingRevision}`,
-		], true, request.signal);
-		const envelope = decode(NATIVE_REVIEW_OPERATION.BIND_SDD, true, () => decodeReviewOperationV2(execution.body));
-		if (envelope.operation !== "review.bind_sdd") throw new Error("wrong bind-sdd operation envelope");
-		const body = envelope.result;
-		const gateContext = decodeGateContext(body.gate_context);
-		const lineage = requiredString(body.lineage);
-		const change = requiredString(body.change);
-		if (lineage !== request.lineage || change !== request.change || gateContext.raw.gate !== "post-apply") throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.BIND_SDD, true, "native binding identity mismatch");
-		return {
-			revision: requiredString(body.revision),
-			change,
-			lineage,
-			authorityRevision: requiredString(body.authority_revision),
-			receiptHash: requiredString(body.receipt_hash),
-			gateContext,
-		};
-	}
-
 	async targetStatus(request: NativeTargetStatusRequest): Promise<ReviewStatusV3> {
-		const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.STATUS, request.cwd, [
+		if (request.baseRef !== undefined && !isCanonicalProcessString(request.baseRef)) throw new TypeError("Native STATUS baseRef must be a non-empty, trimmed, NUL-free string");
+		if (request.baseRef !== undefined && request.committedOnly !== true) throw new TypeError("Native STATUS baseRef requires explicit committedOnly acknowledgement");
+		if (request.baseRef === undefined && request.committedOnly !== undefined) throw new TypeError("Native STATUS committedOnly requires an explicit baseRef");
+		const selection = nativeUntrackedSelection(request);
+		const submitted = request.intendedUntrackedSelection;
+		if (submitted !== undefined && submitted.argumentTokens.reduce((count, token) => count + token.split("{{value}}").length - 1, 0) !== 1) throw new TypeError("Native intended-untracked selection requires exactly one provider-issued {{value}} token");
+		const statusArguments = submitted === undefined ? [
 			"review", "status", "--contract", REVIEW_INTEGRATION_CONTRACT, "--cwd", request.cwd,
 			"--projection", request.projection ?? "workspace",
-			...(request.baseRef === undefined ? [] : ["--base-ref", request.baseRef]),
+			...nativeUntrackedSelectionArguments(selection),
+			...(request.baseRef === undefined ? [] : ["--base-ref", request.baseRef, "--committed-only"]),
 			...(request.lineageId === undefined ? [] : ["--lineage", request.lineageId]),
+			...(request.agent === undefined ? [] : ["--agent", request.agent]),
 			"--next-transition",
-		], false, request.signal);
+		] : ["review", "status", "--cwd", request.cwd, ...submitted.argumentTokens.map((token) => token.replaceAll("{{value}}", submitted.value))];
+		const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.STATUS, request.cwd, statusArguments, false, request.signal);
 		assertSupportedNextTransitionOperation(execution.body);
 		return decode(NATIVE_REVIEW_OPERATION.STATUS, false, () => decodeReviewStatusV3(execution.body));
 	}
@@ -2217,7 +2020,7 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 	// --contract, and the verification-evidence/v2 record returned DIRECTLY —
 	// not wrapped in an operation/v2 envelope. Evidence is staged through the
 	// same 0o600 tmpfile discipline FINALIZE uses.
-	async captureResult(request: NativeReviewCaptureResultRequest): Promise<NativeReviewAdmittedResultManifest> {
+	async captureResult(request: NativeReviewCaptureResultRequest): Promise<NativeReviewCaptureResultOutcome> {
 		if (request.argumentTokens.length === 0) throw new TypeError("Native CAPTURE_RESULT requires the provider-issued argument tokens");
 		if (request.argumentTokens.some((token) => typeof token !== "string" || token.length === 0)) throw new TypeError("Native CAPTURE_RESULT argument tokens must all be non-empty strings");
 		if (request.resultDocument.length === 0) throw new TypeError("Native CAPTURE_RESULT result document must contain at least one byte");
@@ -2229,87 +2032,179 @@ export class NativeReviewCliV216 implements NativeReviewCli {
 			const resultFile = join(directory, "result.json");
 			await writeFile(resultFile, request.resultDocument, { encoding: "utf8", mode: 0o600 });
 			await chmod(resultFile, 0o600);
-			const executable = this.verifiedExecutable(NATIVE_REVIEW_OPERATION.CAPTURE_RESULT, true);
+			const executable = this.executablePath(NATIVE_REVIEW_OPERATION.CAPTURE_RESULT, true);
 			const execution = await this.invoke(NATIVE_REVIEW_OPERATION.CAPTURE_RESULT, request.cwd ?? process.cwd(), [
 				"review", "capture-result",
 				...request.argumentTokens,
 				...(carriesContext || request.cwd === undefined ? [] : ["--cwd", request.cwd]),
 				"--input", resultFile,
-			], true, request.signal, executable.path);
-			return decode(NATIVE_REVIEW_OPERATION.CAPTURE_RESULT, true, () => decodeNativeAdmittedResultManifest(execution.body));
+			], true, request.signal, executable);
+			return decode(NATIVE_REVIEW_OPERATION.CAPTURE_RESULT, true, () => {
+				const body = object(execution.body);
+				if (body.schema === "gentle-ai.review-last-event-closure/v1") {
+					const closure = decodeReviewLastEventClosureV1(body);
+					if (closure.operation !== "review/capture-result") throw new TypeError("capture-result returned a closure for another operation");
+					return closure;
+				}
+				return decodeNativeAdmittedResultManifest(body);
+			});
 		} finally {
 			await this.cleanupDirectory(directory).catch(() => undefined);
 		}
 	}
 
-	async captureEvidence(request: NativeReviewCaptureEvidenceRequest): Promise<NativeReviewVerificationEvidenceV2> {
-		if (!(NATIVE_REVIEW_CAPTURE_OUTCOME as readonly string[]).includes(request.outcome)) throw new TypeError("Native CAPTURE_EVIDENCE outcome must be passed, verification_failed, or procedural_tooling_failed");
-		if (request.evidenceDocument.length === 0) throw new TypeError("Native CAPTURE_EVIDENCE evidence must contain at least one byte");
-		const directory = await mkdtemp(join(tmpdir(), "gentle-ai-capture-evidence-"));
-		try {
-			await chmod(directory, 0o700);
-			const evidenceFile = await this.stageEvidence(directory, request.evidenceDocument);
-			const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.CAPTURE_EVIDENCE, request.cwd, [
-				"review", "capture-evidence", "--cwd", request.cwd,
-				"--lineage", request.lineageId,
-				"--target", request.targetIdentity,
-				"--expected-revision", request.expectedRevision,
-				"--outcome", request.outcome,
-				"--input", evidenceFile,
-			], true, request.signal);
-			return decode(NATIVE_REVIEW_OPERATION.CAPTURE_EVIDENCE, true, () => decodeNativeReviewVerificationEvidence(execution.body));
-		} finally {
-			await this.cleanupDirectory(directory).catch(() => undefined);
-		}
+	// Relays the provider-issued acknowledgement exactly as rendered. A success
+	// burns the authority and its artifacts; a refusal still arrives as the
+	// ordinary typed failure envelope. Two success shapes exist and both are
+	// the same burn: every published release up to v2.5.0-rc.3 prints nothing
+	// (resolved as `undefined`, byte-for-byte the pinned behaviour), and
+	// gentle-ai #3947 prints one `gentle-ai.review-acknowledged/v1` envelope
+	// naming the burned lineage, target, and consumed revision. Any other
+	// output on a zero exit is schema-incompatible with the mutation outcome
+	// unknown, exactly like a malformed terminal closure: the caller
+	// reconciles through STATUS and never infers the burn from prose.
+	async acknowledgeApproved(request: NativeReviewAcknowledgeApprovedRequest): Promise<NativeReviewAcknowledgeApprovedOutcome> {
+		if (request.argumentTokens.length === 0) throw new TypeError("Native ACKNOWLEDGE_APPROVED requires the provider-issued argument tokens");
+		if (request.argumentTokens.some((token) => typeof token !== "string" || token.length === 0)) throw new TypeError("Native ACKNOWLEDGE_APPROVED argument tokens must all be non-empty strings");
+		if (request.argumentTokens.some((token) => token.includes("{{value}}"))) throw new TypeError("Native ACKNOWLEDGE_APPROVED argument tokens carry no caller-substituted value");
+		const executable = this.executablePath(NATIVE_REVIEW_OPERATION.ACKNOWLEDGE_APPROVED, true);
+		const execution = await this.invoke(NATIVE_REVIEW_OPERATION.ACKNOWLEDGE_APPROVED, request.cwd, [
+			"review", "acknowledge-approved", ...request.argumentTokens,
+		], true, request.signal, executable, [], false);
+		if (execution.silent) return undefined;
+		return decode(NATIVE_REVIEW_OPERATION.ACKNOWLEDGE_APPROVED, true, () => decodeReviewAcknowledgedV1(execution.body, request.binding ?? {}));
 	}
 
-	reviewStatus(request: NativeReviewStatusRequest): Promise<NativeReviewStatusResult> {
-		return this.legacy.reviewStatus(request);
+	async captureCorrectionPlan(request: NativeReviewCorrectionPlanCaptureRequest): Promise<ReviewLastEventClosureV1> {
+		if (request.argumentTokens.length === 0) throw new TypeError("Native CAPTURE_CORRECTION_PLAN requires the provider-issued argument tokens");
+		if (request.argumentTokens.some((token) => typeof token !== "string" || token.length === 0)) throw new TypeError("Native CAPTURE_CORRECTION_PLAN argument tokens must all be non-empty strings");
+		if (!Number.isSafeInteger(request.correctionLines) || request.correctionLines < 1 || request.correctionLines > 200) throw new TypeError("Native CAPTURE_CORRECTION_PLAN correction lines must be a positive integer up to 200");
+		const valueIndex = request.argumentTokens.findIndex((token) => token.includes("{{value}}"));
+		if (valueIndex < 0 || request.argumentTokens.filter((token) => token.includes("{{value}}")).length !== 1) throw new TypeError("Native CAPTURE_CORRECTION_PLAN requires exactly one provider-issued {{value}} token");
+		const argumentTokens = request.argumentTokens.map((token, index) => index === valueIndex ? token.replaceAll("{{value}}", String(request.correctionLines)) : token);
+		const executable = this.executablePath(NATIVE_REVIEW_OPERATION.CAPTURE_CORRECTION_PLAN, true);
+		const execution = await this.invoke(NATIVE_REVIEW_OPERATION.CAPTURE_CORRECTION_PLAN, request.cwd, [
+			"review", "capture-correction-plan", ...argumentTokens,
+		], true, request.signal, executable);
+		return decode(NATIVE_REVIEW_OPERATION.CAPTURE_CORRECTION_PLAN, true, () => {
+			const closure = decodeReviewLastEventClosureV1(execution.body);
+			if (closure.operation !== "review.capture-correction-plan") throw new TypeError("capture-correction-plan returned a closure for another operation");
+			return closure;
+		});
 	}
 
-	sddStatus(request: NativeSddStatusRequest): Promise<NativeSddStatusResult> {
-		return this.legacy.sddStatus(request);
+	// gentle-pi#311 P4-roles: executes one provider-rendered self-contained
+	// role capture vector exactly as rendered — one CLI invocation, verbatim
+	// tokens in provider order, in the foreground. Go materializes the role
+	// prompt, spawns its own locked-down pi subprocess, and admits the raw
+	// verdict; Pi never adds, removes, or reorders a single token (not even
+	// --cwd: the vector's --repository-context is authoritative and mutually
+	// exclusive with a path). The central adapter injects the relay handshake
+	// environment on this spawn like on every other gentle-ai invocation.
+	async captureProviderRole(request: NativeReviewProviderRoleCaptureRequest): Promise<NativeReviewProviderRoleCaptureOutcome> {
+		if (!isNativeReviewProviderRoleCaptureOperation(request.captureOperation)) throw new TypeError(`Native CAPTURE_PROVIDER_ROLE supports only review.capture-refuter and review.capture-validation, received ${JSON.stringify(request.captureOperation)}`);
+		const verb = request.captureOperation.slice("review.".length);
+		const expectedClosureOperation = NATIVE_REVIEW_PROVIDER_ROLE_CAPTURE_CLOSURE_OPERATION[request.captureOperation];
+		if (request.argumentTokens.length === 0) throw new TypeError("Native CAPTURE_PROVIDER_ROLE requires the provider-rendered argument tokens");
+		if (request.argumentTokens.some((token) => typeof token !== "string" || token.length === 0)) throw new TypeError("Native CAPTURE_PROVIDER_ROLE argument tokens must all be non-empty strings");
+		const executable = this.executablePath(NATIVE_REVIEW_OPERATION.CAPTURE_PROVIDER_ROLE, true);
+		const execution = await this.invoke(NATIVE_REVIEW_OPERATION.CAPTURE_PROVIDER_ROLE, request.cwd, [
+			"review", verb,
+			...request.argumentTokens,
+		], true, request.signal, executable);
+		return decode(NATIVE_REVIEW_OPERATION.CAPTURE_PROVIDER_ROLE, true, () => {
+			const body = object(execution.body);
+			if (body.schema === "gentle-ai.review-last-event-closure/v1") {
+				const closure = decodeReviewLastEventClosureV1(body);
+				if (closure.operation !== expectedClosureOperation) throw new TypeError("provider role capture returned a closure for another operation");
+				return closure;
+			}
+			return decodeNativeProviderRoleCaptureArtifact(body);
+		});
 	}
 
-	// Same plain-CLI delegation as reviewStatus/sddStatus above: `review mode`
-	// is dark until the negotiated version reports `mode: true` and stays
-	// outside the negotiated integration-v1 contract.
-	reviewMode(request: NativeReviewModeRequest): Promise<NativeReviewModeResult> {
-		return this.legacy.reviewMode(request);
+	// gentle-pi#311 P5: executes one provider-rendered `review.finalize`
+	// execute transition exactly as rendered. The tokens come verbatim from
+	// the negotiated next_transition (e.g. `--lineage=<id>
+	// --captured-results=true`); Pi assembles no reviewer, refuter, or
+	// validator documents for this lane — the provider discovers its own
+	// admitted role and lens slots.
+
+	// Same misbinding class as capture-evidence (live smoke, 2026-08-16): the
+	// correction PLAN and TARGETED VALIDATION collect slots render `finalize`
+	// submission descriptors whose tokens are self-contained (--contract,
+	// --lineage, --expected-revision, --target, --request-hash,
+	// --repository-context) plus exactly one {{value}} slot. Executing anything
+	// other than those rendered tokens fails the live emitter's committed-
+	// intent reconciliation, so the tokens pass through verbatim with only the
+	// {{value}} substitution: a literal for correction_lines, a staged 0o600
+	// artifact path for a validation document.
+
+
+
+	// Field defect (fambig, 2026-08-16): at every evidence-pending sub-state
+	// the collect slot renders the identity native demands — for a correction
+	// that is the fix-diff `--target`, not the live workspace snapshot — so the
+	// slot's rendered submission tokens execute verbatim, with only the
+	// {{outcome}} and {{input}} slots substituted. Same verbatim-token
+	// discipline as captureResult; --repository-context is authoritative and
+	// mutually exclusive with a path.
+
+	async reviewStatus(request: NativeReviewStatusRequest): Promise<NativeReviewStatusResult> {
+		const execution = await this.invoke(
+			NATIVE_REVIEW_OPERATION.STATUS,
+			request.cwd,
+			["review", "status", "--cwd", request.cwd],
+			false,
+			request.signal,
+			this.executablePath(NATIVE_REVIEW_OPERATION.STATUS, false),
+		);
+		const status = decode(NATIVE_REVIEW_OPERATION.STATUS, false, () => decodeNativeReviewStatus(execution.body));
+		if (!await repositoriesMatch(request.cwd, status.repository)) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.STATUS, false, "native review status repository mismatch");
+		return status;
+	}
+
+	async reviewMode(request: NativeReviewModeRequest): Promise<NativeReviewModeResult> {
+		const cwd = await canonicalNativeReviewCwd(request.cwd);
+		const mutating = request.operation !== NATIVE_REVIEW_MODE_OPERATION.STATUS;
+		const execution = await this.invoke(
+			NATIVE_REVIEW_OPERATION.MODE,
+			cwd,
+			["review", "mode", request.operation, "--cwd", cwd, ...(mutating ? ["--scope", "clone"] : []), "--json"],
+			mutating,
+			request.signal,
+			this.executablePath(NATIVE_REVIEW_OPERATION.MODE, mutating),
+		);
+		return decode(NATIVE_REVIEW_OPERATION.MODE, mutating, () => decodeNativeReviewMode(execution.body, request.operation));
 	}
 
 	// Recovery commands are version-gated plain CLI operations outside the
-	// negotiated integration-v1 contract, exactly like reviewStatus/sddStatus.
+	// negotiated integration-v1 contract, exactly like reviewStatus.
 	reclaim(request: NativeReviewReclaimRequest): Promise<NativeReviewRecoveryResult> {
-		return this.legacy.reclaim(request);
+		return this.plain.reclaim(request);
 	}
 
 	recover(request: NativeReviewRecoverRequest): Promise<NativeReviewRecoveryResult> {
-		return this.legacy.recover(request);
+		return this.plain.recover(request);
 	}
 
 	abandon(request: NativeReviewAbandonRequest): Promise<NativeReviewRecoveryResult> {
-		return this.legacy.abandon(request);
+		return this.plain.abandon(request);
 	}
 
 	quarantineLegacy(request: NativeReviewLegacyQuarantineRequest): Promise<NativeReviewRecoveryResult> {
-		return this.legacy.quarantineLegacy(request);
+		return this.plain.quarantineLegacy(request);
 	}
 
 	reconcileAuthority(request: NativeReviewReconcileAuthorityRequest): Promise<NativeReviewRecoveryResult> {
-		return this.legacy.reconcileAuthority(request);
+		return this.plain.reconcileAuthority(request);
 	}
 
 	repairLegacyAlias(request: NativeReviewLegacyAliasRepairRequest): Promise<NativeReviewRecoveryResult> {
-		return this.legacy.repairLegacyAlias(request);
+		return this.plain.repairLegacyAlias(request);
 	}
 }
 
 export function createNativeReviewCli(adapter?: ExecFileAdapter, executable: string | (() => string) = resolveGentleAiBinary): NativeReviewCli {
-	if (adapter !== undefined) return new NativeReviewCliV214(adapter, executable);
-	return new NativeReviewCliV216(createNodeExecFileAdapter(), executable);
+	return new NativeReviewCliV216(adapter ?? createNodeExecFileAdapter(), executable);
 }
-
-// Response-schema fixtures remain v2.1.3 historical contracts; the production
-// client above accepts only the v2.1.4 runtime release.
-export { NativeReviewCliV214 as NativeReviewCliV213 };