gentle-pi 3.2.1 → 3.4.0

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

@@ -440,6 +440,67 @@ test("capabilities/v2.5 negotiates the v2.6.0 advertisement and status/v7 decode
 	assert.throws(() => decodeReviewStatusV3(v6WithDigest), /eligible_untracked_inventory/);
 });
 
+test("capabilities/v2.6 negotiates the v3.4.0 advertisement on the same v2.5 requirement floor", () => {
+	// gentle-ai v3.4.0 advertises capabilities/v2.6: the v2.5 surface plus
+	// status/v8 (status/v6 and status/v7 stay advertised for compatibility).
+	// The `review assess` review_due/review_due_reason/next_transition
+	// additions are a separate schema (gentle-ai.review-assessment/v1),
+	// unrelated to this negotiated capabilities surface.
+	const v26 = clone(fixture(DEV_FIXTURES, "capabilities-v2.2.captured.json") as JsonObject);
+	v26.schema = "gentle-ai.review-integration.capabilities/v2.6";
+	(v26.protocol as JsonObject).minor = 6;
+	const features = v26.features as JsonObject;
+	features.mandatory = (features.mandatory as JsonObject[]).filter((feature) =>
+		!["exact_receipt_replay", "five_delivery_gates", "sdd_receipt_binding"].includes(feature.name as string));
+	v26.schemas = [
+		...(v26.schemas as string[]).map((schema) => schema
+			.replace("capabilities/v2.2", "capabilities/v2.6")
+			.replace("start/v3", "start/v4")
+			.replace("status/v5", "status/v6")),
+		"gentle-ai.review-intended-untracked-selection/v1",
+		"gentle-ai.review-integration.status/v7",
+		"gentle-ai.review-integration.status/v8",
+	];
+	const decoded = decodeReviewCapabilitiesV2(v26, CAPTURED_DIGEST);
+	assert.equal(decoded.schemas.has("gentle-ai.review-integration.status/v6"), true);
+	// The negotiated set is the v2.5 requirement floor unchanged; status/v7
+	// and status/v8 are additive and never required, so an advertisement
+	// without either still negotiates.
+	const withoutV7V8 = clone(v26);
+	withoutV7V8.schemas = (withoutV7V8.schemas as string[]).filter((schema) => !["gentle-ai.review-integration.status/v7", "gentle-ai.review-integration.status/v8"].includes(schema as string));
+	assert.equal(decodeReviewCapabilitiesV2(withoutV7V8, CAPTURED_DIGEST).schemas.has("gentle-ai.review-integration.status/v6"), true);
+
+	// status/v6 stays required: v7/v8 are additive extensions, not a replacement.
+	const missingStatusV6 = clone(v26);
+	missingStatusV6.schemas = (missingStatusV6.schemas as string[]).filter((schema) => schema !== "gentle-ai.review-integration.status/v6");
+	assert.throws(() => decodeReviewCapabilitiesV2(missingStatusV6, CAPTURED_DIGEST), /status\/v6/);
+});
+
+// status/v8 (gentle-ai main, PR #4765; the current released contract) only
+// extended the reviewer-result transition for OpenCode provider tasks -- no
+// new top-level key -- so it decodes on the exact v7 surface: same optional
+// eligible_untracked_inventory digest, same rejection of a v6 envelope
+// carrying it. status/v9 (the sibling gentle-ai branch's contract, ahead of
+// the released v8) adds nothing new at the top level either; its one
+// addition -- the host-mediated role submission -- lives in
+// next_transition.collect.inputs and is covered by
+// tests/review-integration-v2.test.ts's "v9 host-mediated" tests.
+test("status/v8 and status/v9 decode with their exact identity on the v7 surface", () => {
+	const v8 = initialIntendedUntrackedStatusV6();
+	v8.schema = "gentle-ai.review-integration.status/v8";
+	v8.eligible_untracked_inventory = sha("e");
+	const decodedV8 = decodeReviewStatusV3(v8);
+	assert.equal(decodedV8.raw.schema, "gentle-ai.review-integration.status/v8");
+	assert.equal(decodedV8.eligibleUntrackedInventory, sha("e"));
+
+	const v9 = initialIntendedUntrackedStatusV6();
+	v9.schema = "gentle-ai.review-integration.status/v9";
+	v9.eligible_untracked_inventory = sha("e");
+	const decodedV9 = decodeReviewStatusV3(v9);
+	assert.equal(decodedV9.raw.schema, "gentle-ai.review-integration.status/v9");
+	assert.equal(decodedV9.eligibleUntrackedInventory, sha("e"));
+});
+
 test("status/v6 decodes and enforces the intended-untracked selection submission", () => {
 	const decoded = decodeReviewStatusV3(initialIntendedUntrackedStatusV6());
 	const input = decoded.nextTransition?.collect?.inputs[0];

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

@@ -14,6 +14,7 @@ import {
 	decodeReviewProjectionV1,
 	decodeReviewRepairV2,
 	decodeReviewStartV3,
+	decodeReviewStartV4,
 	decodeReviewStatusV3,
 } from "../lib/review-integration-v2.ts";
 
@@ -349,6 +350,35 @@ test("capabilities gates and projections still enforce the required floor", () =
 	assert.throws(() => decode(missingProjection), /projections/);
 });
 
+test("START/v4 preserves provider-generated manifest evidence while retaining exact omitempty validation", () => {
+	const source = fixture<JsonObject>("start.fixture.json");
+	source.schema = "gentle-ai.review-integration.start/v4";
+	source.action = "closed";
+	source.lenses_required = false;
+	source.state = "approved";
+	source.selected_lenses = [];
+	delete source.repository_context;
+	const entry = (source.changed_path_manifest as JsonObject[])[0];
+	entry.generated = true;
+
+	const decoded = decodeReviewStartV4(source);
+	assert.equal(decoded.changedPathManifest?.[0]?.generated, true);
+
+	const omitted = clone(source);
+	delete (omitted.changed_path_manifest as JsonObject[])[0].generated;
+	assert.doesNotThrow(() => decodeReviewStartV4(omitted));
+
+	for (const generated of [false, "true"] as const) {
+		const invalid = clone(source);
+		((invalid.changed_path_manifest as JsonObject[])[0]).generated = generated;
+		assert.throws(() => decodeReviewStartV4(invalid), /generated/);
+	}
+
+	const unknown = clone(source);
+	((unknown.changed_path_manifest as JsonObject[])[0]).unrelated = true;
+	assert.throws(() => decodeReviewStartV4(unknown), /not allowed/);
+});
+
 test("START independently binds base/candidate tree and the target-mode overlay pair", () => {
 	const source = fixture<JsonObject>("start.fixture.json");
 	const decoded = decodeReviewStartV3(source);
@@ -818,11 +848,14 @@ test("next_transition decodes the self-contained provider role capture vectors s
 		() => decodeRoleTransition(roleInput("provider_refuter", "review.capture-refuter", "https://gentle-ai.dev/schema/review/reviewer/v1")),
 		/schema must be https:\/\/gentle-ai\.dev\/schema\/review\/refuter\/v1/,
 	);
+	// This fixture decodes on the v5 surface only (no v9): a submission
+	// descriptor on a role input is rejected for lacking the v9 provider
+	// contract, before the materialize/execute discriminator is even read.
 	assert.throws(
 		() => decodeRoleTransition(roleInput("provider_refuter", "review.capture-refuter", "https://gentle-ai.dev/schema/review/refuter/v1", {
 			submission: { operation_token: "capture-refuter", argument_tokens: ["--input={{value}}"], values: [{ slot: "{{value}}", domain: "artifact-path", substitution_location: 0 }] },
 		})),
-		/submission is not allowed on the self-contained/,
+		/submission requires the v9 provider contract/,
 	);
 
 	const validator = roleInput("provider_targeted_validator", "review.capture-validation", "https://gentle-ai.dev/schema/review/validator/v1");
@@ -837,6 +870,87 @@ test("next_transition decodes the self-contained provider role capture vectors s
 	);
 });
 
+// gentle-ai's v9 contract makes the same two role operations host-mediated
+// exactly like a lens materialize slot: the input carries a submission
+// descriptor alongside --materialize=true (never --execute), and the host
+// completes the frozen prompt in-process and submits through that
+// descriptor instead of executing a Go-owned pi subprocess.
+test("next_transition decodes the v9 host-mediated provider role submission form", () => {
+	const materializeArguments = [
+		{ name: "lineage", value: "review-fixture", token: "--lineage=review-fixture" },
+		{ name: "expected-revision", value: digest, token: `--expected-revision=${digest}` },
+		{ name: "target", value: digest, token: `--target=${digest}` },
+		{ name: "repository-context", value: `rctx1_${"c".repeat(64)}`, token: `--repository-context=rctx1_${"c".repeat(64)}` },
+		{ name: "agent", value: "pi", token: "--agent=pi" },
+		{ name: "materialize", value: "true", token: "--materialize=true" },
+	];
+	const roleInput = (name: string, captureOperation: string, schema: string, extra: Record<string, unknown> = {}) => ({
+		kind: "collect",
+		reason_code: "provider_refuter_required",
+		collect: { inputs: [{ name, schema, capture_operation: captureOperation, arguments: materializeArguments, ...extra }] },
+	});
+	// This decoder path is gated on v9 specifically -- the sibling gentle-ai
+	// branch's contract, ahead of the currently-released v8 -- not on v5,
+	// which v8 (and v6/v7) already satisfy.
+	const decodeRoleTransition = (value: unknown) => decodeReviewNextTransitionV3(value, { v9: true });
+	const refuterSubmission = {
+		operation_token: "capture-refuter",
+		argument_tokens: [...materializeArguments.map((argument) => argument.token), "--input={{value}}"],
+		value: { slot: "provider_refuter", domain: "artifact_path_or_stdin", schema: "https://gentle-ai.dev/schema/review/refuter/v1", substitution_location: materializeArguments.length },
+	};
+
+	const refuter = roleInput("provider_refuter", "review.capture-refuter", "https://gentle-ai.dev/schema/review/refuter/v1", { submission: refuterSubmission });
+	const decodedSubmission = decodeRoleTransition(refuter).collect?.inputs[0]?.submission;
+	assert.equal(decodedSubmission?.operationToken, "capture-refuter");
+	assert.equal(decodedSubmission?.argumentTokens.length, materializeArguments.length + 1);
+	assert.deepEqual(decodedSubmission?.values, [{
+		slot: "provider_refuter",
+		domain: "artifact_path_or_stdin",
+		schema: "https://gentle-ai.dev/schema/review/refuter/v1",
+		substitutionLocation: materializeArguments.length,
+	}]);
+
+	// The exact same payload under v8 (or any earlier non-v9 rung) is
+	// rejected: v8 only extended the reviewer-result transition for OpenCode
+	// provider tasks and never renders a role submission descriptor.
+	assert.throws(
+		() => decodeReviewNextTransitionV3(refuter, { v6: true }),
+		/submission requires the v9 provider contract/,
+	);
+
+	// A submission descriptor with no --materialize=true (and no --execute
+	// either) matches neither wire form.
+	assert.throws(
+		() => decodeRoleTransition(roleInput("provider_refuter", "review.capture-refuter", "https://gentle-ai.dev/schema/review/refuter/v1", {
+			submission: refuterSubmission,
+			arguments: materializeArguments.filter((argument) => argument.name !== "materialize"),
+		})),
+		/submission requires --materialize=true/,
+	);
+
+	// --execute alongside a submission descriptor mixes both wire forms on
+	// one input, which is never valid.
+	assert.throws(
+		() => decodeRoleTransition(roleInput("provider_refuter", "review.capture-refuter", "https://gentle-ai.dev/schema/review/refuter/v1", {
+			submission: refuterSubmission,
+			arguments: [...materializeArguments, { name: "execute", value: "true", token: "--execute=true" }],
+		})),
+		/must not carry --execute alongside a submission descriptor/,
+	);
+
+	// The targeted-validator's host-mediated form still requires its
+	// validation_request, exactly like the self-contained vector.
+	const validatorSubmission = {
+		operation_token: "capture-validation",
+		argument_tokens: [...materializeArguments.map((argument) => argument.token), "--input={{value}}"],
+		value: { slot: "provider_targeted_validator", domain: "artifact_path_or_stdin", schema: "https://gentle-ai.dev/schema/review/validator/v1", substitution_location: materializeArguments.length },
+	};
+	assert.throws(
+		() => decodeRoleTransition(roleInput("provider_targeted_validator", "review.capture-validation", "https://gentle-ai.dev/schema/review/validator/v1", { submission: validatorSubmission })),
+		/validation_request is required/,
+	);
+});
+
 test("v5 targeted-validator collect inputs carry the exact provider-owned validation request", () => {
 	const requestHash = `sha256:${"a".repeat(64)}`;
 	const expectedRevision = `sha256:${"b".repeat(64)}`;
@@ -913,6 +1027,37 @@ test("v5 targeted-validator collect inputs carry the exact provider-owned valida
 	}]);
 	assert.deepEqual(decoded.collect?.inputs[0]?.arguments, input.arguments, "provider-rendered arguments must remain unchanged");
 
+	// The same validation_request rides the v9 host-mediated form too: swap
+	// --execute=true for --materialize=true and add the provider-owned
+	// submission descriptor.
+	const materializeArguments = input.arguments.map((argument) => argument.name === "execute" ? { name: "materialize", value: "true", token: "--materialize=true" } : argument);
+	const hostMediatedInput = {
+		...input,
+		arguments: materializeArguments,
+		submission: {
+			operation_token: "capture-validation",
+			argument_tokens: [...materializeArguments.map((argument) => argument.token), "--input={{value}}"],
+			value: { slot: "provider_targeted_validator", domain: "artifact_path_or_stdin", schema: "https://gentle-ai.dev/schema/review/validator/v1", substitution_location: materializeArguments.length },
+		},
+	};
+	const hostMediatedTransition = { kind: "collect" as const, reason_code: "targeted_validation_required", collect: { inputs: [hostMediatedInput] } };
+	const decodedHostMediated = decodeReviewNextTransitionV3(hostMediatedTransition, { v9: true });
+	assert.equal(decodedHostMediated.collect?.inputs[0]?.submission?.operationToken, "capture-validation");
+	assert.deepEqual(decodedHostMediated.collect?.inputs[0]?.submission?.values, [{
+		slot: "provider_targeted_validator",
+		domain: "artifact_path_or_stdin",
+		schema: "https://gentle-ai.dev/schema/review/validator/v1",
+		substitutionLocation: materializeArguments.length,
+	}]);
+	assert.equal(decodedHostMediated.collect?.inputs[0]?.validationRequest?.requestHash, requestHash);
+
+	// The identical v8 surface (v6/v7/v8 all decode collect inputs alike)
+	// rejects the same host-mediated submission: only v9 renders it.
+	assert.throws(
+		() => decodeReviewNextTransitionV3(hostMediatedTransition, { v6: true }),
+		/submission requires the v9 provider contract/,
+	);
+
 	const missingRequest = clone(transition);
 	delete (missingRequest.collect.inputs[0] as JsonObject).validation_request;
 	assert.throws(() => decodeReviewNextTransitionV3(missingRequest, { v5: true }), /validation_request is required/);

package/tests/review-ledger-contract.test.ts

@@ -22,7 +22,6 @@ const README = "README.md";
 const TECHNICAL_REFERENCE = "docs/readme-reference.md";
 const CHAIN = "assets/chains/4r-review.chain.md";
 const SDD_WORKFLOW = "assets/sdd-orchestrator-workflow.md";
-const RELEASE_SKILL = "skills/release/SKILL.md";
 const WORKER = "assets/agents/gentle-ai-worker.md";
 const CANONICAL_LIFECYCLE_SPECS = [
 	"openspec/specs/review-orchestration/spec.md",
@@ -400,7 +399,7 @@ test("technical reference documents the dynamic runtime authority boundary witho
 });
 
 test("managed contracts retain no fresh lifecycle review directive", () => {
-	const managed = union([...ORCHESTRATOR, SDD_WORKFLOW, RELEASE_SKILL, WORKER, GENTLE_SKILL, README]);
+	const managed = union([...ORCHESTRATOR, SDD_WORKFLOW, WORKER, GENTLE_SKILL, README]);
 	for (const obsolete of [
 		"A fresh review still follows delegated implementation.",
 		"run a fresh-context review lens unless",

package/tests/review-relay-transport-agent.test.ts

@@ -2,13 +2,13 @@ import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { delimiter as pathDelimiter, join } from "node:path";
+import { join } from "node:path";
 import test from "node:test";
 import { __testing } from "../extensions/gentle-ai.ts";
 import { REVIEW_HOST_RELAY_FAILURE, ReviewHostRelayError } from "../lib/review-host-relay.ts";
 import { NativeReviewIntegrationError, type NativeReviewCli } from "../lib/native-review-cli.ts";
 import { CandidateViewRegistry } from "../lib/review-candidate-view.ts";
-import type { ReviewCollectInputV3, ReviewStatusV3 } from "../lib/review-integration-v2.ts";
+import type { ReviewArtifactSubjectV2, ReviewCollectInputV3, ReviewStatusV3 } from "../lib/review-integration-v2.ts";
 import type { ReviewHostRelayRequest } from "../lib/review-host-relay.ts";
 
 // Third field failure on the recovered-lineage defect (2026-08-16, gentle-pi
@@ -149,10 +149,11 @@ function transportAwareNative(options: { refusalCode?: string } = {}): {
 	return { native, agents };
 }
 
-async function runCapture(cwd: string, native: NativeReviewCli, lineageId: string, input: Record<string, unknown> = { reviewerRunAcknowledged: true }): Promise<Record<string, unknown>> {
+async function runCapture(cwd: string, native: NativeReviewCli, lineageId: string, input: Record<string, unknown> = { reviewerRunAcknowledged: true }, reviewerSessionId?: string): Promise<Record<string, unknown>> {
 	return await __testing.executeReviewCaptureOperation(
 		{ lineageId, collectBinding: JSON.stringify(collectInput(lineageId, true)), ...input },
 		cwd, native, undefined, new CandidateViewRegistry(),
+		undefined, undefined, undefined, reviewerSessionId,
 	) as Record<string, unknown>;
 }
 
@@ -187,29 +188,21 @@ test("the negotiated status asks for the pi agent so the provider offers its mat
 	assert.equal(hostRelay.transport, "pi_host_relay");
 });
 
-// gentle-shell#1136 / #1158: the lens's user-owned reviewer selection (agent
-// model routing config) and the extension allowlist environment ride the relay
-// request; without them the child runs the ambient default with no auth
-// adapters. With neither configured the launch stays selection-free.
-test("capture forwards the lens's user-owned reviewer selection and extension allowlist to the relay request", async (t) => {
+// gentle-pi#311 P2 (superseding gentle-shell#1136 / #1158): the lens's
+// user-owned completion selection (agent model routing config) rides the
+// relay request alongside the live model registry; there is no extension
+// allowlist and no ambient default model to fall back to.
+test("capture forwards the lens's user-owned selection and thinking level to the relay request", async (t) => {
 	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
 	const configHome = mkdtempSync(join(tmpdir(), "gentle-pi-relay-config-"));
 	const cwd = repository(t);
 	t.after(() => rmSync(configHome, { recursive: true, force: true }));
-	writeFileSync(join(configHome, "models.json"), JSON.stringify({ "review-reliability": { model: "minimax/MiniMax-M3" } }), "utf8");
-	const adapter = join(configHome, "auth-adapter.ts");
-	const second = join(configHome, "second-adapter.ts");
-	writeFileSync(adapter, "export default () => {};");
-	writeFileSync(second, "export default () => {};");
+	writeFileSync(join(configHome, "models.json"), JSON.stringify({ "review-reliability": { model: "minimax/MiniMax-M3", thinking: "high" } }), "utf8");
 	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
-	const previousExtensions = process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS;
 	process.env.GENTLE_PI_CONFIG_HOME = configHome;
-	process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS = [adapter, second].join(pathDelimiter);
 	t.after(() => {
 		if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
 		else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
-		if (previousExtensions === undefined) delete process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS;
-		else process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS = previousExtensions;
 	});
 	const { native } = transportAwareNative();
 	const relayed: ReviewHostRelayRequest[] = [];
@@ -220,24 +213,134 @@ test("capture forwards the lens's user-owned reviewer selection and extension al
 
 	await runCapture(cwd, native, "selection-lineage");
 	assert.equal(relayed.length, 1);
-	assert.equal(relayed[0]!.reviewerModel, "minimax/MiniMax-M3", "the lens's routing entry must name the child's selection");
-	assert.deepEqual(relayed[0]!.reviewerExtensionPaths, [adapter, second]);
+	assert.equal(relayed[0]!.selection, "minimax/MiniMax-M3", "the lens's routing entry must name the completion's selection");
+	assert.equal(relayed[0]!.thinking, "high");
+	assert.equal(relayed[0]!.routingKey, "review-reliability");
 });
 
-test("capture keeps the relay launch selection-free when the user configured neither a selection nor extensions", async (t) => {
+// The live session id threads from the extension context through both
+// request builders, so an OpenCode-routed reviewer model carries its
+// attribution headers (a side-call bypasses pi's main agent loop, where pi
+// adds them itself). A absent session id adds nothing and is never an error.
+test("capture threads the caller's live session id into the relay request", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = repository(t);
+	const { native } = transportAwareNative();
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request: ReviewHostRelayRequest) => {
+		relayed.push(request);
+		return { promptByteLength: 128, resultByteLength: 64, submission: '{"admission_decision":"completed"}' };
+	});
+
+	await runCapture(cwd, native, "session-lineage", { reviewerRunAcknowledged: true }, "ses-live-1");
+	assert.equal(relayed.length, 1);
+	assert.equal(relayed[0]!.reviewerSessionId, "ses-live-1");
+});
+
+test("capture with no live session id adds no reviewer session id to the relay request", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = repository(t);
+	const { native } = transportAwareNative();
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request: ReviewHostRelayRequest) => {
+		relayed.push(request);
+		return { promptByteLength: 128, resultByteLength: 64, submission: '{"admission_decision":"completed"}' };
+	});
+
+	await runCapture(cwd, native, "no-session-lineage");
+	assert.equal(relayed.length, 1);
+	assert.equal(relayed[0]!.reviewerSessionId, undefined);
+});
+
+function groupInput(lineageId: string, lens: string, order: number): ReviewCollectInputV3 {
+	const subjectHash = `sha256:${String(order + 1).repeat(64)}`;
+	const base = collectInput(lineageId, true);
+	const arguments_ = base.arguments.map((argument) => {
+		if (argument.name === "lens") return { ...argument, value: lens, token: `--lens=${lens}` };
+		if (argument.name === "order") return { ...argument, value: String(order), token: `--order=${order}` };
+		if (argument.name === "subject-hash") return { ...argument, value: subjectHash, token: `--subject-hash=${subjectHash}` };
+		return argument;
+	});
+	return { ...base, arguments: arguments_, artifactSubject: { ...base.artifactSubject, subjectHash, lens: lens as ReviewArtifactSubjectV2["lens"], selectedOrder: order } };
+}
+
+function groupStatus(lineageId: string, inputs: readonly ReviewCollectInputV3[]): ReviewStatusV3 {
+	const status = recoveredStatus(lineageId, false) as ReviewStatusV3 & { repositoryContext?: Record<string, unknown>; nextTransition?: { kind: string; reasonCode: string; collect: { inputs: ReviewCollectInputV3[] } } };
+	// The reviewer group binds one repository context per slot; reuse the same
+	// opaque handle shape the finalizeStatus fixtures in the routing tests use.
+	status.repositoryContext = { capability: "review.opaque_repository_context", handle: `rctx1_${"e".repeat(64)}`, revision: SHA, targetIdentity: SHA };
+	status.nextTransition = { kind: "collect", reasonCode: "reviewer_results_required", collect: { inputs: [...inputs] } };
+	return status;
+}
+
+function queueNative(statuses: readonly ReviewStatusV3[]): { native: NativeReviewCli; agents: Array<string | undefined> } {
+	const agents: Array<string | undefined> = [];
+	const queue = [...statuses];
+	const native = {
+		targetStatus: async (request: { agent?: string }) => {
+			agents.push(request.agent);
+			const next = queue.shift();
+			if (next === undefined) throw new Error("status queue exhausted");
+			return next;
+		},
+	} as unknown as NativeReviewCli;
+	return { native, agents };
+}
+
+function prepared(request: ReviewHostRelayRequest) {
+	return { request, promptByteLength: 64, resultByteLength: 32 };
+}
+
+test("capture group threads the caller's live session id into every relay request", async (t) => {
+	t.after(() => __testing.setReviewHostRelayGroupRunnersForTesting());
+	const cwd = repository(t);
+	const lineageId = "group-session-lineage";
+	const inputs = [groupInput(lineageId, "review-risk", 0), groupInput(lineageId, "review-resilience", 1)];
+	// The final reconciliation STATUS must no longer offer the submitted
+	// reviewer suffix; a STATUS without a collect transition reconciles the
+	// drained group instead of replaying the submitted set.
+	const finalStatus = groupStatus(lineageId, []) as ReviewStatusV3 & { nextTransition?: { kind: string; reasonCode: string; collect: { inputs: ReviewCollectInputV3[] } } };
+	delete finalStatus.nextTransition;
+	const { native } = queueNative([groupStatus(lineageId, inputs), groupStatus(lineageId, inputs), groupStatus(lineageId, inputs.slice(1)), finalStatus]);
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayGroupRunnersForTesting(
+		async (requests: readonly ReviewHostRelayRequest[]) => {
+			relayed.push(...requests);
+			return requests.map(prepared);
+		},
+		async (result: { promptByteLength: number; resultByteLength: number }) => ({ promptByteLength: result.promptByteLength, resultByteLength: result.resultByteLength, submission: "{}" }),
+	);
+
+	const result = await __testing.executeReviewCaptureGroupOperation(
+		{ lineageId, collectBindings: inputs.map((input) => JSON.stringify(input)), reviewerRunAcknowledged: true },
+		cwd, native, undefined, new CandidateViewRegistry(),
+		undefined, undefined, undefined, "ses-live-1",
+	) as Record<string, unknown>;
+
+	assert.equal(relayed.length, 2);
+	assert.ok(relayed.every((request) => request.reviewerSessionId === "ses-live-1"), "every grouped reviewer request must carry the live session id");
+	assert.equal(result.outcome, "native-reviewer-group-status-reconciled");
+});
+
+// gentle-pi#311 P2 decision (flagged for confirmation): the in-process path
+// has no ambient default model. A routing entry with no configured model used
+// to launch the child selection-free (inheriting pi's own default); the real
+// relay now refuses it typed instead, since there is no child to inherit a
+// default from (lib/review-host-relay.ts's own tests exercise that refusal
+// through the real, unfaked runner). This extension layer only forwards
+// whatever the routing config yields — it never validates the selection
+// itself — so with the runner faked here the request still reaches it, and
+// its `selection` field is simply absent.
+test("capture forwards no selection when the lens has no configured model, leaving the missing-model refusal to the relay", async (t) => {
 	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
 	const configHome = mkdtempSync(join(tmpdir(), "gentle-pi-relay-config-empty-"));
 	const cwd = repository(t);
 	t.after(() => rmSync(configHome, { recursive: true, force: true }));
 	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
-	const previousExtensions = process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS;
 	process.env.GENTLE_PI_CONFIG_HOME = configHome;
-	delete process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS;
 	t.after(() => {
 		if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
 		else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
-		if (previousExtensions === undefined) delete process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS;
-		else process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS = previousExtensions;
 	});
 	const { native } = transportAwareNative();
 	const relayed: ReviewHostRelayRequest[] = [];
@@ -248,8 +351,8 @@ test("capture keeps the relay launch selection-free when the user configured nei
 
 	await runCapture(cwd, native, "default-lineage");
 	assert.equal(relayed.length, 1);
-	assert.equal(relayed[0]!.reviewerModel, undefined);
-	assert.equal(relayed[0]!.reviewerExtensionPaths, undefined);
+	assert.equal(relayed[0]!.selection, undefined);
+	assert.equal(relayed[0]!.routingKey, "review-reliability");
 });
 
 test("a relayed empty-output failure carries the child's own evidence in the failure report", async (t) => {

package/tests/review-risk-assessment.test.ts

@@ -9,6 +9,7 @@ import {
 	NativeReviewCliV216,
 	type ExecFileAdapter,
 	type NativeReviewCli,
+	type NativeReviewAssessRequest,
 } from "../lib/native-review-cli.ts";
 import {
 	decodeReviewAssessmentV1,
@@ -573,6 +574,109 @@ function nativeClient(adapter: ExecFileAdapter): NativeReviewCliV216 {
 	return new NativeReviewCliV216(adapter, "/package/.gentle-ai/gentle-ai", 30_000, 1024 * 1024);
 }
 
+test("gentle_review assess: stderr-only refusal preserves safe actionable diagnostics and fails closed", async () => {
+	const queue = queuedAdapter([{ stdout: "", stderr: "untracked scope declaration required; use --untracked-scope=exclude or select; token=hidden-secret", exitCode: 1 }]);
+	const client = nativeClient(queue.adapter);
+	const tool = reviewControllerTool({ assess: client.assess.bind(client) });
+	const result = await tool.execute("refusal", { operation: "assess" }, undefined, undefined, ctx);
+	const details = result.details as { risk: string; reasons: { code: string; detail: string }[]; plan: { independentVerifier: boolean } };
+	assert.equal(details.risk, "unassessable");
+	assert.equal(details.plan.independentVerifier, true);
+	assert.equal(details.reasons[0].code, NATIVE_REVIEW_ERROR_CODE.EMPTY_OUTPUT);
+	assert.match(details.reasons[0].detail, /untracked scope declaration required/);
+	assert.match(details.reasons[0].detail, /--untracked-scope=exclude/);
+	assert.doesNotMatch(JSON.stringify(result), /hidden-secret/);
+});
+
+test("gentle_review assess: diagnostic projection is bounded and redacts paths and environment assignments", async () => {
+	const queue = queuedAdapter([{ stdout: "", stderr: "untracked declaration required /private/project/file C:\\private\\project\\file PRIVATE_PROJECT=hidden-project token=hidden-token " + "x".repeat(6000), exitCode: 1 }]);
+	const client = nativeClient(queue.adapter);
+	const tool = reviewControllerTool({ assess: client.assess.bind(client) });
+	const result = await tool.execute("private-refusal", { operation: "assess" }, undefined, undefined, ctx);
+	const serialized = JSON.stringify(result);
+	const detail = (result.details as { reasons: { detail: string }[] }).reasons[0].detail;
+	assert.match(detail, /untracked declaration required/);
+	assert.ok(detail.length < 4300);
+	assert.doesNotMatch(serialized, /hidden-project|hidden-token|private.project|\/package\//);
+});
+
+for (const [shape, sensitive] of [
+	["lowercase environment", "private_project=hidden-project"],
+	["quoted environment", 'private_project="hidden project value"'],
+	["credential argument", "--password hidden-credential"],
+	["quoted credential argument", '--api-key "hidden credential value"'],
+	["POSIX path with spaces", "/private/hidden project/hidden file.ts"],
+	["quoted POSIX path", '"/private/hidden project/hidden file.ts"'],
+	["Windows path with spaces", String.raw`C:\private\hidden project\hidden file.ts`],
+	["quoted Windows path", String.raw`"C:\private\hidden project\hidden file.ts"`],
+]) {
+	test(`assess diagnostic redacts ${shape} without losing provider guidance`, async () => {
+		const queue = queuedAdapter([{ stdout: "", stderr: `${sensitive}\nuntracked scope declaration required; use --untracked-scope=exclude or select`, exitCode: 1 }]);
+		const client = nativeClient(queue.adapter);
+		const result = await reviewControllerTool({ assess: client.assess.bind(client) }).execute("private-shape", { operation: "assess" }, undefined, undefined, ctx);
+		const details = result.details as { risk: string; reasons: { code: string; detail: string }[] };
+		assert.equal(details.risk, "unassessable");
+		assert.equal(details.reasons[0].code, NATIVE_REVIEW_ERROR_CODE.EMPTY_OUTPUT);
+		assert.doesNotMatch(JSON.stringify(result), /hidden|private_project| project|file\.ts|\/private\//);
+		assert.match(details.reasons[0].detail, /untracked scope declaration required; use --untracked-scope=exclude or select/);
+		assert.ok(details.reasons[0].detail.length < 4300);
+	});
+}
+
+for (const selection of [
+	{ untrackedScope: "exclude", expectedUntrackedInventory: "inventory-v1" },
+	{ untrackedScope: "select", expectedUntrackedInventory: "inventory-v1", intendedUntracked: ["new/file.ts", "notes.md"] },
+] as const) {
+	test(`native and facade assess forward explicit ${selection.untrackedScope} without choosing scope`, async () => {
+		const queue = queuedAdapter([{ stdout: JSON.stringify(validEnvelope()) }, { stdout: JSON.stringify(validEnvelope()) }]);
+		const client = nativeClient(queue.adapter);
+		await client.assess({ cwd: process.cwd(), ...selection });
+		const tool = reviewControllerTool({ assess: client.assess.bind(client) });
+		const result = await tool.execute("selected", { operation: "assess", input: JSON.stringify({ ...selection, baseRef: "origin/main", committedOnly: true }) }, undefined, undefined, ctx);
+		assert.equal((result.details as { risk: string }).risk, "medium");
+		const flags = [`--untracked-scope=${selection.untrackedScope}`, "--expected-untracked-inventory=inventory-v1", ...(selection.untrackedScope === "select" ? selection.intendedUntracked.map((path) => `--intended-untracked=${path}`) : [])];
+		assert.deepEqual(queue.calls[0].arguments, ["review", "assess", "--cwd", process.cwd(), ...flags, "--json"]);
+		assert.deepEqual(queue.calls[1].arguments, ["review", "assess", "--cwd", process.cwd(), "--base-ref", "origin/main", "--committed-only", ...flags, "--json"]);
+	});
+}
+
+test("native and facade assess reject invalid declarations before launching", async () => {
+	const invalid = [
+		{ untrackedScope: "exclude" },
+		{ expectedUntrackedInventory: "inventory" },
+		{ intendedUntracked: ["file.ts"] },
+		{ untrackedScope: "all", expectedUntrackedInventory: "inventory" },
+		{ untrackedScope: "exclude", expectedUntrackedInventory: "inventory", intendedUntracked: ["file.ts"] },
+		{ untrackedScope: "select", expectedUntrackedInventory: "inventory" },
+		{ untrackedScope: "select", expectedUntrackedInventory: "inventory", intendedUntracked: [] },
+		...[null, 42, "", " inventory", "inventory\n", "inv\u0000entory"].map((expectedUntrackedInventory) => ({ untrackedScope: "exclude", expectedUntrackedInventory })),
+		...["/absolute", "C:\\absolute", "dir\\file", ".", "..", "../file", "dir/../file", "dir/./file", "dir//file", "dir/", " file", "file\n"].map((path) => ({ untrackedScope: "select", expectedUntrackedInventory: "inventory", intendedUntracked: [path] })),
+		{ untrackedScope: "select", expectedUntrackedInventory: "inventory", intendedUntracked: ["file", "file"] },
+		{ untrackedScope: "select", expectedUntrackedInventory: "inventory", intendedUntracked: "file" },
+	];
+	for (const selection of invalid) {
+		const queue = queuedAdapter([]);
+		const client = nativeClient(queue.adapter);
+		await assert.rejects(() => client.assess({ cwd: process.cwd(), ...selection } as NativeReviewAssessRequest), TypeError);
+		const tool = reviewControllerTool({ assess: client.assess.bind(client) });
+		await assert.rejects(() => tool.execute("invalid", { operation: "assess", input: JSON.stringify(selection) }, undefined, undefined, ctx));
+		assert.equal(queue.calls.length, 0);
+	}
+});
+
+test("facade assess leaves absent declarations to native and preserves stale-inventory refusal", async () => {
+	for (const selection of [{}, { untrackedScope: "exclude", expectedUntrackedInventory: "stale-inventory" }]) {
+		const queue = queuedAdapter([{ stdout: "", stderr: "untracked inventory changed; inspect and declare the current inventory", exitCode: 1 }]);
+		const client = nativeClient(queue.adapter);
+		const tool = reviewControllerTool({ assess: client.assess.bind(client) });
+		const result = await tool.execute("stale", { operation: "assess", input: JSON.stringify(selection) }, undefined, undefined, ctx);
+		const details = result.details as { risk: string; reasons: { detail: string }[] };
+		assert.equal(details.risk, "unassessable");
+		assert.match(details.reasons[0].detail, /inventory changed/);
+		if (!("untrackedScope" in selection)) assert.deepEqual(queue.calls[0].arguments, ["review", "assess", "--cwd", process.cwd(), "--json"]);
+	}
+});
+
 test("native assess: decodes a well-formed envelope and sends the exact plain-versioned argv", async () => {
 	const queue = queuedAdapter([{ stdout: JSON.stringify({ schema: REVIEW_ASSESSMENT_SCHEMA, risk: "medium", reasons: [], changed_paths: 1, changed_lines: 2, candidate: { kind: "current-changes" } }) }]);
 	const result = await nativeClient(queue.adapter).assess!({ cwd: process.cwd() });

package/tests/runtime-harness.mjs

@@ -524,7 +524,18 @@ async function run() {
 
 	const toolCwd = await tempWorkspace();
 	try {
+		execFileSync("git", ["init"], { cwd: toolCwd, stdio: "ignore" });
 		const toolHook = hooks.get("tool_call")[0];
+		const toolResultHook = hooks.get("tool_result")[0];
+		const promptHook = hooks.get("before_agent_start")[0];
+		const oddCtx = createCtx(toolCwd, false, "odd-runtime-gate");
+		await promptHook({ systemPrompt: "primary" }, oddCtx);
+		const firstOddPath = join(toolCwd, "first.ts");
+		assert.equal(await toolHook({ toolName: "write", input: { path: firstOddPath } }, oddCtx), undefined);
+		await toolResultHook({ toolName: "write", toolCallId: "odd-first", input: { path: firstOddPath }, isError: false }, oddCtx);
+		const secondOdd = await toolHook({ toolName: "edit", input: { path: join(toolCwd, "second.ts") } }, oddCtx);
+		assert.equal(secondOdd?.block, true, "the real primary hook must stop a second distinct direct file");
+		assert.match(secondOdd?.reason ?? "", /subagent_run/);
 		const ghPrCwd = await tempWorkspace();
 		try {
 			execFileSync("git", ["init"], { cwd: ghPrCwd, stdio: "ignore" });