gentle-pi 3.7.0 → 4.0.0

package/tests/review-controller-workspace-root.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
@@ -28,6 +28,7 @@ type ToolCallHandler = (
 interface Runtime {
 	controller: RegisteredTool;
 	toolCall: ToolCallHandler;
+	lifecycle(name: string, event: unknown, ctx: ExtensionContext): Promise<void>;
 }
 
 function runtime(
@@ -36,10 +37,12 @@ function runtime(
 ): Runtime {
 	const tools = new Map<string, RegisteredTool>();
 	let toolCall: ToolCallHandler | undefined;
+	const handlers = new Map<string, (event: unknown, ctx: ExtensionContext) => unknown>();
 	const dependencies = { nativeReviewCli, candidateViews } as unknown as Parameters<typeof createGentleAiExtension>[0];
 	createGentleAiExtension(dependencies)({
 		on(name: string, handler: ToolCallHandler) {
 			if (name === "tool_call") toolCall = handler;
+			handlers.set(name, handler as unknown as (event: unknown, ctx: ExtensionContext) => unknown);
 		},
 		registerTool(definition: RegisteredTool & { name: string }) { tools.set(definition.name, definition); },
 		registerCommand() {},
@@ -47,7 +50,7 @@ function runtime(
 	const controller = tools.get("gentle_review");
 	assert.ok(controller);
 	assert.ok(toolCall);
-	return { controller, toolCall };
+	return { controller, toolCall, async lifecycle(name, event, ctx) { await handlers.get(name)?.(event, ctx); } };
 }
 
 function context(cwd: string): ExtensionContext {
@@ -69,6 +72,156 @@ function repository(t: test.TestContext, prefix = "gentle-pi-workspace-root-"):
 	return cwd;
 }
 
+for (const operation of ["inspect", "start"] as const) {
+	for (const mode of ["on", "off", "unknown", "missing", "malformed", "throws"] as const) {
+		test(`non-Git ${operation} requires validated RDD on: ${mode}`, async () => {
+			const cwd = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-bootstrap-target-")));
+			writeFileSync(join(cwd, "candidate.txt"), "unchanged candidate\n");
+			const requests: string[] = [];
+			const native = fakeNative({
+				reviewMode: mode === "missing" ? undefined : (async () => {
+					if (mode === "throws") throw new Error("mode unavailable");
+					return { operation: "status", scope: "clone", status: { global: "", cloneLocal: "", effective: mode === "malformed" ? "on" : mode, source: mode === "malformed" ? "invalid" : "global" } };
+				}) as NonNullable<NativeReviewCli["reviewMode"]>,
+				targetStatus: async (request) => {
+					requests.push(request.cwd);
+					// Stop at entry: this contract does not exercise START or consent.
+					throw new Error("native preparation reached");
+				},
+			});
+			for (const explicit of [false, true]) {
+				requests.length = 0;
+				const result = await __testing.executeReviewControllerOperation({
+					operation, ...(explicit ? { workspaceRoot: cwd } : {}),
+					...(operation === "start" ? { input: JSON.stringify({ mode: "ordinary" }) } : {}),
+				}, explicit ? process.cwd() : cwd, native);
+				assert.equal(result.status, "blocked");
+				assert.deepEqual(requests, mode === "on" ? [cwd] : []);
+			}
+			assert.equal(readFileSync(join(cwd, "candidate.txt"), "utf8"), "unchanged candidate\n");
+		});
+	}
+}
+
+for (const operation of ["inspect", "start"] as const) {
+	for (const transition of ["shutdown", "replacement", "same-manager-rebind", "changed-id", "cancelled", "live"] as const) {
+		test(`explicit non-Git ${operation} pins lifecycle across held mode: ${transition}`, async t => {
+			const fixture = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-explicit-lifecycle-")));
+			const home = join(fixture, "home");
+			const project = join(fixture, "project");
+			mkdirSync(home); mkdirSync(project);
+			writeFileSync(join(project, "candidate.txt"), "unchanged candidate\n");
+			const previous = { HOME: process.env.HOME, GENTLE_PI_AGENT_HOME: process.env.GENTLE_PI_AGENT_HOME, GENTLE_PI_CONFIG_HOME: process.env.GENTLE_PI_CONFIG_HOME };
+			Object.assign(process.env, { HOME: home, GENTLE_PI_AGENT_HOME: join(fixture, "agent"), GENTLE_PI_CONFIG_HOME: join(fixture, "config") });
+			t.after(() => {
+				for (const [key, value] of Object.entries(previous)) { if (value === undefined) delete process.env[key]; else process.env[key] = value; }
+				rmSync(fixture, { recursive: true, force: true });
+			});
+			let entered!: () => void;
+			const modeEntered = new Promise<void>(resolve => { entered = resolve; });
+			let release!: () => void;
+			const heldMode = new Promise<void>(resolve => { release = resolve; });
+			let hold = false;
+			let statuses = 0;
+			let starts = 0;
+			const native = fakeNative({
+				reviewMode: async () => {
+					if (hold) { entered(); await heldMode; }
+					return { operation: "status", scope: "global", status: { global: "on", cloneLocal: "", effective: "on", source: "global" } };
+				},
+				targetStatus: async request => {
+					statuses++;
+					assert.equal(request.cwd, project);
+					// Only the fake provider mutates this disposable project. Stop before consent/START.
+					execFileSync("git", ["init", "--quiet", project]);
+					throw new Error("fixture preparation completed");
+				},
+				start: async () => { starts++; throw new Error("unexpected START"); },
+			});
+			const h = runtime(native);
+			const session = { ...context(home), sessionManager: { getSessionId: () => "same-id", getCwd: () => home, getEntries: () => [], getBranch: () => [] } } as unknown as ExtensionContext;
+			await h.lifecycle("session_start", { reason: "startup" }, session);
+			assert.equal(statuses, 0);
+			hold = true;
+			const abort = new AbortController();
+			const pending = h.controller.execute("held-explicit", { operation, workspaceRoot: project, ...(operation === "start" ? { input: JSON.stringify({ mode: "ordinary" }) } : {}) }, abort.signal, undefined, session);
+			// Observe rejection immediately, so a revoked call cannot become unhandled.
+			const settled = pending.then(result => ({ result }), error => ({ error }));
+			await modeEntered;
+			if (transition === "shutdown") await h.lifecycle("session_shutdown", { reason: "quit" }, session);
+			if (transition === "replacement") {
+				const successor = { ...session, sessionManager: { getSessionId: () => "same-id", getCwd: () => home, getEntries: () => [], getBranch: () => [] } } as unknown as ExtensionContext;
+				assert.notEqual(successor.sessionManager, session.sessionManager);
+				await h.lifecycle("session_start", { reason: "new" }, successor);
+			}
+			if (transition === "same-manager-rebind") await h.lifecycle("session_start", { reason: "reload" }, session);
+			if (transition === "changed-id") session.sessionManager.getSessionId = () => "changed-id";
+			if (transition === "cancelled") abort.abort();
+			release();
+			await settled;
+			assert.equal(abort.signal.aborted, transition === "cancelled", "lifecycle revocation is independent of caller abort");
+			assert.equal(statuses, transition === "live" ? 1 : 0, "revoked original context cannot reach native bootstrap STATUS");
+			assert.equal(starts, 0);
+			assert.equal(existsSync(join(project, ".git")), transition === "live");
+			assert.equal(existsSync(join(home, ".git")), false, "explicit selection never initializes HOME");
+			assert.equal(readFileSync(join(project, "candidate.txt"), "utf8"), "unchanged candidate\n");
+			await h.lifecycle("session_shutdown", { reason: "quit" }, session);
+		});
+	}
+}
+
+test("invalid bootstrap target selectors reject before native STATUS", async () => {
+	const cwd = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-bootstrap-invalid-")));
+	let statusCalls = 0;
+	const native = fakeNative({
+		reviewMode: async () => ({ operation: "status", scope: "clone", status: { global: "on", cloneLocal: "", effective: "on", source: "global" } }),
+		targetStatus: async () => { statusCalls += 1; throw new Error("must not reach STATUS"); },
+	});
+	for (const parameters of [
+		{ operation: "inspect", input: JSON.stringify({ baseRef: "HEAD" }) },
+		{ operation: "inspect", input: JSON.stringify({ baseRef: "missing-ref", committedOnly: true }) },
+		{ operation: "start", input: JSON.stringify({ mode: "ordinary", focus: "invalid" }) },
+		{ operation: "start", input: JSON.stringify({ mode: "ordinary", policyPath: "../outside" }) },
+	]) {
+		const result = await __testing.executeReviewControllerOperation(parameters, cwd, native);
+		assert.equal(result.status, "blocked");
+	}
+	for (const workspaceRoot of ["relative", join(cwd, "missing")]) {
+		await assert.rejects(__testing.executeReviewControllerOperation({ operation: "inspect", workspaceRoot }, cwd, native));
+	}
+	assert.equal(statusCalls, 0);
+});
+
+test("repository discovery ignores ambient Git root overrides", async (t) => {
+	const sessionRoot = repository(t);
+	const targetRoot = repository(t, "gentle-pi-isolated-target-");
+	const previous = { GIT_DIR: process.env.GIT_DIR, GIT_WORK_TREE: process.env.GIT_WORK_TREE };
+	t.after(() => {
+		for (const [key, value] of Object.entries(previous)) {
+			if (value === undefined) delete process.env[key]; else process.env[key] = value;
+		}
+	});
+	process.env.GIT_DIR = join(sessionRoot, ".git");
+	process.env.GIT_WORK_TREE = sessionRoot;
+	const requests: string[] = [];
+	await __testing.executeReviewControllerOperation({ operation: "inspect", workspaceRoot: targetRoot }, sessionRoot,
+		fakeNative({ targetStatus: async (request) => { requests.push(request.cwd); throw new Error("entry only"); } }));
+	assert.deepEqual(requests, [targetRoot]);
+});
+
+test("non-Git bound and maintenance routes cannot use preparation entry", async () => {
+	const cwd = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-bootstrap-bound-")));
+	let statusCalls = 0;
+	const native = fakeNative({ targetStatus: async () => { statusCalls += 1; throw new Error("must not reach STATUS"); } });
+	for (const parameters of [
+		{ operation: "status" },
+		{ operation: "inspect", lineageId: "bound" },
+		{ operation: "start", input: JSON.stringify({ mode: "judgment-day" }) },
+		{ operation: "reset", input: "{}" },
+	]) await assert.rejects(__testing.executeReviewControllerOperation(parameters, cwd, native));
+	assert.equal(statusCalls, 0);
+});
+
 function addWorktree(t: test.TestContext, cwd: string, branch: string): string {
 	const parent = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-workspace-worktrees-")));
 	t.after(() => {
@@ -83,7 +236,6 @@ function addWorktree(t: test.TestContext, cwd: string, branch: string): string {
 function fakeNative(overrides: Partial<NativeReviewCli> = {}): NativeReviewCli {
 	return {
 		start: async () => ({ lineageId: "native-lineage", state: "reviewing", riskLevel: "medium", selectedLenses: ["review-reliability"], changedFiles: 2, changedLines: 7, correctionBudget: 4, action: "created", lensesRequired: true }),
-		sddStatus: async () => ({ ready: false }),
 		reviewStatus: async () => ({ schema: "gentle-ai.review-authority-status/v1", repository: "/repo", complete: true, authoritative: true, status: "clean", entries: [], locks: [], diagnostics: [], raw: { schema: "gentle-ai.review-authority-status/v1", operation: "review/status", repository: "/repo", complete: true, authoritative: true, status: "clean", entries: [], locks: [], diagnostics: [] } }),
 		targetStatus: async (request) => request.lineageId === undefined
 			? candidateStartTargetStatus(request)
@@ -487,7 +639,6 @@ test("workspaceRoot fails closed before any native call for invalid target paths
 	});
 	const { controller } = runtime(counting);
 	const rejected: Array<{ label: string; workspaceRoot: string }> = [
-		{ label: "non-git directory", workspaceRoot: nonGit },
 		{ label: "missing directory", workspaceRoot: join(nonGit, "missing") },
 		{ label: "file path", workspaceRoot: filePath },
 		{ label: "relative path", workspaceRoot: "relative/worktree" },
@@ -506,6 +657,14 @@ test("workspaceRoot fails closed before any native call for invalid target paths
 			);
 		}
 	}
+	for (const operation of ["inspect", "start"] as const) {
+		const result = await controller.execute(`non-git-${operation}`, {
+			operation, workspaceRoot: nonGit,
+			...(operation === "start" ? { input: JSON.stringify({ mode: "ordinary" }) } : {}),
+		}, undefined, undefined, context(sessionCwd));
+		assert.equal((result.details as Record<string, unknown>).outcome, "native-repository-bootstrap-not-authorized");
+	}
+	await assert.rejects(controller.execute("non-git-bound", { operation: "status", workspaceRoot: nonGit, lineageId: "bound" }, undefined, undefined, context(sessionCwd)), /workspaceRoot/);
 	assert.equal(nativeCalls, 0);
 });
 

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

@@ -5,9 +5,15 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
 import { __testing } from "../extensions/gentle-ai.ts";
+import { CandidateViewRegistry } from "../lib/review-candidate-view.ts";
+import { localProfilePinPath, repoProfileDeclarationPath, writeProfilePinSync } from "../lib/agent-profile-pin.ts";
+import { createProfile, emptyProfilesFile, profilesFilePath, writeProfilesFileSync } from "../lib/agent-profiles.ts";
+import type { AgentModelConfig } from "../lib/model-routing-authority.ts";
+import { GENTLE_AI_DEV_BINARY_ENV, resolveGentleAiDevBinaryOverride } from "../lib/gentle-ai-binary.ts";
 import type { NativeReviewCli, NativeReviewUnachievableLensCaptureArtifact, NativeReviewUnachievableLensCaptureRequest } from "../lib/native-review-cli.ts";
 import { REVIEW_HOST_RELAY_FAILURE, REVIEW_HOST_RELAY_PI_TIMEOUT_ENV, REVIEW_HOST_RELAY_PI_TIMEOUT_MAX_MS, REVIEW_HOST_RELAY_SUBMISSION_MISSING_MESSAGE, REVIEW_HOST_RELAY_UNAVAILABLE_MESSAGE, ReviewHostRelayError, type ReviewHostRelayRequest } from "../lib/review-host-relay.ts";
 import { decodeReviewNextTransitionV3, decodeReviewStatusV3, type ReviewArtifactSubjectV2, type ReviewCaptureSubmissionV1, type ReviewCollectInputV3, type ReviewStatusV3 } from "../lib/review-integration-v2.ts";
+import type { InProcessReviewerRegistry } from "../lib/inprocess-reviewer.ts";
 
 // One-slot capture routing: the host relay runs only when the selected
 // provider-returned collect input carries the --materialize token. Every
@@ -216,16 +222,133 @@ function nativeHarness(statuses: readonly ReviewStatusV3[], unachievableResponde
 	return harness;
 }
 
-async function runCapture(cwd: string, harness: RoutingHarness, lineageId: string, input: Record<string, unknown> = { reviewerRunAcknowledged: true }): Promise<Record<string, unknown>> {
+async function runCapture(cwd: string, harness: RoutingHarness, lineageId: string, input: Record<string, unknown> = { reviewerRunAcknowledged: true }, modelRegistry?: InProcessReviewerRegistry): Promise<Record<string, unknown>> {
 	const selected = harness.statusQueue[0]?.nextTransition?.collect?.inputs[0];
 	if (selected === undefined) throw new Error("capture test requires one current collect input");
 	return await __testing.executeReviewCaptureOperation(
 		{ lineageId, collectBinding: JSON.stringify(selected), ...input },
 		cwd,
 		harness.native,
+		undefined, undefined, undefined, false, modelRegistry,
 	) as Record<string, unknown>;
 }
 
+// Fake STATUS/relay evidence exercises facade admission, not native-provider E2E.
+test("capture route recovery revalidates a single forecast after route loss", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = repository(t), lineageId = "recovered-single", input = relayCollectInput(lineageId, "review-risk", 0);
+	const selections = new Map(), current = finalizeStatus(lineageId, [input]);
+	const harness = nativeHarness([current, current, current]);
+	let relays = 0;
+	__testing.setReviewHostRelayRunnerForTesting(async () => {
+		relays += 1;
+		return { promptByteLength: 64, resultByteLength: 32, submission: '{"admission_decision":"completed"}' };
+	});
+	await __testing.executeReviewControllerOperation({ operation: "status", lineageId }, cwd, harness.native, undefined, null, undefined, selections);
+	const parameters = { lineageId, collectBinding: JSON.stringify(input) };
+	const forecast = await __testing.executeReviewCaptureOperation(parameters, cwd, harness.native, undefined, null, selections, true);
+	assert.equal(forecast.outcome, "reviewer-model-run-forecast");
+	assert.equal(relays, 0);
+	selections.clear();
+	const result = await __testing.executeReviewCaptureOperation({ ...parameters, reviewerRunAcknowledged: true }, cwd, harness.native, undefined, null, selections, true);
+	assert.equal(result.status, "captured");
+	assert.equal(relays, 1);
+	assert.equal(harness.statusCalls.length, 3);
+	assert.ok(harness.statusCalls.every((request) => request.agent === "pi"));
+});
+
+test("capture route recovery revalidates a complete group after forecast eviction", async (t) => {
+	t.after(() => __testing.setReviewHostRelayGroupRunnersForTesting());
+	const cwd = repository(t), lineageId = "recovered-group", inputs = groupInputs(lineageId), selections = new Map();
+	const harness = nativeHarness([finalizeStatus(lineageId, inputs), finalizeStatus(lineageId, inputs), finalizeStatus(lineageId, inputs), ...inputs.map((_input, index) => finalizeStatus(lineageId, inputs.slice(index))), finalizeStatus(lineageId)]);
+	let relays = 0, submissions = 0;
+	__testing.setReviewHostRelayGroupRunnersForTesting(async (requests) => { relays += requests.length; return requests.map(prepared); }, async () => {
+		submissions += 1;
+		return { promptByteLength: 64, resultByteLength: 32, submission: "{}" };
+	});
+	await __testing.executeReviewControllerOperation({ operation: "status", lineageId }, cwd, harness.native, undefined, null, undefined, selections);
+	const parameters = { lineageId, collectBindings: inputs.map((input) => JSON.stringify(input)) };
+	const forecast = await __testing.executeReviewCaptureGroupOperation(parameters, cwd, harness.native, undefined, null, selections, true);
+	assert.equal(forecast.outcome, "reviewer-model-run-forecast");
+	assert.equal(relays, 0);
+	selections.clear();
+	const result = await __testing.executeReviewCaptureGroupOperation({ ...parameters, reviewerRunAcknowledged: true }, cwd, harness.native, undefined, null, selections, true);
+	assert.equal(result.outcome, "native-reviewer-group-status-reconciled");
+	assert.equal(relays, 4);
+	assert.equal(submissions, 4);
+	assert.equal(harness.statusCalls.length, 8);
+});
+
+test("capture route recovery preserves the committed group selector after partial route loss", async (t) => {
+	const candidateViews = new CandidateViewRegistry();
+	t.after(() => { candidateViews.cleanupAll(); __testing.setReviewHostRelayGroupRunnersForTesting(); });
+	const cwd = repository(t), lineageId = "recovered-committed-group", inputs = groupInputs(lineageId), selections = new Map();
+	const view = candidateViews.create({ contributorRoot: cwd, baseRef: execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" }).trim(), committedOnly: true });
+	candidateViews.retain(view.token, lineageId);
+	const target = candidateViews.resolveProjection(lineageId, cwd), requests: Array<Record<string, unknown>> = [];
+	const statuses = [finalizeStatus(lineageId, inputs), finalizeStatus(lineageId, inputs), ...inputs.map((_input, index) => finalizeStatus(lineageId, inputs.slice(index))), finalizeStatus(lineageId)];
+	const native = { targetStatus: async (request: Record<string, unknown>) => { requests.push(request); return statuses.shift()!; } } as unknown as NativeReviewCli;
+	__testing.setReviewHostRelayGroupRunnersForTesting(async (requests) => requests.map(prepared), async () => ({ promptByteLength: 64, resultByteLength: 32, submission: "{}" }));
+	const parameters = { lineageId, collectBindings: inputs.map((input) => JSON.stringify(input)) };
+	const forecast = await __testing.executeReviewCaptureGroupOperation(parameters, cwd, native, undefined, candidateViews, selections, true);
+	assert.equal(forecast.outcome, "reviewer-model-run-forecast");
+	// Leave only a later matching route, rather than assuming the first survives.
+	for (const key of [...selections.keys()].slice(0, 3)) selections.delete(key);
+	const result = await __testing.executeReviewCaptureGroupOperation({ ...parameters, reviewerRunAcknowledged: true }, cwd, native, undefined, candidateViews, selections, true);
+	assert.equal(result.outcome, "native-reviewer-group-status-reconciled");
+	assert.equal(requests.length, 7);
+	assert.ok(requests.every((request) => request.baseRef === target.baseCommit && request.committedOnly === true && request.agent === "pi"));
+});
+
+test("capture route recovery rejects known workspace, lineage and selector route mismatches", async (t) => {
+	const cwd = repository(t), other = repository(t), lineageId = "known-route-boundaries", inputs = groupInputs(lineageId), selections = new Map();
+	const harness = nativeHarness([finalizeStatus(lineageId, inputs)]);
+	await __testing.executeReviewControllerOperation({ operation: "status", lineageId, input: JSON.stringify({ baseRef: "trusted-base", committedOnly: true }) }, cwd, harness.native, undefined, null, undefined, selections);
+	for (const parameters of [{ lineageId, workspaceRoot: other }, { lineageId: "foreign" }]) {
+		const single = await __testing.executeReviewCaptureOperation({ ...parameters, collectBinding: JSON.stringify(inputs[0]), reviewerRunAcknowledged: true }, cwd, harness.native, undefined, null, selections, true);
+		assert.equal(single.outcome, "capture-binding-rejected");
+		const group = await __testing.executeReviewCaptureGroupOperation({ ...parameters, collectBindings: inputs.map((input) => JSON.stringify(input)), reviewerRunAcknowledged: true }, cwd, harness.native, undefined, null, selections, true);
+		assert.equal(group.outcome, "capture-group-rejected");
+	}
+	const key = [...selections.keys()][1]!;
+	selections.set(key, { ...selections.get(key), baseRef: "wrong-base" });
+	const mixed = await __testing.executeReviewCaptureGroupOperation({ lineageId, collectBindings: inputs.map((input) => JSON.stringify(input)), reviewerRunAcknowledged: true }, cwd, harness.native, undefined, null, selections, true);
+	assert.equal(mixed.outcome, "capture-group-rejected");
+	assert.equal(harness.statusCalls.length, 1, "known route mismatches never retarget native STATUS or launch capture");
+});
+
+test("capture route recovery rejects fresh foreign, terminal, stale and malformed groups without relay", async (t) => {
+	t.after(() => { __testing.setReviewHostRelayRunnerForTesting(); __testing.setReviewHostRelayGroupRunnersForTesting(); });
+	const cwd = repository(t), lineageId = "recovery-negatives", inputs = groupInputs(lineageId);
+	let relays = 0;
+	__testing.setReviewHostRelayRunnerForTesting(async () => { relays += 1; throw new Error("unexpected relay"); });
+	__testing.setReviewHostRelayGroupRunnersForTesting(async () => { relays += 1; throw new Error("unexpected group"); }, async () => { throw new Error("unexpected submission"); });
+	const current = finalizeStatus(lineageId, inputs);
+	for (const fresh of [
+		finalizeStatus(lineageId), finalizeStatus("foreign", inputs),
+		{ ...current, targetIdentity: `sha256:${"9".repeat(64)}` },
+		{ ...current, applicability: "unrelated" },
+		{ ...current, authority: { ...current.authority!, state: "approved" } },
+		finalizeStatus(lineageId, groupInputs(lineageId, PHASE_REVISION)),
+	] as ReviewStatusV3[]) {
+		const single = await __testing.executeReviewCaptureOperation({ lineageId, collectBinding: JSON.stringify(inputs[0]), reviewerRunAcknowledged: true }, cwd, nativeHarness([fresh]).native, undefined, null, new Map(), true);
+		assert.equal(single.outcome, "capture-binding-rejected");
+		if (fresh.applicability !== "current_target" || fresh.authority?.state === "approved") {
+			const routes = new Map();
+			const listed = await __testing.executeReviewControllerOperation({ operation: "status", lineageId }, cwd, nativeHarness([fresh]).native, undefined, null, undefined, routes);
+			assert.deepEqual(listed.collectBindings, [], "publication follows route-registration eligibility");
+			assert.equal(routes.size, 0);
+		}
+		const group = await __testing.executeReviewCaptureGroupOperation({ lineageId, collectBindings: inputs.map((input) => JSON.stringify(input)), reviewerRunAcknowledged: true }, cwd, nativeHarness([fresh]).native, undefined, null, new Map(), true);
+		assert.equal(group.outcome, "capture-group-rejected");
+	}
+	for (const submitted of [inputs.slice(1), [inputs[0], inputs[0], ...inputs.slice(2)], [...inputs].reverse(), [...inputs.slice(0, 3), relayCollectInput("foreign", "review-reliability", 3)]]) {
+		const group = await __testing.executeReviewCaptureGroupOperation({ lineageId, collectBindings: submitted.map((input) => JSON.stringify(input)), reviewerRunAcknowledged: true }, cwd, nativeHarness([current]).native, undefined, null, new Map(), true);
+		assert.equal(group.outcome, "capture-group-rejected");
+	}
+	assert.equal(relays, 0);
+});
+
 test("one materialize binding routes exactly one provider slot through the host relay", async (t) => {
 	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
 	const cwd = repository(t);
@@ -315,7 +438,7 @@ test("Pi-authored review documents are rejected at the capture input boundary",
 
 function groupInputs(lineageId: string, revision = SHA): ReviewCollectInputV3[] { return ["review-risk", "review-resilience", "review-readability", "review-reliability"].map((lens, order) => relayCollectInput(lineageId, lens, order, true, "provider", revision)); }
 
-async function runCaptureGroup(cwd: string, harness: RoutingHarness, lineageId: string, inputs: readonly ReviewCollectInputV3[], reviewerRunAcknowledged = true): Promise<Record<string, unknown>> { return await __testing.executeReviewCaptureGroupOperation({ lineageId, collectBindings: inputs.map((input) => JSON.stringify(input)), reviewerRunAcknowledged }, cwd, harness.native) as Record<string, unknown>; }
+async function runCaptureGroup(cwd: string, harness: RoutingHarness, lineageId: string, inputs: readonly ReviewCollectInputV3[], reviewerRunAcknowledged = true, modelRegistry?: InProcessReviewerRegistry): Promise<Record<string, unknown>> { return await __testing.executeReviewCaptureGroupOperation({ lineageId, collectBindings: inputs.map((input) => JSON.stringify(input)), reviewerRunAcknowledged }, cwd, harness.native, undefined, undefined, undefined, false, modelRegistry) as Record<string, unknown>; }
 
 function prepared(request: ReviewHostRelayRequest) { return { request, promptByteLength: 64, resultByteLength: 32 }; }
 
@@ -1005,3 +1128,216 @@ test("collect inputs without the provider-issued materialize token never reach t
 	}
 	assert.equal(relayCalls, 0);
 });
+
+// gentle-shell#1544: the relay's reviewer selection must honor the repository
+// profile pin. These tests isolate the global config home via
+// GENTLE_PI_CONFIG_HOME so the pin's precedence over (and independence from)
+// models.json is observable without touching the operator's real
+// configuration; repository(t) supplies the Git identity the pin resolver reads.
+const GLOBAL_MODELS: AgentModelConfig = {
+	"review-risk": { model: "global/risk-model" },
+	"review-resilience": { model: "global/resilience-model" },
+	"review-readability": { model: "global/readability-model" },
+	"review-reliability": { model: "global/reliability-model" },
+};
+
+const PINNED_COMPLETE: AgentModelConfig = {
+	"review-risk": { model: "pinned/risk-model" },
+	"review-resilience": { model: "pinned/resilience-model" },
+	"review-readability": { model: "pinned/readability-model" },
+	"review-reliability": { model: "pinned/reliability-model" },
+};
+
+// A pin is a whole profile, not a per-role patch: this one deliberately omits
+// three reviewer roles that models.json still configures.
+const PINNED_PARTIAL: AgentModelConfig = { "review-risk": { model: "pinned/risk-model" } };
+
+function pinFixture(t: test.TestContext): string {
+	const configHome = mkdtempSync(join(tmpdir(), "gentle-pi-relay-pin-config-"));
+	const previous = process.env.GENTLE_PI_CONFIG_HOME;
+	const previousDevBinary = process.env[GENTLE_AI_DEV_BINARY_ENV];
+	// Redirecting the config home hides the ambient dev-binary registration, and
+	// the pinned runtime refuses a symlinked .gentle-ai directory; resolve the
+	// override while the ambient config home is still visible, then carry it
+	// through the env activation path so the real relay path resolves its
+	// executable the same way it does outside this fixture.
+	const devBinary = resolveGentleAiDevBinaryOverride()?.path;
+	process.env.GENTLE_PI_CONFIG_HOME = configHome;
+	if (devBinary !== undefined) process.env[GENTLE_AI_DEV_BINARY_ENV] = devBinary;
+	t.after(() => {
+		if (previous === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
+		else process.env.GENTLE_PI_CONFIG_HOME = previous;
+		if (previousDevBinary === undefined) delete process.env[GENTLE_AI_DEV_BINARY_ENV];
+		else process.env[GENTLE_AI_DEV_BINARY_ENV] = previousDevBinary;
+		rmSync(configHome, { recursive: true, force: true });
+	});
+	let store = emptyProfilesFile();
+	store = createProfile(store, "pinned-complete", PINNED_COMPLETE);
+	store = createProfile(store, "pinned-partial", PINNED_PARTIAL);
+	writeProfilesFileSync(profilesFilePath(configHome), store);
+	writeFileSync(join(configHome, "models.json"), `${JSON.stringify(GLOBAL_MODELS, null, 2)}\n`);
+	return repository(t);
+}
+
+function pinLocal(cwd: string, profile: string): void {
+	writeProfilePinSync(localProfilePinPath(join(cwd, ".git")), profile);
+}
+
+function pinRepoDeclaration(cwd: string, profile: string): void {
+	writeProfilePinSync(repoProfileDeclarationPath(cwd), profile);
+}
+
+test("a valid local profile pin routes a single capture's reviewer selection through the pinned profile", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = pinFixture(t);
+	pinLocal(cwd, "pinned-complete");
+	const lineageId = "relay-pin-single";
+	const harness = nativeHarness([finalizeStatus(lineageId, [relayCollectInput(lineageId, "review-risk", 0)])]);
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request) => {
+		relayed.push(request);
+		return { promptByteLength: 64, resultByteLength: 32, submission: '{"admission_decision":"completed"}' };
+	});
+
+	const result = await runCapture(cwd, harness, lineageId);
+
+	assert.equal(result.status, "captured");
+	assert.equal(relayed.length, 1);
+	assert.equal(relayed[0]!.routingKey, "review-risk");
+	assert.equal(relayed[0]!.selection, "pinned/risk-model", "the pin re-anchors the reviewer routing away from models.json");
+});
+
+test("a valid profile pin routes every grouped reviewer slot through the pinned profile", async (t) => {
+	t.after(() => __testing.setReviewHostRelayGroupRunnersForTesting());
+	const cwd = pinFixture(t);
+	pinLocal(cwd, "pinned-complete");
+	const lineageId = "relay-pin-group";
+	const inputs = groupInputs(lineageId);
+	// After each submission the authoritative STATUS offers exactly the
+	// unsubmitted suffix, so the loop's per-slot re-queries stay consistent.
+	const harness = nativeHarness([finalizeStatus(lineageId, inputs), finalizeStatus(lineageId, inputs), finalizeStatus(lineageId, inputs.slice(1)), finalizeStatus(lineageId, inputs.slice(2)), finalizeStatus(lineageId, inputs.slice(3))]);
+	const relayed: ReviewHostRelayRequest[] = [];
+	let submissions = 0;
+	__testing.setReviewHostRelayGroupRunnersForTesting(
+		async (requests) => { relayed.push(...requests); return requests.map(prepared); },
+		async (result) => {
+			submissions += 1;
+			return {
+				promptByteLength: result.promptByteLength,
+				resultByteLength: result.resultByteLength,
+				submission: submissions === inputs.length
+					? JSON.stringify({ schema: "gentle-ai.review-last-event-closure/v1", operation: "review/capture-result", lineage_id: lineageId, state: "approved", store_revision: SHA, action: "native last event closed the review" })
+					: "{}",
+			};
+		},
+	);
+
+	const result = await runCaptureGroup(cwd, harness, lineageId, inputs);
+
+	assert.equal(result.status, "closed");
+	assert.deepEqual(relayed.map((request) => [request.routingKey, request.selection]), [
+		["review-risk", "pinned/risk-model"],
+		["review-resilience", "pinned/resilience-model"],
+		["review-readability", "pinned/readability-model"],
+		["review-reliability", "pinned/reliability-model"],
+	]);
+});
+
+test("without a pin the relay keeps the global models.json routing", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = pinFixture(t);
+	const lineageId = "relay-pin-absent";
+	const harness = nativeHarness([finalizeStatus(lineageId, [relayCollectInput(lineageId, "review-risk", 0)])]);
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request) => {
+		relayed.push(request);
+		return { promptByteLength: 64, resultByteLength: 32, submission: '{"admission_decision":"completed"}' };
+	});
+
+	const result = await runCapture(cwd, harness, lineageId);
+
+	assert.equal(result.status, "captured");
+	assert.equal(relayed[0]!.selection, "global/risk-model", "no pin is exactly the pre-pin global behavior");
+});
+
+test("a repository profile declaration routes the relay when no local pin exists", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = pinFixture(t);
+	pinRepoDeclaration(cwd, "pinned-complete");
+	const lineageId = "relay-pin-repo-declaration";
+	const harness = nativeHarness([finalizeStatus(lineageId, [relayCollectInput(lineageId, "review-risk", 0)])]);
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request) => {
+		relayed.push(request);
+		return { promptByteLength: 64, resultByteLength: 32, submission: '{"admission_decision":"completed"}' };
+	});
+
+	const result = await runCapture(cwd, harness, lineageId);
+
+	assert.equal(result.status, "captured");
+	assert.equal(relayed[0]!.selection, "pinned/risk-model", "the committed declaration reaches the reviewer routing through the same resolver");
+});
+
+test("a stale pin naming a dropped profile falls back to the global routing", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = pinFixture(t);
+	pinLocal(cwd, "ghost-profile");
+	const lineageId = "relay-pin-stale";
+	const harness = nativeHarness([finalizeStatus(lineageId, [relayCollectInput(lineageId, "review-risk", 0)])]);
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request) => {
+		relayed.push(request);
+		return { promptByteLength: 64, resultByteLength: 32, submission: '{"admission_decision":"completed"}' };
+	});
+
+	const result = await runCapture(cwd, harness, lineageId);
+
+	assert.equal(result.status, "captured");
+	assert.equal(relayed[0]!.selection, "global/risk-model", "a stale chain degrades to the global routing instead of blocking");
+});
+
+test("a pinned profile missing a single-capture role sends no selection instead of borrowing models.json's role", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = pinFixture(t);
+	pinLocal(cwd, "pinned-partial");
+	const lineageId = "relay-pin-missing-single";
+	const harness = nativeHarness([finalizeStatus(lineageId, [relayCollectInput(lineageId, "review-reliability", 0)])]);
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request) => {
+		relayed.push(request);
+		return { promptByteLength: 64, resultByteLength: 32, submission: '{"admission_decision":"completed"}' };
+	});
+
+	await runCapture(cwd, harness, lineageId);
+
+	assert.equal(relayed.length, 1);
+	assert.equal(relayed[0]!.selection, undefined, "whole-profile precedence: models.json must not fill the pinned profile's gaps");
+});
+
+test("a pinned profile missing a required group role is refused typed before any reviewer launch", async (t) => {
+	const cwd = pinFixture(t);
+	pinLocal(cwd, "pinned-partial");
+	const lineageId = "relay-pin-missing-group";
+	// One group slot whose role the pin omits: models.json still configures it,
+	// so a per-role fallback would launch instead of refusing typed.
+	const inputs = [relayCollectInput(lineageId, "review-resilience", 0)];
+	const harness = nativeHarness([finalizeStatus(lineageId, inputs)]);
+	// Instrument the real model-start/auth boundary without bypassing the live
+	// group runner: a reviewer model can only start after resolving through
+	// registry.find and authenticating through registry.getApiKeyAndHeaders, so
+	// counting those seams proves no model resolution, auth, or completion ran.
+	let modelLookups = 0, authAttempts = 0;
+	const registry: InProcessReviewerRegistry = {
+		find: () => { modelLookups += 1; return undefined; },
+		getApiKeyAndHeaders: async () => { authAttempts += 1; return { ok: true }; },
+	};
+
+	const result = await runCaptureGroup(cwd, harness, lineageId, inputs, true, registry);
+
+	assert.equal(result.outcome, "pi-host-relay-transport-failure");
+	const failure = result.failure as { kind?: string } | undefined;
+	assert.equal(failure?.kind, "reviewer-config-invalid");
+	assert.match(String(result.reason), /no model is configured for review-resilience/, "whole-profile precedence: models.json must not fill the pinned profile's gaps");
+	assert.equal(modelLookups, 0, "the typed refusal fires before any model resolution");
+	assert.equal(authAttempts, 0, "the typed refusal fires before any provider auth");
+});