gentle-pi 2.4.0 → 2.6.0

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

@@ -1,8 +1,11 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os, { tmpdir } from "node:os";
+import { syncBuiltinESMExports } from "node:module";
+import { dirname, join, resolve, sep } from "node:path";
 import test from "node:test";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { __testing, createGentleAiExtension, PendingReviewConsentRegistry } from "../extensions/gentle-ai.ts";
@@ -95,6 +98,37 @@ function burnedAcknowledgementStatus(lineageId: string): ReviewStatusV3 {
 	return burned;
 }
 
+// gentle-pi#627: gentle-ai reports a stale managed-asset set as a typed stop
+// carrying the exact `gentle-ai sync` invocation that resolves it.
+function managedAssetsOutdatedStatus(lineageId: string): ReviewStatusV3 {
+	const stopped = status(lineageId, [], "approved");
+	stopped.nextTransition = { kind: "stop", reasonCode: "managed_assets_outdated", continuation: { operation: "sync", command: "gentle-ai sync --agent claude-code", agent: "claude-code", staleAssets: ["orchestration/claude-code.md"] } };
+	return stopped;
+}
+
+test("STATUS renders the managed_assets_outdated continuation command as the actionable next step", async () => {
+	const lineageId = "managed-assets-outdated";
+	const native = { targetStatus: async () => managedAssetsOutdatedStatus(lineageId) } as unknown as NativeReviewCli;
+	const blocked = await __testing.executeReviewControllerOperation({ operation: "status", lineageId }, process.cwd(), native);
+	assert.equal(blocked.status, "blocked");
+	assert.equal(blocked.hint, "run gentle-ai sync --agent claude-code");
+
+	// an unknown stop reason code keeps rendering as a plain blocked result
+	const otherStopNative = { targetStatus: async () => burnedAcknowledgementStatus(lineageId) } as unknown as NativeReviewCli;
+	const plainBlocked = await __testing.executeReviewControllerOperation({ operation: "status", lineageId }, process.cwd(), otherStopNative);
+	assert.equal(plainBlocked.status, "blocked");
+	assert.equal(plainBlocked.hint, undefined);
+
+	// an older gentle-ai may report this same stop with no continuation; the
+	// renderer degrades to a plain blocked result instead of losing the status
+	const noContinuation = status(lineageId, [], "approved");
+	noContinuation.nextTransition = { kind: "stop", reasonCode: "managed_assets_outdated" };
+	const noContinuationNative = { targetStatus: async () => noContinuation } as unknown as NativeReviewCli;
+	const degraded = await __testing.executeReviewControllerOperation({ operation: "status", lineageId }, process.cwd(), noContinuationNative);
+	assert.equal(degraded.status, "blocked");
+	assert.equal(degraded.hint, undefined);
+});
+
 test("public acknowledgement relays one current provider vector and never replays after authority burn", async () => {
 	const lineageId = "acknowledge-approved";
 	const requests: Array<Record<string, unknown>> = [];
@@ -423,6 +457,72 @@ test("REPAIR retains frozen committed collect selectors and leaves workspace rou
 	assert.deepEqual(workspaceRequests, [{ cwd, lineageId: workspaceLineage }]);
 });
 
+test("selectorless STATUS resumes a retained committed correction lineage", async (t) => {
+	const candidateViews = new CandidateViewRegistry();
+	t.after(() => candidateViews.cleanupAll());
+	const cwd = repository(t);
+	const lineageId = "retained-committed-correction";
+	const view = candidateViews.create({
+		contributorRoot: cwd,
+		baseRef: execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" }).trim(),
+		committedOnly: true,
+	});
+	candidateViews.retain(view.token, lineageId);
+	const frozenTarget = candidateViews.resolveProjection(lineageId, cwd);
+	const requests: Array<Record<string, unknown>> = [];
+	const selections = new Map();
+	let captures = 0;
+	const native = {
+		targetStatus: async (request: Record<string, unknown>) => {
+			requests.push(request);
+			return status(lineageId, [correctionPlanInput(lineageId)], "correction_required");
+		},
+		captureCorrectionPlan: async () => {
+			captures += 1;
+			return { schema: "gentle-ai.review-last-event-closure/v1", operation: "review.capture-correction-plan", lineageId, state: "correction_required", storeRevision: SHA };
+		},
+	} as unknown as NativeReviewCli;
+
+	const listed = await __testing.executeReviewControllerOperation({ operation: "status", lineageId }, cwd, native, undefined, candidateViews, undefined, selections);
+	const captured = await __testing.executeReviewCaptureOperation({ lineageId, collectBinding: bindingOf(listed), correctionLines: 1 }, cwd, native, undefined, candidateViews, selections, true);
+
+	assert.equal(captured.outcome, "native-last-event-closure");
+	assert.equal(captures, 1);
+	assert.deepEqual(requests, Array.from({ length: 2 }, () => ({ cwd, lineageId, agent: "pi", baseRef: frozenTarget.baseCommit, committedOnly: true })));
+});
+
+test("selectorless STATUS uses a retained committed selector only at its retained workspace", async (t) => {
+	const candidateViews = new CandidateViewRegistry();
+	t.after(() => candidateViews.cleanupAll());
+	const retainedRoot = repository(t);
+	const otherRoot = repository(t);
+	const lineageId = "retained-selector-boundary";
+	const view = candidateViews.create({
+		contributorRoot: retainedRoot,
+		baseRef: execFileSync("git", ["rev-parse", "HEAD"], { cwd: retainedRoot, encoding: "utf8" }).trim(),
+		committedOnly: true,
+	});
+	candidateViews.retain(view.token, lineageId);
+	const frozenTarget = candidateViews.resolveProjection(lineageId, retainedRoot);
+	const requests: Array<Record<string, unknown>> = [];
+	const native = {
+		targetStatus: async (request: Record<string, unknown>) => {
+			requests.push(request);
+			return status(String(request.lineageId ?? "unretained"));
+		},
+	} as unknown as NativeReviewCli;
+
+	await __testing.executeReviewControllerOperation({ operation: "status", lineageId, input: JSON.stringify({ baseRef: "explicit-base", committedOnly: true }) }, retainedRoot, native, undefined, candidateViews);
+	await __testing.executeReviewControllerOperation({ operation: "status", lineageId: "unretained" }, retainedRoot, native, undefined, candidateViews);
+	await __testing.executeReviewControllerOperation({ operation: "status", lineageId }, otherRoot, native, undefined, candidateViews);
+
+	assert.deepEqual(requests, [
+		{ cwd: retainedRoot, lineageId, agent: "pi", baseRef: "explicit-base", committedOnly: true },
+		{ cwd: retainedRoot, lineageId: "unretained", agent: "pi" },
+		{ cwd: retainedRoot, lineageId, agent: "pi", baseRef: frozenTarget.baseCommit, committedOnly: true },
+	]);
+});
+
 test("STATUS preserves retained intended-untracked selection through selectorless same-lineage replacement collection", async () => {
 	const cwd = process.cwd();
 	const lineageId = "selectorless-replacement";
@@ -638,6 +738,94 @@ function repository(t: test.TestContext): string {
 	return cwd;
 }
 
+test("candidate lifecycle sweeps startup and cleans every shutdown including reload", async (t) => {
+	const cwd = repository(t);
+	for (const key of ["HOME", "GENTLE_PI_AGENT_HOME", "PI_CODING_AGENT_DIR", "GENTLE_PI_CONFIG_HOME", "GENTLE_PI_GENTLE_AI_DEV_BINARY"]) {
+		const previous = process.env[key];
+		process.env[key] = key === "GENTLE_PI_GENTLE_AI_DEV_BINARY" ? "" : join(cwd, key);
+		if (process.env[key]) mkdirSync(process.env[key]!, { recursive: true });
+		t.after(() => { if (previous === undefined) delete process.env[key]; else process.env[key] = previous; });
+	}
+	t.mock.method(os, "homedir", () => join(cwd, "HOME"));
+	const homeAgent = join(cwd, "HOME", ".agents", "isolation-probe.md");
+	mkdirSync(dirname(homeAgent), { recursive: true });
+	writeFileSync(homeAgent, "---\nname: isolation-probe\ndescription: Fixture\n---\n");
+	writeFileSync(join(cwd, "GENTLE_PI_CONFIG_HOME", "models.json"), JSON.stringify({ "isolation-probe": { model: "fixture/model" } }));
+	t.diagnostic(`startup routing: cwd=${cwd}; HOME, GENTLE_PI_AGENT_HOME, PI_CODING_AGENT_DIR, GENTLE_PI_CONFIG_HOME are same-named children; dev-binary override disabled`);
+	const calls: string[] = [];
+	const destinations: string[] = [];
+	const violations: string[] = [];
+	const discovery: string[] = [];
+	const assets = resolve("assets");
+	const inside = (root: string, path: string) => path === root || path.startsWith(`${root}${sep}`);
+	const originalExists = fs.existsSync;
+	const originalRealpath = fs.realpathSync;
+	// Install guards BEFORE startup, including RED: a swallowed startup error
+	// must never hide an attempted external write or read real-home contents.
+	for (const [module, names] of [
+		[fs, ["existsSync", "lstatSync", "readdirSync", "readFileSync", "mkdirSync", "writeFileSync", "rmSync"]],
+		[fsp, ["access", "readdir", "readFile", "mkdir", "writeFile"]],
+	] as const) {
+		for (const name of names) {
+			const original = (module as any)[name];
+			t.mock.method(module as any, name, (value: string, ...args: unknown[]) => {
+				const path = resolve(value);
+				const writes = /^(mkdir|writeFile|rm)/.test(name);
+				const allowed = inside(cwd, path) || (!writes && inside(assets, path));
+				if (!allowed && name === "existsSync") return false;
+				if (!allowed && ["access", "readdir"].includes(name)) return Promise.reject(Object.assign(new Error("fixture discovery boundary"), { code: "ENOENT" }));
+				if (!allowed) { violations.push(`${name}:${path}`); throw new Error("fixture filesystem boundary"); }
+				if (writes) {
+					let ancestor = path;
+					while (!originalExists(ancestor)) ancestor = dirname(ancestor);
+					assert.ok(inside(cwd, originalRealpath(ancestor)), "write ancestor escaped fixture");
+					destinations.push(path);
+				}
+				if (name.startsWith("readdir")) discovery.push(path);
+				return original(value, ...args);
+			});
+		}
+	}
+	syncBuiltinESMExports();
+	// Prove the guard refuses an escape without performing the attempted write.
+	const escape = join(cwd, "..", "startup-isolation-escape");
+	assert.throws(() => fs.writeFileSync(escape, "blocked"), /fixture filesystem boundary/);
+	assert.deepEqual(violations, [`writeFileSync:${escape}`]);
+	violations.length = 0;
+	const hooks = new Map<string, Array<(event: unknown, ctx: ExtensionContext) => unknown>>();
+	const registry = new CandidateViewRegistry();
+	t.mock.method(registry, "sweepOrphans", (root: string) => { assert.equal(root, cwd); calls.push("sweep"); });
+	t.mock.method(registry, "cleanupAll", () => { calls.push("cleanup"); });
+	createGentleAiExtension({ nativeReviewCli: null, candidateViews: registry, processEnv: {} })({
+		on(name: string, handler: (event: unknown, ctx: ExtensionContext) => unknown) {
+			hooks.set(name, [...(hooks.get(name) ?? []), handler]);
+		},
+		registerTool() {}, registerCommand() {},
+	} as unknown as ExtensionAPI);
+	try {
+		assert.equal(hooks.get("session_start")?.length, 1);
+		await hooks.get("session_start")![0]!({ reason: "startup" }, reviewContext(cwd));
+		assert.deepEqual(violations, []);
+		assert.ok(destinations.length > 0, "startup must actually write fixture assets");
+		assert.ok(discovery.includes(join(cwd, "HOME", ".agents")), "home agent discovery must use the fixture");
+		assert.equal(existsSync(join(cwd, "GENTLE_PI_AGENT_HOME", "gentle-ai", "managed-assets.json")), true);
+		assert.match(readFileSync(homeAgent, "utf8"), /model: fixture\/model/);
+		assert.ok(destinations.includes(homeAgent), "the discovered fixture agent must actually receive routing");
+		assert.ok(destinations.includes(join(cwd, "GENTLE_PI_AGENT_HOME", "subagents.json")));
+		t.diagnostic(`confined startup: ${destinations.length} filesystem mutations; fixture home-agent routing and managed-assets manifest verified; external violations=0`);
+		assert.deepEqual(calls, ["sweep"]);
+	} finally {
+		// Restore only mocks before fixture teardown; never clean external paths.
+		t.mock.restoreAll();
+		syncBuiltinESMExports();
+	}
+	t.mock.method(registry, "cleanupAll", () => { calls.push("cleanup"); });
+	for (const reason of ["quit", "reload", "new", "resume", "fork"]) {
+		for (const hook of hooks.get("session_shutdown")!) await hook({ reason }, reviewContext(cwd));
+	}
+	assert.deepEqual(calls, ["sweep", ...Array(5).fill("cleanup")]);
+});
+
 interface RegisteredControllerTool {
 	execute: (toolCallId: string, params: unknown, signal: AbortSignal | undefined, onUpdate: undefined, ctx: ExtensionContext) => Promise<{ details?: unknown }>;
 }
@@ -722,7 +910,79 @@ test("ordinary START binds the native workspace candidate and returns the native
 	assert.equal(startCalls, 1);
 });
 
-test("pre-lineage intended-untracked selection revalidates and starts at an explicit workspace root", async (t) => {
+test("ordinary START preserves sanitized foreign diagnostics through one ambiguous reconciliation", async (t) => {
+	const cwd = repository(t);
+	const target = startStatus(cwd);
+	let targetCalls = 0;
+	let startCalls = 0;
+	const native = {
+		targetStatus: async () => {
+			targetCalls += 1;
+			return target;
+		},
+		start: async () => {
+			startCalls += 1;
+			throw {
+				name: "NativeReviewCliError",
+				code: NATIVE_REVIEW_ERROR_CODE.NON_ZERO,
+				mutationOutcome: "unknown",
+				nextAction: "review.status",
+				diagnostics: {
+					operation: "review/start",
+					error_code: NATIVE_REVIEW_ERROR_CODE.NON_ZERO,
+					exit_code: 1,
+					timed_out: false,
+					output_limit_exceeded: false,
+					stderr: "token=secret",
+				},
+			};
+		},
+	} as unknown as NativeReviewCli;
+
+	const result = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, cwd, native);
+	assert.equal(result.outcome, "native-mutation-status-reconciled");
+	assert.equal(result.mutation_outcome, "unknown");
+	assert.deepEqual(result.diagnostics, {
+		operation: "review/start",
+		error_code: NATIVE_REVIEW_ERROR_CODE.NON_ZERO,
+		exit_code: 1,
+		timed_out: false,
+		output_limit_exceeded: false,
+		stderr: "token=[REDACTED]",
+	});
+	assert.match(String(result.required_status_action), /Run target-scoped review\.status/);
+	assert.equal(result.next_action, "start");
+	assert.equal(targetCalls, 2, "START failure reconciles STATUS exactly once");
+	assert.equal(startCalls, 1, "reconciliation never replays START");
+});
+
+test("ambiguous START reconciliation preserves the provider-selected recovery directive", async (t) => {
+	const cwd = repository(t), recoveryStatus = status("recovery-lineage");
+	recoveryStatus.action = "recover";
+	recoveryStatus.actionDisposition = "escalated";
+	recoveryStatus.nextTransition = { kind: "stop", reasonCode: "manual_intervention_required" };
+	let targetCalls = 0, startCalls = 0;
+	const native = {
+		targetStatus: async () => {
+			targetCalls += 1;
+			return targetCalls === 1 ? startStatus(cwd) : recoveryStatus;
+		},
+		start: async () => {
+			startCalls += 1;
+			throw new NativeReviewCliError(NATIVE_REVIEW_ERROR_CODE.NON_ZERO, "review/start", true, true, "unknown mutation");
+		},
+	} as unknown as NativeReviewCli;
+
+	const result = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, cwd, native);
+	assert.equal(result.outcome, "native-mutation-status-reconciled");
+	assert.equal(result.mutation_outcome, "unknown");
+	assert.equal(result.next_action, "recover-with-provider-disposition");
+	assert.equal(result.required_status_action, "Use only the provider-selected recovery disposition; do not substitute scope_changed, invalidated, or escalated.");
+	assert.equal(targetCalls, 2, "START failure reconciles STATUS exactly once");
+	assert.equal(startCalls, 1, "reconciliation never replays START");
+});
+
+for (const statusSchema of ["gentle-ai.review-integration.status/v6", "gentle-ai.review-integration.status/v7"]) test(`pre-lineage intended-untracked selection revalidates and starts at an explicit workspace root (${statusSchema})`, async (t) => {
 	const cwd = realpathSync(repository(t)), sessionCwd = repository(t), eligible = "selected.md";
 	writeFileSync(join(cwd, eligible), "selected\n");
 	const initialTarget = startStatus(cwd), target = startStatus(cwd, undefined, [eligible]);
@@ -735,7 +995,7 @@ test("pre-lineage intended-untracked selection revalidates and starts at an expl
 		],
 		submission: { operationToken: "status", argumentTokens: ["--contract=gentle-ai.review-integration/v2", "--next-transition=true", "--agent=pi", "--projection=workspace", "--intended-untracked-selection={{value}}"], values: [{ slot: "intended_untracked_selection", domain: "schema_bound_json", schema: "gentle-ai.review-intended-untracked-selection/v1", substitutionLocation: 4 }] },
 	};
-	const initial = { ...initialTarget, nextTransition: { kind: "collect", reasonCode: "intended_untracked_selection_required", collect: { inputs: [selection] } }, raw: { schema: "gentle-ai.review-integration.status/v6" } } as ReviewStatusV3;
+	const initial = { ...initialTarget, nextTransition: { kind: "collect", reasonCode: "intended_untracked_selection_required", collect: { inputs: [selection] } }, raw: { schema: statusSchema } } as ReviewStatusV3;
 	const requests: Array<Record<string, unknown>> = [], starts: Array<Record<string, unknown>> = [], retained = new Map();
 	const native = {
 		reviewMode: async () => ({ operation: "status", scope: "clone", status: { global: "on", cloneLocal: "on", effective: "on", source: "clone_local" } }),
@@ -765,6 +1025,470 @@ test("pre-lineage intended-untracked selection revalidates and starts at an expl
 	assert.equal(requests.every((request) => !("lineageId" in request)), true);
 });
 
+// gentle-pi#706: inspect names the exact continuation for the intended-untracked
+// stop and can resolve it in one call through top-level untrackedScope.
+function untrackedStopFixture(
+	t: test.TestContext,
+	statusSchema = "gentle-ai.review-integration.status/v7",
+): {
+	cwd: string;
+	eligible: string;
+	initial: ReviewStatusV3;
+	target: ReviewStatusV3;
+	selection: ReviewCollectInputV3;
+} {
+	const cwd = repository(t),
+		eligible = "selected.md";
+	writeFileSync(join(cwd, eligible), "selected\n");
+	const initialTarget = startStatus(cwd),
+		target = startStatus(cwd, undefined, [eligible]);
+	const selection: ReviewCollectInputV3 = {
+		name: "intended_untracked_selection",
+		schema: "gentle-ai.review-intended-untracked-selection/v1",
+		captureOperation: "external.select_intended_untracked",
+		arguments: [
+			{ name: "target_identity", value: SHA },
+			{ name: "projection", value: "workspace" },
+			{ name: "base_tree", value: initialTarget.projection.baseTree },
+			{
+				name: "candidate_tree",
+				value: initialTarget.projection.currentCandidateTree,
+			},
+			{ name: "eligible_paths_json", value: JSON.stringify([eligible]) },
+			{ name: "expected_untracked_inventory", value: SHA },
+		],
+		submission: {
+			operationToken: "status",
+			argumentTokens: [
+				"--contract=gentle-ai.review-integration/v2",
+				"--next-transition=true",
+				"--agent=pi",
+				"--projection=workspace",
+				"--intended-untracked-selection={{value}}",
+			],
+			values: [
+				{
+					slot: "intended_untracked_selection",
+					domain: "schema_bound_json",
+					schema: "gentle-ai.review-intended-untracked-selection/v1",
+					substitutionLocation: 4,
+				},
+			],
+		},
+	};
+	const initial = {
+		...initialTarget,
+		nextTransition: {
+			kind: "collect",
+			reasonCode: "intended_untracked_selection_required",
+			collect: { inputs: [selection] },
+		},
+		raw: { schema: statusSchema },
+	} as ReviewStatusV3;
+	return { cwd, eligible, initial, target, selection };
+}
+
+for (const statusSchema of [
+	"gentle-ai.review-integration.status/v6",
+	"gentle-ai.review-integration.status/v7",
+])
+	test(`inspect on the intended-untracked stop returns nextStep and the selection binding (${statusSchema})`, async (t) => {
+		const { cwd, initial } = untrackedStopFixture(t, statusSchema);
+		let targetCalls = 0;
+		const native = {
+			targetStatus: async () => {
+				targetCalls += 1;
+				return initial;
+			},
+		} as unknown as NativeReviewCli;
+		const result = await __testing.executeReviewControllerOperation(
+			{ operation: "inspect" },
+			cwd,
+			native,
+		);
+		assert.equal(result.status, "blocked");
+		assert.equal(typeof result.selectionBinding, "string");
+		assert.equal(typeof result.nextStep, "string");
+		for (const fragment of [
+			"select-intended-untracked",
+			"untrackedScope",
+			".gitignore",
+			"path names",
+		]) {
+			assert.equal((result.nextStep as string).includes(fragment), true, fragment);
+		}
+		assert.equal(targetCalls, 1);
+	});
+
+test("inspect with untrackedScope exclude resolves the intended-untracked stop in one round trip", async (t) => {
+	const { cwd, initial, target, selection } = untrackedStopFixture(t);
+	const requests: Array<Record<string, unknown>> = [],
+		retained = new Map();
+	const native = {
+		targetStatus: async (request: Record<string, unknown>) => {
+			requests.push(request);
+			return "intendedUntrackedSelection" in request ? target : initial;
+		},
+	} as unknown as NativeReviewCli;
+	const result = await __testing.executeReviewControllerOperation(
+		{ operation: "inspect", untrackedScope: "exclude" },
+		cwd,
+		native,
+		undefined,
+		undefined,
+		undefined,
+		retained,
+	);
+	assert.equal(result.status, "ready");
+	assert.equal("selectionBinding" in result, false);
+	assert.equal(requests.length, 2);
+	assert.equal(requests[1]!.untrackedScope, "exclude");
+	assert.equal(requests[1]!.expectedUntrackedInventory, SHA);
+	assert.deepEqual(requests[1]!.intendedUntracked, []);
+	assert.deepEqual(requests[1]!.intendedUntrackedSelection, {
+		argumentTokens: selection.submission!.argumentTokens,
+		value: JSON.stringify({
+			schema: "gentle-ai.review-intended-untracked-selection/v1",
+			untracked_scope: "exclude",
+			expected_untracked_inventory: SHA,
+			intended_untracked: [],
+		}),
+	});
+	const retainedEntry = retained.get(`${cwd}\u0000`) as
+		| { untrackedScope: string; submission?: unknown }
+		| undefined;
+	assert.notEqual(retainedEntry, undefined);
+	assert.equal(retainedEntry!.untrackedScope, "exclude");
+	assert.notEqual(retainedEntry!.submission, undefined);
+});
+
+test("inspect with untrackedScope select resolves the stop with exactly the selected paths", async (t) => {
+	const { cwd, eligible, initial, target } = untrackedStopFixture(t);
+	const requests: Array<Record<string, unknown>> = [];
+	const native = {
+		targetStatus: async (request: Record<string, unknown>) => {
+			requests.push(request);
+			return "intendedUntrackedSelection" in request ? target : initial;
+		},
+	} as unknown as NativeReviewCli;
+	const result = await __testing.executeReviewControllerOperation(
+		{
+			operation: "inspect",
+			untrackedScope: "select",
+			intendedUntracked: [eligible],
+		},
+		cwd,
+		native,
+	);
+	assert.equal(result.status, "ready");
+	assert.equal(requests.length, 2);
+	assert.equal(requests[1]!.untrackedScope, "select");
+	assert.deepEqual(requests[1]!.intendedUntracked, [eligible]);
+	const submission = requests[1]!.intendedUntrackedSelection as {
+		value: string;
+	};
+	assert.deepEqual(JSON.parse(submission.value), {
+		schema: "gentle-ai.review-intended-untracked-selection/v1",
+		untracked_scope: "select",
+		expected_untracked_inventory: SHA,
+		intended_untracked: [eligible],
+	});
+});
+
+test("inspect with untrackedScope select rejects a path outside the eligible inventory", async (t) => {
+	const { cwd, initial } = untrackedStopFixture(t);
+	let targetCalls = 0;
+	const native = {
+		targetStatus: async () => {
+			targetCalls += 1;
+			return initial;
+		},
+	} as unknown as NativeReviewCli;
+	const result = await __testing.executeReviewControllerOperation(
+		{
+			operation: "inspect",
+			untrackedScope: "select",
+			intendedUntracked: ["docs/unknown.md"],
+		},
+		cwd,
+		native,
+	);
+	assert.equal(result.status, "blocked");
+	assert.equal(result.outcome, "inspect-untracked-scope-invalid");
+	assert.equal(result.mutation_performed, false);
+	assert.equal(result.mutation_outcome, "none");
+	assert.equal(targetCalls, 1);
+});
+
+for (const invalid of [
+	{ untrackedScope: "select" },
+	{ untrackedScope: "exclude", intendedUntracked: ["selected.md"] },
+] as const)
+	test(`inspect rejects an inconsistent untracked scope combination (${JSON.stringify(invalid)})`, async (t) => {
+		const { cwd, initial } = untrackedStopFixture(t);
+		let targetCalls = 0;
+		const native = {
+			targetStatus: async () => {
+				targetCalls += 1;
+				return initial;
+			},
+		} as unknown as NativeReviewCli;
+		if (invalid.untrackedScope === "exclude") {
+			await assert.rejects(
+				() => __testing.executeReviewControllerOperation({ operation: "inspect", ...invalid }, cwd, native),
+				/requires untrackedScope select/,
+			);
+			assert.equal(targetCalls, 0);
+			return;
+		}
+		const result = await __testing.executeReviewControllerOperation(
+			{ operation: "inspect", ...invalid },
+			cwd,
+			native,
+		);
+		assert.equal(result.status, "blocked");
+		assert.equal(result.outcome, "inspect-untracked-scope-invalid");
+		assert.equal(result.mutation_performed, false);
+		assert.equal(result.mutation_outcome, "none");
+		assert.equal(targetCalls, 1);
+	});
+
+test("inspect with untrackedScope and no intended-untracked stop reports not-required", async (t) => {
+	const { cwd, target } = untrackedStopFixture(t);
+	let targetCalls = 0;
+	const native = {
+		targetStatus: async () => {
+			targetCalls += 1;
+			return target;
+		},
+	} as unknown as NativeReviewCli;
+	const result = await __testing.executeReviewControllerOperation(
+		{ operation: "inspect", untrackedScope: "exclude" },
+		cwd,
+		native,
+	);
+	assert.equal(result.status, "ready");
+	assert.equal(result.untracked_selection, "not-required");
+	assert.equal(targetCalls, 1);
+});
+
+test("plain START adopts the pre-lineage selection retained by inspect and deletes it after success", async (t) => {
+	const { cwd, eligible, initial, target, selection } = untrackedStopFixture(t);
+	const requests: Array<Record<string, unknown>> = [],
+		starts: Array<Record<string, unknown>> = [],
+		retained = new Map();
+	const native = {
+		targetStatus: async (request: Record<string, unknown>) => {
+			requests.push(request);
+			return "intendedUntrackedSelection" in request ? target : initial;
+		},
+		start: async (request: Record<string, unknown>) => {
+			starts.push(request);
+			return {
+				lineageId: "review-started",
+				state: "reviewing",
+				riskLevel: "low",
+				selectedLenses: [],
+				changedFiles: 1,
+				changedLines: 1,
+				correctionBudget: 1,
+				action: "created",
+				lensesRequired: false,
+				riskReasons: [],
+				raw: {},
+			};
+		},
+	} as unknown as NativeReviewCli;
+	const resolved = await __testing.executeReviewControllerOperation(
+		{
+			operation: "inspect",
+			untrackedScope: "select",
+			intendedUntracked: [eligible],
+		},
+		cwd,
+		native,
+		undefined,
+		undefined,
+		undefined,
+		retained,
+	);
+	assert.equal(resolved.status, "ready");
+	const started = await __testing.executeReviewControllerOperation(
+		{ operation: "start", input: JSON.stringify({ mode: "ordinary" }) },
+		cwd,
+		native,
+		undefined,
+		undefined,
+		undefined,
+		retained,
+	);
+	assert.equal(started.operation, "start");
+	assert.equal(started.result.lineage_id, "review-started");
+	assert.equal(starts.length, 1);
+	assert.equal(requests.length, 3);
+	const startStatusRequest = requests[2]!;
+	assert.equal(startStatusRequest.untrackedScope, "select");
+	assert.equal(startStatusRequest.expectedUntrackedInventory, SHA);
+	assert.deepEqual(startStatusRequest.intendedUntracked, [eligible]);
+	assert.deepEqual(startStatusRequest.intendedUntrackedSelection, {
+		argumentTokens: selection.submission!.argumentTokens,
+		value: JSON.stringify({
+			schema: "gentle-ai.review-intended-untracked-selection/v1",
+			untracked_scope: "select",
+			expected_untracked_inventory: SHA,
+			intended_untracked: [eligible],
+		}),
+	});
+	assert.equal(starts[0]!.untrackedScope, "select");
+	assert.equal(retained.has(`${cwd}\u0000`), false);
+	const lineageEntry = retained.get(`${cwd}\u0000review-started`) as
+		| { untrackedScope: string; submission?: unknown }
+		| undefined;
+	assert.notEqual(lineageEntry, undefined);
+	assert.equal(lineageEntry!.untrackedScope, "select");
+	assert.notEqual(lineageEntry!.submission, undefined);
+});
+
+test("untrackedScope is accepted only by the inspect operation", async (t) => {
+	const { cwd, initial } = untrackedStopFixture(t);
+	const native = {
+		targetStatus: async () => initial,
+	} as unknown as NativeReviewCli;
+	await assert.rejects(
+		() =>
+			__testing.executeReviewControllerOperation(
+				{ operation: "status", untrackedScope: "exclude" } as never,
+				cwd,
+				native,
+			),
+		/does not accept untrackedScope/,
+	);
+	await assert.rejects(
+		() =>
+			__testing.executeReviewControllerOperation(
+				{
+					operation: "start",
+					input: JSON.stringify({ mode: "ordinary" }),
+					untrackedScope: "exclude",
+				} as never,
+				cwd,
+				native,
+			),
+		/does not accept untrackedScope/,
+	);
+});
+
+test("top-level intendedUntracked is accepted only by inspect select", async (t) => {
+		const { cwd, initial } = untrackedStopFixture(t);
+		const native = { targetStatus: async () => initial } as unknown as NativeReviewCli;
+		for (const parameters of [
+			{ operation: "inspect", intendedUntracked: [] },
+			{ operation: "inspect", untrackedScope: "exclude", intendedUntracked: [] },
+			{ operation: "status", intendedUntracked: [] },
+			{ operation: "start", input: JSON.stringify({ mode: "ordinary" }), intendedUntracked: [] },
+		] as const) {
+			await assert.rejects(
+				() => __testing.executeReviewControllerOperation(parameters as never, cwd, native),
+				/intendedUntracked/,
+				JSON.stringify(parameters),
+			);
+		}
+	});
+
+test("a fresh unsuccessful inspect invalidates its prior pre-lineage selection", async (t) => {
+		const { cwd, eligible, initial, target } = untrackedStopFixture(t);
+		const retained = new Map();
+		let failInspect = false;
+		const native = {
+			targetStatus: async (request: Record<string, unknown>) => {
+				if (failInspect) throw new Error("inspect unavailable");
+				return "intendedUntrackedSelection" in request ? target : initial;
+			},
+		} as unknown as NativeReviewCli;
+		await __testing.executeReviewControllerOperation(
+			{ operation: "inspect", untrackedScope: "select", intendedUntracked: [eligible] },
+			cwd, native, undefined, undefined, undefined, retained,
+		);
+		assert.equal(retained.has(`${cwd}\u0000`), true);
+		failInspect = true;
+		const failed = await __testing.executeReviewControllerOperation(
+			{ operation: "inspect" }, cwd, native, undefined, undefined, undefined, retained,
+		);
+		assert.equal(failed.outcome, "native-status-unavailable");
+		assert.equal(retained.has(`${cwd}\u0000`), false);
+	});
+
+test("START rejects a retained pre-lineage selection when fresh STATUS identifies a changed candidate", async (t) => {
+		const { cwd, eligible, initial, target } = untrackedStopFixture(t);
+		const retained = new Map();
+		const candidateA = {
+			...target,
+			targetIdentity: "target-a",
+			projection: { ...target.projection, currentCandidateTree: "candidate-a" },
+		} as ReviewStatusV3;
+		const candidateB = {
+			...target,
+			targetIdentity: "target-b",
+			projection: { ...target.projection, currentCandidateTree: "candidate-b" },
+		} as ReviewStatusV3;
+		let resolved = false;
+		let starts = 0;
+		const native = {
+			targetStatus: async (request: Record<string, unknown>) => {
+				if (!("intendedUntrackedSelection" in request)) return initial;
+				if (!resolved) { resolved = true; return candidateA; }
+				return candidateB;
+			},
+			start: async () => {
+				starts += 1;
+				return { lineageId: "unexpected", state: "reviewing", riskLevel: "low", selectedLenses: [], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: false, riskReasons: [], raw: {} };
+			},
+		} as unknown as NativeReviewCli;
+		await __testing.executeReviewControllerOperation(
+			{ operation: "inspect", untrackedScope: "select", intendedUntracked: [eligible] },
+			cwd, native, undefined, null, undefined, retained,
+		);
+		const rejected = await __testing.executeReviewControllerOperation(
+			{ operation: "start", input: JSON.stringify({ mode: "ordinary" }) },
+			cwd, native, undefined, null, undefined, retained,
+		);
+		assert.equal(rejected.outcome, "native-start-retained-selection-candidate-mismatch");
+		assert.equal(starts, 0);
+		assert.equal(retained.has(`${cwd}\u0000`), false);
+	});
+
+test("a failed START retains a pre-lineage selection for a same-candidate retry", async (t) => {
+		const { cwd, eligible, initial, target } = untrackedStopFixture(t);
+		const retained = new Map();
+		let starts = 0;
+		const native = {
+			targetStatus: async (request: Record<string, unknown>) =>
+				"intendedUntrackedSelection" in request ? target : initial,
+			start: async () => {
+				starts += 1;
+				if (starts === 1) throw Object.assign(new Error("retryable failure"), { mutationOutcome: "none" });
+				return { lineageId: "retried", state: "reviewing", riskLevel: "low", selectedLenses: [], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: false, riskReasons: [], raw: {} };
+			},
+		} as unknown as NativeReviewCli;
+		await __testing.executeReviewControllerOperation(
+			{ operation: "inspect", untrackedScope: "select", intendedUntracked: [eligible] },
+			cwd, native, undefined, null, undefined, retained,
+		);
+		const failed = await __testing.executeReviewControllerOperation(
+			{ operation: "start", input: JSON.stringify({ mode: "ordinary" }) },
+			cwd, native, undefined, null, undefined, retained,
+		);
+		assert.equal(failed.mutation_outcome, "none");
+		assert.equal(retained.has(`${cwd}\u0000`), true);
+		const retried = await __testing.executeReviewControllerOperation(
+			{ operation: "start", input: JSON.stringify({ mode: "ordinary" }) },
+			cwd, native, undefined, null, undefined, retained,
+		);
+		assert.equal(retried.result.lineage_id, "retried");
+		assert.equal(starts, 2);
+		assert.equal(retained.has(`${cwd}\u0000`), false);
+	});
+
 test("ordinary START relays native consent without authoring or advancing it", async (t) => {
 	const cwd = repository(t);
 	const consent = decodeReviewConsentV3(JSON.parse(readFileSync(join(process.cwd(), "tests", "fixtures", "devbinary", "consent-v3.captured.json"), "utf8")));
@@ -778,6 +1502,22 @@ test("ordinary START relays native consent without authoring or advancing it", a
 	assert.equal(result.mutation_outcome, "none");
 });
 
+test("shutdown preserves failed consent candidates without interrupting session teardown", async (t) => {
+	const cwd = repository(t);
+	const consent = decodeReviewConsentV3(JSON.parse(readFileSync(join(process.cwd(), "tests", "fixtures", "devbinary", "consent-v3.captured.json"), "utf8")));
+	const native = {
+		targetStatus: async () => startStatus(cwd),
+		start: async () => { throw new NativeReviewConsentRequiredError(consent); },
+	} as unknown as NativeReviewCli;
+	const registry = new CandidateViewRegistry();
+	const runtime = reviewRuntime(native, registry);
+	const ctx = reviewContext(cwd);
+	const result = await runtime.controller.execute("pending", { operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, undefined, undefined, ctx);
+	assert.equal((result.details as { outcome: string }).outcome, "native-review-consent-required");
+	t.mock.method(registry, "cleanup", () => { throw new Error("fixture unsafe ownership"); });
+	assert.doesNotThrow(() => runtime.sessionShutdown({ reason: "reload" }, ctx));
+});
+
 test("ordinary START obeys the review-mode kill switch before target STATUS", async () => {
 	let targetCalls = 0;
 	const native = {
@@ -799,6 +1539,24 @@ test("STATUS preserves a native process failure without inventing authority reco
 	assert.equal(result.mutation_outcome, "none");
 });
 
+test("foreign native errors with malformed diagnostics remain untrusted", async () => {
+	const native = {
+		targetStatus: async () => { throw {
+			name: "NativeReviewCliError",
+			code: NATIVE_REVIEW_ERROR_CODE.NON_ZERO,
+			diagnostics: {
+				operation: "review/status",
+				error_code: "forged-code",
+				timed_out: false,
+				output_limit_exceeded: false,
+			},
+		}; },
+	} as unknown as NativeReviewCli;
+	const result = await __testing.executeReviewControllerOperation({ operation: "status" }, process.cwd(), native);
+	assert.equal(result.outcome, "native-operation-failed");
+	assert.equal("diagnostics" in result, false);
+});
+
 test("STATUS preserves ambiguous native status as read-only provider-owned state", async () => {
 	const lineageId = "ambiguous-lineage";
 	const native = {
@@ -1178,13 +1936,17 @@ test("START and consent ambiguity reconciliation register their returned committ
 	const lineageId = "reconciled-collect", input = correctionPlanInput(lineageId), unknown = () => { throw new NativeReviewCliError(NATIVE_REVIEW_ERROR_CODE.NON_ZERO, "review/start", true, true, "unknown mutation"); };
 	const selectors = (requests: readonly Record<string, unknown>[]) => requests.map(({ baseRef: base, committedOnly }) => ({ baseRef: base, committedOnly }));
 	const directRequests: Array<Record<string, unknown>> = [], directRoutes = new Map();
+	let directStartCalls = 0;
 	const directNative = {
 		targetStatus: async (request: Record<string, unknown>) => { directRequests.push(request); return directRequests.length === 1 ? startStatus(cwd, baseRef) : status(lineageId, [input]); },
-		start: unknown,
+		start: () => { directStartCalls += 1; return unknown(); },
 		captureCorrectionPlan: async () => ({ schema: "gentle-ai.review-last-event-closure/v1", operation: "review.capture-correction-plan", lineageId, state: "correction_required", storeRevision: SHA }),
 	} as unknown as NativeReviewCli;
-	await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary", baseRef, committedOnly: true }) }, cwd, directNative, undefined, undefined, undefined, directRoutes);
-	const directCapture = await __testing.executeReviewCaptureOperation({ lineageId, collectBinding: JSON.stringify(input), correctionLines: 1 }, cwd, directNative, undefined, undefined, directRoutes, true);
+	const directStart = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary", baseRef, committedOnly: true }) }, cwd, directNative, undefined, undefined, undefined, directRoutes);
+	assert.deepEqual({ outcome: directStart.outcome, status: directStart.status, mutationOutcome: directStart.mutation_outcome, startCalls: directStartCalls, statusCalls: directRequests.length }, { outcome: "native-mutation-status-reconciled", status: "blocked", mutationOutcome: "unknown", startCalls: 1, statusCalls: 2 });
+	assert.equal((directStart.diagnostics as { error_code?: string }).error_code, NATIVE_REVIEW_ERROR_CODE.NON_ZERO);
+	assert.equal("next_action" in directStart, false);
+	const directCapture = await __testing.executeReviewCaptureOperation({ lineageId, collectBinding: bindingOf(directStart), correctionLines: 1 }, cwd, directNative, undefined, undefined, directRoutes, true);
 	const consent = decodeReviewConsentV3(JSON.parse(readFileSync(join(process.cwd(), "tests", "fixtures", "devbinary", "consent-v3.captured.json"), "utf8")));
 	const consentRequests: Array<Record<string, unknown>> = [], consentRoutes = new Map(), registry = new PendingReviewConsentRegistry(), session = Symbol("consent-session");
 	const consentNative = {
@@ -1199,9 +1961,11 @@ test("START and consent ambiguity reconciliation register their returned committ
 	const consentCapture = await __testing.executeReviewCaptureOperation({ lineageId, collectBinding: JSON.stringify(input), correctionLines: 1 }, cwd, consentNative, undefined, undefined, consentRoutes, true);
 	assert.deepEqual({
 		outcomes: [directCapture.outcome, consentCapture.outcome],
+		directStartCalls,
 		selectors: [selectors(directRequests), selectors(consentRequests)],
 	}, {
 		outcomes: ["native-last-event-closure", "native-last-event-closure"],
+		directStartCalls: 1,
 		selectors: [Array.from({ length: 3 }, () => ({ baseRef, committedOnly: true })), Array.from({ length: 3 }, () => ({ baseRef, committedOnly: true }))],
 	});
 });
@@ -1220,6 +1984,119 @@ test("ordinary START refuses a target projection that no longer matches the froz
 	assert.equal(startCalls, 0);
 });
 
+// gentle-pi#455: a consent binding one active Pi session's START created must
+// be answerable from another active session presenting the same opaque
+// binding id -- consent bindings are not partitioned by which session's
+// START created them, only by the repository and candidate they are scoped to.
+test("answer-consent resolves a valid binding presented by a different active Pi session", async (t) => {
+	const cwd = repository(t);
+	const consent = decodeReviewConsentV3(JSON.parse(readFileSync(join(process.cwd(), "tests", "fixtures", "devbinary", "consent-v3.captured.json"), "utf8")));
+	const registry = new PendingReviewConsentRegistry();
+	const sessionA = Symbol("session-a"), sessionB = Symbol("session-b");
+	let answerCalls = 0;
+	const native = {
+		targetStatus: async () => startStatus(cwd),
+		start: async () => { throw new NativeReviewConsentRequiredError(consent); },
+		answerConsent: async () => {
+			answerCalls += 1;
+			return { kind: "granted", start: { lineageId: "cross-session", state: "reviewing", riskLevel: "low", selectedLenses: [], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: false, riskReasons: [] } };
+		},
+	} as unknown as NativeReviewCli;
+	const started = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, cwd, native, undefined, undefined, undefined, undefined, registry, sessionA);
+	assert.equal(typeof started.consent_binding, "string", JSON.stringify(started));
+	const answered = await __testing.executeReviewControllerOperation({ operation: "answer-consent", input: JSON.stringify({ consentBinding: started.consent_binding, answer: "granted" }) }, cwd, native, undefined, undefined, undefined, undefined, registry, sessionB);
+	assert.equal(answerCalls, 1, JSON.stringify(answered));
+	assert.equal((answered.result as { lineage_id?: string } | undefined)?.lineage_id, "cross-session", JSON.stringify(answered));
+	assert.notEqual(answered.status, "blocked", JSON.stringify(answered));
+});
+
+// gentle-pi#455: cross-session resolution must still enforce single use --
+// once a binding is answered by any session, no session (including the one
+// whose START created it) may answer it again.
+test("a consumed consent binding cannot be answered a second time from any session", async (t) => {
+	const cwd = repository(t);
+	const consent = decodeReviewConsentV3(JSON.parse(readFileSync(join(process.cwd(), "tests", "fixtures", "devbinary", "consent-v3.captured.json"), "utf8")));
+	const registry = new PendingReviewConsentRegistry();
+	const sessionA = Symbol("session-a"), sessionB = Symbol("session-b");
+	let answerCalls = 0;
+	const native = {
+		targetStatus: async () => startStatus(cwd),
+		start: async () => { throw new NativeReviewConsentRequiredError(consent); },
+		answerConsent: async () => {
+			answerCalls += 1;
+			return { kind: "granted", start: { lineageId: "single-use", state: "reviewing", riskLevel: "low", selectedLenses: [], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: false, riskReasons: [] } };
+		},
+	} as unknown as NativeReviewCli;
+	const started = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, cwd, native, undefined, undefined, undefined, undefined, registry, sessionA);
+	const binding = started.consent_binding as string;
+	const first = await __testing.executeReviewControllerOperation({ operation: "answer-consent", input: JSON.stringify({ consentBinding: binding, answer: "granted" }) }, cwd, native, undefined, undefined, undefined, undefined, registry, sessionB);
+	assert.equal(answerCalls, 1, JSON.stringify(first));
+	const replay = await __testing.executeReviewControllerOperation({ operation: "answer-consent", input: JSON.stringify({ consentBinding: binding, answer: "granted" }) }, cwd, native, undefined, undefined, undefined, undefined, registry, sessionA);
+	assert.equal(answerCalls, 1, JSON.stringify(replay));
+	assert.equal(replay.status, "blocked", JSON.stringify(replay));
+	assert.equal(replay.outcome, "consent-binding-stale", JSON.stringify(replay));
+	assert.equal((replay.diagnostics as { code?: string } | undefined)?.code, "consent-binding-already-consumed", JSON.stringify(replay));
+});
+
+// gentle-pi#455 correction: cross-session resolution looks a binding up by
+// its opaque id alone, so it must independently refuse an answer presented
+// from a different repository than the one its owning START minted it for,
+// without ever running the mode gate or native answerConsent, and without
+// consuming the binding -- leaving it answerable from the right repository.
+test("answer-consent refuses a binding presented from a different repository than the one its START minted, and leaves it answerable from the right one", async (t) => {
+	const cwdA = repository(t), cwdB = repository(t);
+	const consent = decodeReviewConsentV3(JSON.parse(readFileSync(join(process.cwd(), "tests", "fixtures", "devbinary", "consent-v3.captured.json"), "utf8")));
+	const registry = new PendingReviewConsentRegistry();
+	const sessionA = Symbol("session-a"), sessionB = Symbol("session-b");
+	let answerCalls = 0;
+	const native = {
+		targetStatus: async () => startStatus(cwdA),
+		start: async () => { throw new NativeReviewConsentRequiredError(consent); },
+		answerConsent: async () => {
+			answerCalls += 1;
+			return { kind: "granted", start: { lineageId: "right-repo", state: "reviewing", riskLevel: "low", selectedLenses: [], changedFiles: 1, changedLines: 1, correctionBudget: 1, action: "created", lensesRequired: false, riskReasons: [] } };
+		},
+	} as unknown as NativeReviewCli;
+	const started = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, cwdA, native, undefined, undefined, undefined, undefined, registry, sessionA);
+	const binding = started.consent_binding as string;
+	const wrongRepo = await __testing.executeReviewControllerOperation({ operation: "answer-consent", input: JSON.stringify({ consentBinding: binding, answer: "granted" }) }, cwdB, native, undefined, undefined, undefined, undefined, registry, sessionB);
+	assert.equal(answerCalls, 0, JSON.stringify(wrongRepo));
+	assert.equal(wrongRepo.status, "blocked", JSON.stringify(wrongRepo));
+	assert.equal(wrongRepo.outcome, "consent-binding-repository-mismatch", JSON.stringify(wrongRepo));
+	assert.equal((wrongRepo.diagnostics as { code?: string } | undefined)?.code, "consent-binding-repository-mismatch", JSON.stringify(wrongRepo));
+	assert.equal(wrongRepo.mutation_performed, false, JSON.stringify(wrongRepo));
+	const rightRepo = await __testing.executeReviewControllerOperation({ operation: "answer-consent", input: JSON.stringify({ consentBinding: binding, answer: "granted" }) }, cwdA, native, undefined, undefined, undefined, undefined, registry, sessionA);
+	assert.equal(answerCalls, 1, JSON.stringify(rightRepo));
+	assert.equal((rightRepo.result as { lineage_id?: string } | undefined)?.lineage_id, "right-repo", JSON.stringify(rightRepo));
+});
+
+// gentle-pi#323: within the live consent TTL window, a content-independent
+// replay key let a second ordinary START reuse the first START's still-live
+// (never lineage-bound) frozen candidate view even though the live candidate
+// content changed underneath it, and then dead-ended at
+// candidate-target-projection-drift instead of minting a fresh view and a
+// fresh consent envelope. An intended-untracked selection is retained across
+// both calls so the pre-existing empty-untracked drift-recovery branch does
+// not mask the general content-change gap this covers.
+test("ordinary START mints a fresh candidate view when candidate content changes within the live consent TTL window", async (t) => {
+	const candidateViews = new CandidateViewRegistry();
+	t.after(() => candidateViews.cleanupAll());
+	const cwd = repository(t);
+	writeFileSync(join(cwd, "extra.md"), "kept\n");
+	const consent = decodeReviewConsentV3(JSON.parse(readFileSync(join(process.cwd(), "tests", "fixtures", "devbinary", "consent-v3.captured.json"), "utf8")));
+	const native = {
+		targetStatus: async () => startStatus(cwd, undefined, ["extra.md"]),
+		start: async () => { throw new NativeReviewConsentRequiredError(consent); },
+	} as unknown as NativeReviewCli;
+	const first = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, cwd, native, undefined, candidateViews);
+	assert.equal(first.outcome, "native-review-consent-required", JSON.stringify(first));
+	writeFileSync(join(cwd, "tracked.txt"), "candidate two\n");
+	const second = await __testing.executeReviewControllerOperation({ operation: "start", input: JSON.stringify({ mode: "ordinary" }) }, cwd, native, undefined, candidateViews);
+	assert.notEqual(second.outcome, "native-operation-failed", JSON.stringify(second));
+	assert.equal(second.outcome, "native-review-consent-required", JSON.stringify(second));
+	assert.notEqual(second.consent_binding, first.consent_binding, JSON.stringify(second));
+});
+
 test("controller-owned dispatch confines single and parallel graph actors to the current candidate view", async (t) => {
 	const cwd = repository(t);
 	const candidateViews = new CandidateViewRegistry();