gentle-pi 3.2.0 → 3.3.0

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

@@ -1171,6 +1171,7 @@ for (const statusSchema of [
 
 test("inspect with untrackedScope exclude resolves the intended-untracked stop in one round trip", async (t) => {
 	const { cwd, initial, target, selection } = untrackedStopFixture(t);
+	const baseRef = execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" }).trim();
 	const requests: Array<Record<string, unknown>> = [],
 		retained = new Map();
 	const native = {
@@ -1180,7 +1181,11 @@ test("inspect with untrackedScope exclude resolves the intended-untracked stop i
 		},
 	} as unknown as NativeReviewCli;
 	const result = await __testing.executeReviewControllerOperation(
-		{ operation: "inspect", untrackedScope: "exclude" },
+		{
+			operation: "inspect",
+			input: JSON.stringify({ baseRef: "HEAD", committedOnly: true }),
+			untrackedScope: "exclude",
+		},
 		cwd,
 		native,
 		undefined,
@@ -1191,6 +1196,10 @@ test("inspect with untrackedScope exclude resolves the intended-untracked stop i
 	assert.equal(result.status, "ready");
 	assert.equal("selectionBinding" in result, false);
 	assert.equal(requests.length, 2);
+	for (const request of requests) {
+		assert.equal(request.baseRef, baseRef);
+		assert.equal(request.committedOnly, true);
+	}
 	assert.equal(requests[1]!.untrackedScope, "exclude");
 	assert.equal(requests[1]!.expectedUntrackedInventory, SHA);
 	assert.deepEqual(requests[1]!.intendedUntracked, []);
@@ -1960,6 +1969,56 @@ test("ordinary START transports native focus and safe policy inputs without rebu
 	assert.equal(statusCalls, 0);
 });
 
+test("INSPECT forwards an explicit committed-only base selector to negotiated STATUS", async (t) => {
+	const cwd = repository(t);
+	const baseRef = execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" }).trim();
+	const requests: Array<Record<string, unknown>> = [];
+	const native = {
+		targetStatus: async (request: Record<string, unknown>) => {
+			requests.push(request);
+			return startStatus(cwd, baseRef);
+		},
+	} as unknown as NativeReviewCli;
+
+	const result = await __testing.executeReviewControllerOperation(
+		{ operation: "inspect", input: JSON.stringify({ baseRef, committedOnly: true }) },
+		cwd,
+		native,
+	);
+
+	assert.equal(result.status, "ready");
+	assert.deepEqual(
+		requests.map(({ baseRef: selectedBase, committedOnly }) => ({ baseRef: selectedBase, committedOnly })),
+		[{ baseRef, committedOnly: true }],
+	);
+});
+
+test("INSPECT rejects malformed committed-range selectors before negotiated STATUS", async (t) => {
+	const cwd = repository(t);
+	let targetCalls = 0;
+	const native = {
+		targetStatus: async () => {
+			targetCalls += 1;
+			return startStatus(cwd);
+		},
+	} as unknown as NativeReviewCli;
+
+	for (const input of [
+		{ baseRef: "HEAD", committedOnly: false },
+		{ committedOnly: true },
+		{ baseRef: "HEAD", committedOnly: true, mode: "ordinary" },
+	]) {
+		const rejected = await __testing.executeReviewControllerOperation(
+			{ operation: "inspect", input: JSON.stringify(input) },
+			cwd,
+			native,
+		);
+		assert.equal(rejected.outcome, "native-inspect-input-invalid");
+		assert.equal(rejected.mutation_outcome, "none");
+	}
+	assert.equal(targetCalls, 0);
+});
+
 test("ordinary START keeps default and explicit base selection fail-closed before native mutation", async (t) => {
 	const cwd = repository(t);
 	let targetCalls = 0;

package/tests/review-host-relay-routing.test.ts

@@ -155,6 +155,38 @@ function providerRefuterRequiredStatus(lineageId: string): ReviewStatusV3 {
 	};
 }
 
+// gentle-pi#311 P3: gentle-ai's v9 contract renders the refuter and
+// targeted-validator role captures host-mediated, exactly like a lens
+// materialize slot, instead of the self-contained --execute=true vector
+// `providerRefuterRequiredStatus` above models.
+function roleBindingArguments(lineageId: string, revision = SHA): ReviewCollectInputV3["arguments"] {
+	return [
+		{ name: "lineage", value: lineageId, token: `--lineage=${lineageId}` },
+		{ name: "expected-revision", value: revision, token: `--expected-revision=${revision}` },
+		{ name: "target", value: SHA, token: `--target=${SHA}` },
+		{ name: "repository-context", value: `rctx1_${"e".repeat(64)}`, token: `--repository-context=rctx1_${"e".repeat(64)}` },
+	];
+}
+
+function hostMediatedRefuterCollectInput(lineageId: string, revision = SHA): ReviewCollectInputV3 {
+	const bindingTokens = roleBindingArguments(lineageId, revision).map((argument) => argument.token!);
+	return {
+		name: "provider_refuter",
+		schema: "https://gentle-ai.dev/schema/review/refuter/v1",
+		captureOperation: "review.capture-refuter",
+		arguments: [
+			...roleBindingArguments(lineageId, revision),
+			{ name: "agent", value: "pi", token: "--agent=pi" },
+			{ name: "materialize", value: "true", token: "--materialize=true" },
+		],
+		submission: {
+			operationToken: "capture-refuter",
+			argumentTokens: [...bindingTokens, "--agent=pi", "--input={{value}}"],
+			values: [{ slot: "provider_refuter", domain: "artifact_path_or_stdin", substitutionLocation: bindingTokens.length + 1 }],
+		},
+	};
+}
+
 interface RoutingHarness {
 	statusQueue: ReviewStatusV3[];
 	statusCalls: Array<{ cwd: string; lineageId?: string; agent?: "pi" }>;
@@ -216,6 +248,51 @@ test("one materialize binding routes exactly one provider slot through the host
 	assert.equal((result.host_relay as { transport: string }).transport, "pi_host_relay");
 });
 
+// gentle-pi#311 P3: a v9 host-mediated refuter/targeted-validator slot reuses
+// this exact relay machinery — the only role-specific part reachable from
+// here is the fixed routing key it resolves through, since it carries no
+// per-slot lens identity.
+test("a v9 host-mediated refuter slot routes through the host relay with its fixed routing key", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = repository(t);
+	const lineageId = "relay-role-lineage";
+	const input = hostMediatedRefuterCollectInput(lineageId);
+	const harness = nativeHarness([finalizeStatus(lineageId, [input])]);
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request: ReviewHostRelayRequest) => {
+		relayed.push(request);
+		return { promptByteLength: 64, resultByteLength: 32, submission: '{"admission_decision":"completed"}' };
+	});
+
+	const result = await runCapture(cwd, harness, lineageId);
+
+	assert.equal(relayed.length, 1);
+	assert.equal(relayed[0]!.routingKey, "review-refuter");
+	assert.deepEqual(relayed[0]!.captureArgumentTokens, input.arguments.map((argument) => argument.token));
+	assert.deepEqual(relayed[0]!.submission, input.submission);
+	assert.equal(harness.statusCalls.length, 1, "a nonterminal capture does not auto-follow STATUS");
+	assert.equal(result.status, "captured");
+	assert.equal((result.host_relay as { transport: string }).transport, "pi_host_relay");
+});
+
+// The reviewer selection is validated before any process launches (the same
+// discipline a lens slot already has): a routing config with no
+// review-refuter entry is refused typed, naming that exact key, never a
+// mid-relay transport failure.
+test("a missing review-refuter routing model is refused typed, naming the key, before any relay launch", async (t) => {
+	const cwd = repository(t);
+	const lineageId = "relay-role-missing-model";
+	const input = hostMediatedRefuterCollectInput(lineageId);
+	const harness = nativeHarness([finalizeStatus(lineageId, [input])]);
+
+	const result = await runCapture(cwd, harness, lineageId);
+
+	assert.equal(result.status, "blocked");
+	const failure = result.failure as { kind?: string } | undefined;
+	assert.equal(failure?.kind, "reviewer-config-invalid");
+	assert.match(String(result.reason), /review-refuter/);
+});
+
 test("Pi-authored review documents are rejected at the capture input boundary", async (t) => {
 	// The narrow capture schema rejects a caller-authored reviewer document
 	// before any relay launch or native call.