gentle-pi 3.7.0 → 4.1.0

package/tests/review-integration-v2-forward.test.ts

@@ -17,6 +17,7 @@ import {
 	decodeReviewStartV4,
 	decodeReviewStatusV3,
 } from "../lib/review-integration-v2.ts";
+import { NativeReviewCliV216, type ExecFileAdapter } from "../lib/native-review-cli.ts";
 
 const DEV_FIXTURES = join(process.cwd(), "tests", "fixtures", "devbinary");
 const V2_FIXTURES = join(process.cwd(), "contracts", "review-integration", "v2", "fixtures");
@@ -556,6 +557,205 @@ test("status/v6 decodes and enforces the intended-untracked selection submission
 	}
 });
 
+function queuedTargetStatusAdapter(): { adapter: ExecFileAdapter; calls: string[][] } {
+	const calls: string[][] = [];
+	return {
+		calls,
+		adapter: async (request) => {
+			calls.push([...request.arguments]);
+			return { stdout: JSON.stringify(currentStatusFixture("status-v5.captured.json")), stderr: "", exitCode: 0, signal: null, timedOut: false, outputLimitExceeded: false };
+		},
+	};
+}
+
+function targetStatusClient(adapter: ExecFileAdapter): NativeReviewCliV216 {
+	return new NativeReviewCliV216(adapter, "/package/.gentle-ai/gentle-ai", 30_000, 1024 * 1024);
+}
+
+const SUBMITTED_PROVIDER_TOKENS = ["--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", "--intended-untracked-selection={{value}}"];
+
+test("targetStatus appends the forwarded base-ref/committed-only pair after intended-untracked submission tokens", async () => {
+	const queue = queuedTargetStatusAdapter();
+	await targetStatusClient(queue.adapter).targetStatus({
+		cwd: "/repo",
+		baseRef: "deadbeef",
+		committedOnly: true,
+		intendedUntrackedSelection: { argumentTokens: SUBMITTED_PROVIDER_TOKENS, value: '{"selection":true}' },
+	});
+	assert.deepEqual(queue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--base-ref", "deadbeef", "--committed-only",
+	]);
+});
+
+test("targetStatus leaves the intended-untracked submission argv unchanged when no baseRef is forwarded", async () => {
+	const queue = queuedTargetStatusAdapter();
+	await targetStatusClient(queue.adapter).targetStatus({
+		cwd: "/repo",
+		intendedUntrackedSelection: { argumentTokens: SUBMITTED_PROVIDER_TOKENS, value: '{"selection":true}' },
+	});
+	assert.deepEqual(queue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+	]);
+});
+
+test("targetStatus rejects a forwarded baseRef that conflicts with a base-ref the submission already carries", async () => {
+	const queue = queuedTargetStatusAdapter();
+	const tokensWithBaseRef = [...SUBMITTED_PROVIDER_TOKENS, "--base-ref=cafebabe"];
+	await assert.rejects(
+		() => targetStatusClient(queue.adapter).targetStatus({
+			cwd: "/repo", baseRef: "deadbeef", committedOnly: true,
+			intendedUntrackedSelection: { argumentTokens: tokensWithBaseRef, value: '{"selection":true}' },
+		}),
+		TypeError,
+	);
+	assert.equal(queue.calls.length, 0);
+
+	// Same value on both sides is not a conflict, but the submission still lacks
+	// --committed-only: T3 appends it so the selector stays complete.
+	const sameValueQueue = queuedTargetStatusAdapter();
+	await targetStatusClient(sameValueQueue.adapter).targetStatus({
+		cwd: "/repo", baseRef: "cafebabe", committedOnly: true,
+		intendedUntrackedSelection: { argumentTokens: tokensWithBaseRef, value: '{"selection":true}' },
+	});
+	assert.deepEqual(sameValueQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--base-ref=cafebabe",
+		"--committed-only",
+	]);
+});
+
+test("targetStatus appends --committed-only when the submission's same base-ref is missing it, and skips it when already present", async () => {
+	const missingQueue = queuedTargetStatusAdapter();
+	const tokensWithBaseRefOnly = [...SUBMITTED_PROVIDER_TOKENS, "--base-ref", "cafebabe"];
+	await targetStatusClient(missingQueue.adapter).targetStatus({
+		cwd: "/repo", baseRef: "cafebabe", committedOnly: true,
+		intendedUntrackedSelection: { argumentTokens: tokensWithBaseRefOnly, value: '{"selection":true}' },
+	});
+	assert.deepEqual(missingQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--base-ref", "cafebabe",
+		"--committed-only",
+	]);
+
+	const presentQueue = queuedTargetStatusAdapter();
+	const tokensWithBoth = [...SUBMITTED_PROVIDER_TOKENS, "--base-ref=cafebabe", "--committed-only=true"];
+	await targetStatusClient(presentQueue.adapter).targetStatus({
+		cwd: "/repo", baseRef: "cafebabe", committedOnly: true,
+		intendedUntrackedSelection: { argumentTokens: tokensWithBoth, value: '{"selection":true}' },
+	});
+	assert.deepEqual(presentQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--base-ref=cafebabe", "--committed-only=true",
+	]);
+
+	const committedOnlyQueue = queuedTargetStatusAdapter();
+	const tokensWithCommittedOnly = [...SUBMITTED_PROVIDER_TOKENS, "--committed-only"];
+	await targetStatusClient(committedOnlyQueue.adapter).targetStatus({
+		cwd: "/repo", baseRef: "cafebabe", committedOnly: true,
+		intendedUntrackedSelection: { argumentTokens: tokensWithCommittedOnly, value: '{"selection":true}' },
+	});
+	assert.deepEqual(committedOnlyQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--committed-only",
+		"--base-ref", "cafebabe",
+	]);
+});
+
+test("targetStatus forwards --lineage on the submitted branch, skips a matching value, and rejects a conflicting one", async () => {
+	const forwardedQueue = queuedTargetStatusAdapter();
+	await targetStatusClient(forwardedQueue.adapter).targetStatus({
+		cwd: "/repo", lineageId: "review-abc123",
+		intendedUntrackedSelection: { argumentTokens: SUBMITTED_PROVIDER_TOKENS, value: '{"selection":true}' },
+	});
+	assert.deepEqual(forwardedQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--lineage", "review-abc123",
+	]);
+
+	const sameValueQueue = queuedTargetStatusAdapter();
+	const tokensWithLineage = [...SUBMITTED_PROVIDER_TOKENS, "--lineage=review-abc123"];
+	await targetStatusClient(sameValueQueue.adapter).targetStatus({
+		cwd: "/repo", lineageId: "review-abc123",
+		intendedUntrackedSelection: { argumentTokens: tokensWithLineage, value: '{"selection":true}' },
+	});
+	assert.deepEqual(sameValueQueue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--lineage=review-abc123",
+	]);
+
+	const conflictQueue = queuedTargetStatusAdapter();
+	await assert.rejects(
+		() => targetStatusClient(conflictQueue.adapter).targetStatus({
+			cwd: "/repo", lineageId: "review-other",
+			intendedUntrackedSelection: { argumentTokens: tokensWithLineage, value: '{"selection":true}' },
+		}),
+		TypeError,
+	);
+	assert.equal(conflictQueue.calls.length, 0);
+});
+
+test("targetStatus forwards base-ref and lineage together on the submitted branch, base-ref first", async () => {
+	const queue = queuedTargetStatusAdapter();
+	await targetStatusClient(queue.adapter).targetStatus({
+		cwd: "/repo", baseRef: "deadbeef", committedOnly: true, lineageId: "review-abc123",
+		intendedUntrackedSelection: { argumentTokens: SUBMITTED_PROVIDER_TOKENS, value: '{"selection":true}' },
+	});
+	assert.deepEqual(queue.calls[0], [
+		"review", "status", "--cwd", "/repo",
+		"--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", '--intended-untracked-selection={"selection":true}',
+		"--base-ref", "deadbeef", "--committed-only",
+		"--lineage", "review-abc123",
+	]);
+});
+
+test("targetStatus rejects a dangling or empty --base-ref/--lineage in the submitted tokens", async () => {
+	for (const tokens of [
+		[...SUBMITTED_PROVIDER_TOKENS, "--base-ref"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--base-ref="],
+		[...SUBMITTED_PROVIDER_TOKENS, "--lineage"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--lineage="],
+	]) {
+		const queue = queuedTargetStatusAdapter();
+		await assert.rejects(
+			() => targetStatusClient(queue.adapter).targetStatus({
+				cwd: "/repo",
+				intendedUntrackedSelection: { argumentTokens: tokens, value: '{"selection":true}' },
+			}),
+			TypeError,
+			JSON.stringify(tokens),
+		);
+		assert.equal(queue.calls.length, 0, JSON.stringify(tokens));
+	}
+});
+
+test("targetStatus rejects ambiguous or malformed provider selectors before executing STATUS", async () => {
+	for (const tokens of [
+		[...SUBMITTED_PROVIDER_TOKENS, "--committed-only=false"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--committed-only=garbage"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--committed-only=true", "--committed-only=true"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--committed-only", "--committed-only=true"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--base-ref=deadbeef", "--base-ref", "deadbeef"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--lineage=review-a", "--lineage", "review-a"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--base-ref", "--lineage=review-a"],
+		[...SUBMITTED_PROVIDER_TOKENS, "--lineage", "--base-ref=deadbeef"],
+	]) {
+		const queue = queuedTargetStatusAdapter();
+		await assert.rejects(() => targetStatusClient(queue.adapter).targetStatus({
+			cwd: "/repo", intendedUntrackedSelection: { argumentTokens: tokens, value: '{"selection":true}' },
+		}), TypeError, JSON.stringify(tokens));
+		assert.equal(queue.calls.length, 0, JSON.stringify(tokens));
+	}
+});
+
 test("START/v4 accepts only its reviewing status continuation and preserves v3 strictness", () => {
 	for (const action of ["created", "replayed"] as const) {
 		const start = reviewingStartV4(action);
@@ -747,7 +947,7 @@ test("review-acknowledged/v1 is disjoint from every prior captured identity in b
 		["status/v3", decodeReviewStatusV3],
 		["start/v3", decodeReviewStartV3],
 		["start/v4", decodeReviewStartV4],
-		["capabilities/v2", decodeReviewCapabilitiesV2],
+		["capabilities/v2", (value) => decodeReviewCapabilitiesV2(value, CAPTURED_DIGEST)],
 		["consent/v2", decodeReviewConsentV2],
 		["consent/v3", decodeReviewConsentV3],
 		["last-event-closure/v1", decodeReviewLastEventClosureV1],
@@ -804,3 +1004,23 @@ test("v7 escalation strictly decodes all causes and optional refuter evidence",
 		assert.throws(() => decodeReviewStatusV3({ ...escalatedStatusV7(), schema: `gentle-ai.review-integration.status/v${version}` }), /not allowed/);
 	}
 });
+
+test("START/v4 accepts every risk reason code and signal the published start schema allows", () => {
+	// gentle-ai publishes dangerous_sink (code and signal) and agent_escalation
+	// (code and signal) in start-v4.schema.json; a high-risk START that names
+	// them must decode instead of failing as schema-incompatible (#5374).
+	const start = reviewingStartV4();
+	start.risk_reasons = [
+		{ code: "dangerous_sink", signal: "dangerous_sink", path: "auth/session.py" },
+		{ code: "hot_path", signal: "auth", path: "auth/session.py" },
+		{ code: "process_boundary", signal: "shell_process", path: "auth/session.py" },
+		{ code: "agent_escalation", signal: "agent_escalation" },
+	];
+	const decoded = decodeReviewStartV4(start);
+	assert.deepEqual(decoded.riskReasons.map((reason) => reason.code), ["dangerous_sink", "hot_path", "process_boundary", "agent_escalation"]);
+	assert.deepEqual(decoded.riskReasons.map((reason) => reason.signal), ["dangerous_sink", "auth", "shell_process", "agent_escalation"]);
+
+	const unknown = reviewingStartV4();
+	unknown.risk_reasons = [{ code: "code_from_a_newer_cli" }];
+	assert.throws(() => decodeReviewStartV4(unknown), /risk_reasons\[0\]\.code is unsupported/);
+});

package/tests/review-json-arguments.test.ts

@@ -0,0 +1,167 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { stream as streamAnthropic } from "@earendil-works/pi-ai/api/anthropic-messages";
+import { normalizeContext, validateToolArguments, type Model, type ToolCall } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { NativeReviewCli } from "../lib/native-review-cli.ts";
+import { __testing, createGentleAiExtension } from "../extensions/gentle-ai.ts";
+
+function registeredTools(): Map<string, any> {
+	const tools = new Map<string, any>();
+	createGentleAiExtension({ nativeReviewCli: null })({
+		on() {}, registerCommand() {}, registerTool(tool: any) { tools.set(tool.name, tool); },
+	} as unknown as ExtensionAPI);
+	return tools;
+}
+
+const tools = registeredTools();
+function validate(name: string, args: Record<string, unknown>): any {
+	return validateToolArguments(tools.get(name), { type: "toolCall", id: "json-arguments", name, arguments: args as ToolCall["arguments"] });
+}
+
+test("registered review schemas have plain object parameters with no root-level union combinators (#1698)", () => {
+	for (const [name, tool] of tools) {
+		assert.equal(tool.parameters.type, "object", `${name} parameters must be an object`);
+		assert.equal(tool.parameters.anyOf, undefined, `${name} parameters must not have root-level anyOf`);
+		assert.equal(tool.parameters.oneOf, undefined, `${name} parameters must not have root-level oneOf`);
+		assert.equal(tool.parameters.allOf, undefined, `${name} parameters must not have root-level allOf`);
+	}
+});
+
+test("public Anthropic non-strict adapter preserves the complete review tool declarations", async () => {
+	const model: Model<"anthropic-messages"> = {
+		id: "claude-sonnet-4-20250514", name: "Payload-only model", api: "anthropic-messages", provider: "anthropic",
+		baseUrl: "https://example.invalid", input: ["text"], reasoning: false,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 200000, maxTokens: 1024,
+		compat: { supportsStrictTools: false },
+	};
+	let payload: any;
+	let transportCalls = 0;
+	const sentinel = "PAYLOAD_CAPTURED_BEFORE_TRANSPORT";
+	const result = await streamAnthropic(model, normalizeContext({ messages: [{ role: "user", content: "payload only", timestamp: 0 }], tools: [...tools.values()] }), {
+		apiKey: "dummy-test-key", env: {},
+		onPayload(value) { payload = value; throw new Error(sentinel); },
+		fetch: async () => { transportCalls++; throw new Error("TRANSPORT_MUST_NOT_RUN"); },
+	}).result();
+	assert.equal(transportCalls, 0);
+	assert.equal(result.stopReason, "error");
+	assert.match(result.errorMessage ?? "", new RegExp(sentinel));
+	assert.ok(payload, "adapter reached payload callback");
+	const emitted = new Map<string, any>(payload.tools.map((tool: any) => [tool.name, tool.input_schema]));
+	const controller = emitted.get("gentle_review");
+	assert.equal(controller.type, "object");
+	assert.deepEqual(controller.required, ["operation"]);
+	assert.deepEqual(Object.keys(controller.properties).sort(), ["operation", "lineageId", "selectionBinding", "intendedUntracked", "untrackedScope", "changeName", "idempotencyKey", "transition", "input", "outputPath", "inputPath", "operationId", "lineageIds", "workspaceRoot"].sort());
+	assert.ok(controller.properties.input.anyOf.some((schema: any) => schema.type === "object"));
+	assert.match(controller.properties.input.description, /START\/ASSESS only/);
+	assert.deepEqual(controller.properties.operation.enum, tools.get("gentle_review").parameters.properties.operation.enum);
+	for (const name of ["gentle_review_capture", "gentle_review_capture_group"]) {
+		const schema = emitted.get(name);
+		assert.deepEqual(schema.required, tools.get(name).parameters.required);
+		assert.deepEqual(schema.properties, tools.get(name).parameters.properties);
+	}
+	assert.ok(emitted.get("gentle_review_capture_group").properties.collectBindings.items.anyOf.some((schema: any) => schema.type === "object"));
+	// Anthropic omits the root operation constraints. Even its broader nullable
+	// declaration cannot grant consent, maintenance, or native execution.
+	let nativeCalls = 0;
+	const native = new Proxy({}, { get() { return async () => { nativeCalls++; }; } }) as NativeReviewCli;
+	for (const operation of ["start", "assess", "answer-consent", "inspect", "reset", "recover"]) {
+		const inputs = operation === "start" || operation === "assess" ? [null] : [null, { consentBinding: "opaque", answer: "granted" }];
+		for (const input of inputs) {
+			const args = validateToolArguments({ ...tools.get("gentle_review"), parameters: controller }, { type: "toolCall", id: "provider-shell", name: "gentle_review", arguments: { operation, input } });
+			assert.deepEqual(args.input, input, "provider-shell validation accepts and retains this input");
+			await assert.rejects(__testing.executeReviewControllerOperation(args, process.cwd(), native));
+		}
+	}
+	assert.equal(nativeCalls, 0);
+});
+
+const binding = { name: "reviewer_result", arguments: [] };
+test("registered review schemas admit START/ASSESS objects and ordered capture objects", () => {
+	for (const operation of ["start", "assess"]) {
+		const input = operation === "start" ? { mode: "ordinary" } : { committedOnly: true, baseRef: "HEAD" };
+		assert.deepEqual(validate("gentle_review", { operation, input }).input, input);
+		assert.equal(__testing.parseReviewControllerParameters(validate("gentle_review", { operation, input })).input, JSON.stringify(input));
+	}
+	assert.deepEqual(validate("gentle_review_capture", { lineageId: "l", collectBinding: binding }).collectBinding, binding);
+	const ordered = [binding, ' { "name": "second", "arguments": [] } '];
+	const args = validate("gentle_review_capture_group", { lineageId: "l", collectBindings: ordered });
+	assert.deepEqual(__testing.parseReviewCaptureGroupParameters(args).collectBindings, [JSON.stringify(binding), ordered[1]]);
+});
+
+test("validated ASSESS objects reach the mocked native facade with parsed fields", async () => {
+	const requests: unknown[] = [];
+	const native = { assess: async (request: unknown) => { requests.push(request); throw new Error("mock assessment unavailable"); } } as unknown as NativeReviewCli;
+	for (const input of [{ baseRef: "HEAD", committedOnly: true, nativeReviewOutcome: "unknown" }, ' { "baseRef": "HEAD", "committedOnly": true, "nativeReviewOutcome": "unknown" } ']) {
+		await __testing.executeReviewControllerOperation(validate("gentle_review", { operation: "assess", input }), process.cwd(), native);
+	}
+	assert.equal(requests.length, 2);
+	assert.deepEqual(requests[0], { cwd: process.cwd(), baseRef: "HEAD", committedOnly: true });
+	assert.deepEqual(requests[1], requests[0]);
+});
+
+test("serialized inputs remain byte-for-byte unchanged at validation and facade parsing", () => {
+	const input = ' \n{ "mode" : "ordinary" }\t';
+	for (const operation of ["start", "assess", "answer-consent", "reset", "recover"]) {
+		assert.equal(__testing.parseReviewControllerParameters(validate("gentle_review", { operation, input })).input, input);
+	}
+	const collectBinding = ' { "name": "reviewer_result", "arguments": [] }\n';
+	assert.equal(__testing.parseReviewCaptureParameters(validate("gentle_review_capture", { lineageId: "l", collectBinding })).collectBinding, collectBinding);
+});
+
+test("actual validation rejects arrays, null and coerced primitives rather than admitting native calls", async () => {
+	for (const value of [[], 123, true, "123", "null", "[]"]) {
+		for (const operation of ["start", "assess", "answer-consent", "inspect", "reset", "recover"]) {
+			assert.throws(() => validate("gentle_review", { operation, input: value }), /Validation failed/);
+		}
+		assert.throws(() => validate("gentle_review_capture", { lineageId: "l", collectBinding: value }), /Validation failed/);
+		assert.throws(() => validate("gentle_review_capture_group", { lineageId: "l", collectBindings: [binding, value] }), /Validation failed/);
+	}
+	let calls = 0;
+	const native = new Proxy({}, { get() { return async () => { calls++; throw new Error("unexpected native execution"); }; } }) as NativeReviewCli;
+	for (const value of [null, false]) {
+		for (const operation of ["start", "assess", "answer-consent", "inspect", "reset", "recover"]) {
+			const validated = validate("gentle_review", { operation, input: value });
+			assert.equal(validated.input, null, "nullable shell preserves null instead of stripping it to omitted");
+			await assert.rejects(__testing.executeReviewControllerOperation(validated, process.cwd(), native));
+		}
+		assert.throws(() => validate("gentle_review_capture", { lineageId: "l", collectBinding: value }), /Validation failed/);
+		assert.throws(() => validate("gentle_review_capture_group", { lineageId: "l", collectBindings: [binding, value] }), /Validation failed/);
+	}
+	assert.equal(calls, 0);
+});
+
+test("all other controller operations keep object input fail-closed at the facade boundary (#1698)", async () => {
+	const operations = (tools.get("gentle_review").parameters.properties.operation.enum as string[]).filter((operation) => operation !== "start" && operation !== "assess" && operation !== "select-intended-untracked");
+	let calls = 0;
+	const native = new Proxy({}, { get() { return async () => { calls++; throw new Error("unexpected native execution"); }; } }) as NativeReviewCli;
+	for (const operation of operations) {
+		const args = { operation, lineageId: "l", input: { consentBinding: "opaque", answer: "granted" } };
+		await assert.rejects(
+			__testing.executeReviewControllerOperation(args, process.cwd(), native),
+			/Review controller input must be a string/,
+		);
+	}
+	assert.equal(calls, 0);
+});
+
+test("facade rejects non-JSON runtime objects without lossy serialization or native execution", async () => {
+	const cyclic: any = {}; cyclic.self = cyclic;
+	const accessor = Object.defineProperty({}, "mode", { enumerable: true, get() { throw new Error("getter must not execute"); } });
+	const hidden = Object.defineProperty({}, "hidden", { value: 1 });
+	const extended: any[] = [1]; Object.assign(extended, { extra: 1 });
+	const invalid = [null, [], 1, true, undefined, new Date(), cyclic, accessor, hidden, new Proxy({}, {}), { x: new Proxy({}, {}) },
+		{ x: undefined }, { x: NaN }, { x: Infinity }, { x: -0 }, { x: 1n }, { x() {} },
+		{ [Symbol("x")]: 1 }, { x: new Array(2) }, { x: extended }, { toJSON() { return {}; } }];
+	let calls = 0;
+	const native = new Proxy({}, { get() { return async () => { calls++; }; } }) as NativeReviewCli;
+	for (const input of invalid) {
+		for (const operation of ["start", "assess"]) {
+			await assert.rejects(__testing.executeReviewControllerOperation({ operation, input }, process.cwd(), native), /Review JSON argument/);
+		}
+		assert.throws(() => __testing.parseReviewCaptureParameters({ lineageId: "l", collectBinding: input }), /Review JSON argument/);
+		assert.throws(() => __testing.parseReviewCaptureGroupParameters({ lineageId: "l", collectBindings: [binding, input] }), /Review JSON argument/);
+	}
+	assert.equal(calls, 0);
+});
+

package/tests/review-last-event-closure.test.ts

@@ -34,21 +34,28 @@ function closure(operation: string, lineageId: string): Record<string, unknown>
 	};
 }
 
-function bindingArguments(lineageId: string, suffix = "0"): ReviewCollectInputV3["arguments"] {
+function fixtureLens(suffix: string) {
+	const lenses = ["review-risk", "review-reliability", "review-resilience", "review-readability"] as const;
+	const lens = lenses[Number(suffix)];
+	assert.ok(lens, "fixture order must select an authoritative lens");
+	return lens;
+}
+
+function bindingArguments(lineageId: string, suffix = "0", subjectHash = SHA): ReviewCollectInputV3["arguments"] {
 	return [
 		{ name: "lineage", value: lineageId, token: `--lineage=${lineageId}` },
 		{ name: "expected-revision", value: SHA, token: `--expected-revision=${SHA}` },
 		{ name: "target", value: SHA, token: `--target=${SHA}` },
 		{ name: "repository-context", value: `rctx1_${"c".repeat(64)}`, token: `--repository-context=rctx1_${"c".repeat(64)}` },
-		{ name: "lens", value: `review-risk-${suffix}`, token: `--lens=review-risk-${suffix}` },
+		{ name: "lens", value: fixtureLens(suffix), token: `--lens=${fixtureLens(suffix)}` },
 		{ name: "order", value: suffix, token: `--order=${suffix}` },
-		{ name: "subject-hash", value: SHA, token: `--subject-hash=${SHA}` },
+		{ name: "subject-hash", value: subjectHash, token: `--subject-hash=${subjectHash}` },
 	];
 }
 
-function materializeInput(lineageId: string, suffix = "0"): ReviewCollectInputV3 {
+function materializeInput(lineageId: string, suffix = "0", subjectHash = SHA): ReviewCollectInputV3 {
 	const arguments_ = [
-		...bindingArguments(lineageId, suffix),
+		...bindingArguments(lineageId, suffix, subjectHash),
 		{ name: "agent", value: "pi", token: "--agent=pi" },
 		{ name: "materialize", value: "true", token: "--materialize=true" },
 	];
@@ -59,19 +66,19 @@ function materializeInput(lineageId: string, suffix = "0"): ReviewCollectInputV3
 		arguments: arguments_,
 		artifactSubject: {
 			schema: "gentle-ai.review-artifact-subject/v2",
-			subjectHash: SHA,
+			subjectHash,
 			lineageId,
 			authorityRevision: SHA,
 			targetIdentity: SHA,
 			baseTree: TREE,
 			candidateTree: TREE,
 			changedPathManifestSha256: SHA,
-			lens: `review-risk-${suffix}`,
+			lens: fixtureLens(suffix),
 			selectedOrder: Number(suffix),
 		},
 		submission: {
 			operationToken: "capture-result",
-			argumentTokens: [...bindingArguments(lineageId, suffix).map((argument) => argument.token!), "--input={{value}}"],
+			argumentTokens: [...bindingArguments(lineageId, suffix, subjectHash).map((argument) => argument.token!), "--input={{value}}"],
 			values: [{ slot: "reviewer_result", domain: "artifact_path_or_stdin", substitutionLocation: 7 }],
 		},
 	};
@@ -195,6 +202,148 @@ test("approved closure preserves complete admitted reviewer results before ackno
 	assert.throws(() => decodeReviewLastEventClosureV1(correctionPlan), /reviewer_results requires approved state/);
 });
 
+test("escalated closures preserve the native diagnostic evidence without granting a continuation", () => {
+	const evidence = { cause: "unknown_causality", finding_ids: ["R3-001"], refuter_outcomes: [{ finding_id: "R3-001", outcome: "inconclusive", proof: "causal origin could not be established" }] };
+	for (const operation of ["review/capture-result", "review.capture-refuter", "review/capture-validation"]) {
+		const payload = { ...closure(operation, "escalated-evidence"), state: "escalated", escalation: evidence };
+		const decoded = decodeReviewLastEventClosureV1(payload);
+		assert.equal(decoded.state, "escalated");
+		assert.deepEqual(decoded.escalation, {
+			cause: "unknown_causality", findingIds: ["R3-001"],
+			refuterOutcomes: [{ findingId: "R3-001", outcome: "inconclusive", proof: "causal origin could not be established" }],
+		});
+		assert.equal(decoded.acknowledgement, undefined);
+		assert.equal(decoded.statusContinuation, undefined);
+		const historical = { ...payload } as Record<string, unknown>;
+		delete historical.escalation;
+		assert.equal(decodeReviewLastEventClosureV1(historical).state, "escalated", "older provider closures remain readable");
+	}
+});
+
+test("closure escalation is strict diagnostic data restricted to escalated state", () => {
+	const evidence = { cause: "unknown_causality", finding_ids: ["R3-001"] };
+	const payload = { ...closure("review/capture-result", "strict-escalation"), state: "escalated", escalation: evidence };
+	for (const invalid of [
+		null, undefined, {}, { ...evidence, cause: "unknown-new-cause" },
+		{ cause: evidence.cause }, { ...evidence, finding_ids: [""] },
+		{ ...evidence, unexpected: true }, { ...evidence, refuter_outcomes: null },
+		{ ...evidence, refuter_outcomes: [{ finding_id: "R3-001", outcome: "approved", proof: "unsupported outcome" }] },
+		{ ...evidence, refuter_outcomes: [{ finding_id: "R3-001", outcome: "inconclusive", proof: "proof", unexpected: true }] },
+	]) assert.throws(() => decodeReviewLastEventClosureV1({ ...payload, escalation: invalid }), TypeError);
+	for (const operation of ["review/capture-result", "review.capture-correction-plan"]) {
+		assert.throws(() => decodeReviewLastEventClosureV1({ ...closure(operation, "wrong-state"), escalation: evidence }), /escalation requires escalated state/);
+	}
+	assert.throws(() => decodeReviewLastEventClosureV1({ ...payload, unexpected: true }), /is not allowed/);
+});
+
+function targetedValidationClosure(): Record<string, unknown> {
+	return {
+		...closure("review/capture-validation", "validation-evidence"), state: "escalated",
+		escalation: { cause: "targeted_validator_rejected", finding_ids: ["R3-001"] },
+		targeted_validator_evidence: {
+			targeted_validation_request_hash: SHA, correction_target_identity: SHA,
+			original_criteria: { passed: false, evidence: ["original criterion still fails"] },
+			correction_regression: { passed: false, evidence: ["correction regressed a second path"], regressions: [{ location: "lib/session.ts:4", claim: "changed behavior regressed", proof_refs: ["observed result"] }] },
+			follow_ups: [{ observation: "inspect the remaining behavior", proof_refs: ["observed result"] }],
+		},
+	};
+}
+
+test("TS and runtime preserve targeted-validator diagnostics without granting authority", async () => {
+	const runtime = await import(new URL("../runtime/review-integration-v2.mjs", import.meta.url).href);
+	for (const decode of [decodeReviewLastEventClosureV1, runtime.decodeReviewLastEventClosureV1]) {
+		const payload = targetedValidationClosure();
+		const decoded = decode(payload);
+		assert.deepEqual(decoded.targetedValidatorEvidence.raw, payload.targeted_validator_evidence);
+		assert.equal(decoded.targetedValidatorEvidence.targetedValidationRequestHash, SHA);
+		assert.equal(decoded.targetedValidatorEvidence.correctionTargetIdentity, SHA);
+		assert.equal(decoded.targetedValidatorEvidence.originalCriteria.passed, false);
+		assert.deepEqual(decoded.targetedValidatorEvidence.correctionRegression.regressions[0].proofRefs, ["observed result"]);
+		assert.deepEqual(decoded.targetedValidatorEvidence.followUps[0].proofRefs, ["observed result"]);
+		assert.equal(decoded.acknowledgement, undefined);
+		assert.equal(decoded.statusContinuation, undefined);
+		const historical = { ...payload };
+		delete historical.targeted_validator_evidence;
+		assert.equal(decode(historical).targetedValidatorEvidence, undefined);
+		assert.throws(() => decode({ ...payload, acknowledgement: {} }), /acknowledgement requires approved state/);
+		assert.throws(() => decode({ ...payload, status_continuation: {} }), /status_continuation/);
+	}
+});
+
+test("targeted-validator evidence is strict and exclusive to escalated validation closures", async () => {
+	const runtime = await import(new URL("../runtime/review-integration-v2.mjs", import.meta.url).href);
+	const payload = targetedValidationClosure();
+	const evidence = payload.targeted_validator_evidence as Record<string, unknown>;
+	for (const decode of [decodeReviewLastEventClosureV1, runtime.decodeReviewLastEventClosureV1]) {
+		for (const operation of ["review/capture-result", "review.capture-refuter", "review.capture-correction-plan", "review/capture-validation"]) {
+			for (const state of ["approved", "correction_required", "escalated"]) {
+				if (operation === "review/capture-validation" && state === "escalated") continue;
+				assert.throws(() => decode({ ...payload, operation, state, escalation: undefined }), /targeted_validator_evidence requires escalated review\/capture-validation/);
+			}
+		}
+		for (const invalid of [
+			null, undefined, {}, { ...evidence, extra: true },
+			{ ...evidence, targeted_validation_request_hash: "bad-hash" }, { ...evidence, correction_target_identity: "bad-hash" },
+			{ ...evidence, original_criteria: null }, { ...evidence, original_criteria: { passed: "false", evidence: ["proof"] } },
+			{ ...evidence, original_criteria: { passed: false, evidence: [] } }, { ...evidence, original_criteria: { passed: false, evidence: [""] } },
+			{ ...evidence, original_criteria: { passed: false, evidence: [" \t\n"] } }, { ...evidence, correction_regression: { passed: true, evidence: ["\u0085\u00a0"] } },
+			{ ...evidence, correction_regression: { passed: true, evidence: ["proof"], extra: true } },
+			{ ...evidence, correction_regression: { passed: false, evidence: ["proof"], regressions: [{ location: "path:1", claim: "claim", proof_refs: [] }] } },
+			{ ...evidence, correction_regression: { passed: false, evidence: ["proof"], regressions: [{ location: "path:1", claim: "claim", proof_refs: ["proof"], extra: true }] } },
+			{ ...evidence, follow_ups: null }, { ...evidence, follow_ups: [{ observation: "note", proof_refs: [] }] },
+			{ ...evidence, follow_ups: [{ observation: "note", proof_refs: ["proof"], extra: true }] },
+		]) assert.throws(() => decode({ ...payload, targeted_validator_evidence: invalid }), TypeError);
+		const minimal = { ...evidence, original_criteria: { passed: false, evidence: [" original observation "] }, correction_regression: { passed: true, evidence: ["no regression"] }, follow_ups: [] };
+		assert.deepEqual(decode({ ...payload, targeted_validator_evidence: minimal }).targetedValidatorEvidence.raw, minimal);
+	}
+});
+
+test("single-lens terminal escalation returns its evidence directly without reconciliation or replay", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const lineageId = "single-escalation", input = materializeInput(lineageId);
+	const escalation = { cause: "unknown_causality", finding_ids: ["R3-001"] };
+	let statusCalls = 0, captures = 0;
+	const native = { targetStatus: async () => { statusCalls += 1; return status(lineageId, [input]); } } as unknown as NativeReviewCli;
+	__testing.setReviewHostRelayRunnerForTesting(async () => {
+		captures += 1;
+		return { promptByteLength: 1, resultByteLength: 1, submission: JSON.stringify({ ...closure("review/capture-result", lineageId), state: "escalated", escalation }) };
+	});
+	const result = await capture(lineageId, input, native, { reviewerRunAcknowledged: true });
+	assert.equal(result.status, "closed");
+	assert.equal(result.state, "escalated");
+	assert.deepEqual((result.closure as Record<string, unknown>).escalation, escalation);
+	assert.equal(result.next_action, undefined);
+	assert.equal(statusCalls, 1);
+	assert.equal(captures, 1);
+});
+
+test("one- and four-lens groups count the final escalated submission and preserve its native evidence", async (t) => {
+	t.after(() => __testing.setReviewHostRelayGroupRunnersForTesting());
+	for (const count of [1, 4]) {
+		const lineageId = `group-escalation-${count}`;
+		const inputs = Array.from({ length: count }, (_, index) => materializeInput(lineageId, String(index), `sha256:${String(index + 1).repeat(64)}`));
+		const escalation = { cause: "unknown_causality", finding_ids: ["R3-001"], refuter_outcomes: [{ finding_id: "R3-001", outcome: "inconclusive", proof: "causal origin could not be established" }] };
+		let submitted = 0, statusCalls = 0;
+		const native = { targetStatus: async () => {
+			statusCalls += 1;
+			return { ...status(lineageId, inputs.slice(submitted)), repositoryContext: { capability: "review.opaque_repository_context", handle: `rctx1_${"c".repeat(64)}`, revision: SHA, targetIdentity: SHA } };
+		} } as unknown as NativeReviewCli;
+		__testing.setReviewHostRelayGroupRunnersForTesting(async (requests) => requests.map((request) => ({ request, promptByteLength: 1, resultByteLength: 1 })), async () => {
+			submitted += 1;
+			return { promptByteLength: 1, resultByteLength: 1, submission: submitted === count ? JSON.stringify({ ...closure("review/capture-result", lineageId), state: "escalated", escalation }) : '{"admission_decision":"completed"}' };
+		});
+		const result = await __testing.executeReviewCaptureGroupOperation({ lineageId, collectBindings: inputs, reviewerRunAcknowledged: true }, process.cwd(), native);
+		assert.equal(result.status, "closed", JSON.stringify(result));
+		assert.equal(result.state, "escalated");
+		assert.equal(result.submitted_reviewers, count);
+		assert.equal(result.mutation_outcome, "completed");
+		assert.deepEqual((result.closure as Record<string, unknown>).escalation, escalation);
+		assert.equal(result.next_action, undefined);
+		assert.equal(submitted, count);
+		assert.equal(statusCalls, count + 1, "closure triggers no post-success STATUS");
+	}
+});
+
 test("retired legacy client no longer exposes a FINALIZE route", () => {
 	assert.equal("NativeReviewCliV214" in nativeReviewCliModule, false);
 	assert.equal("NativeReviewCliV213" in nativeReviewCliModule, false);