gentle-pi 4.3.0 → 4.4.0

package/tests/pi-update.test.ts

@@ -11,8 +11,12 @@ const CLI = 'dist/bundle/cli.js';
 // peer is a sibling of the Shell package; a separate global Pi links to the
 // same store entry. npm nests the peer under the Shell package.
 function fixture({windows = false, npm = false, runtime = 'adjacent', groups = 'both', peerAfter = '1.2.0', shellVersion = '4.1.0',
- badManifest = false, failed = false, mismatch = false, linked = false, readback = true, unrelatedPeer = false, shim = ''} = {}) {
+ badManifest = false, failed = false, mismatch = false, linked = false, readback = true, unrelatedPeer = false, shim = '',
+ artifact = true, configHome = '', installFailure = undefined as undefined | {stdout?: string, stderrTail?: string}} = {}) {
  const base = windows ? 'C:/pnpm' : '/pnpm';
+ const home = windows ? 'C:/Users/u' : '/home/u';
+ // The tarball `gentle-shell upgrade --channel main` packs, named after its version.
+ const tarball = `${configHome || `${home}/.pi/gentle-ai`}/main/packages/gentle-pi-${shellVersion}.tgz`;
  const storePi = (version: string) => `${base}/store/links/@earendil-works/pi-coding-agent/${version}/h/node_modules/${PI}`;
  const shellModules = npm ? `${base}/npm/lib/node_modules` : `${base}/store/links/@/gentle-pi/4.1.0/h1/node_modules`;
  const shell = `${shellModules}/gentle-pi`;
@@ -31,6 +35,7 @@ function fixture({windows = false, npm = false, runtime = 'adjacent', groups = '
  const mutations: string[][] = [];
  const out: string[] = [];
  const cwds: unknown[] = [];
+ const runOptions: unknown[] = [];
  const entry = (pkg: string, modules: string, extra = {}) => ({[pkg]: {path: `${modules}/${pkg}`, ...extra}});
  const shellEntry = entry('gentle-pi', g1, linked ? {link: true} : {});
  const piEntry = entry(PI, g2, linked ? {resolved: 'file:/src/pi'} : {});
@@ -41,7 +46,7 @@ function fixture({windows = false, npm = false, runtime = 'adjacent', groups = '
   return npm ? group : [group];
  };
  const exists = (n: string) => [g1, g2, g3, shellModules, shell, storePi(state.peer), storePi(state.group), storePi('1.1.0'), nestedPeer]
-  .some(root => n === root || n.startsWith(root + '/'));
+  .some(root => n === root || n.startsWith(root + '/')) || (artifact && n === tarball);
  const realpath = async (value: string) => {
   const n = value.replaceAll('\\', '/');
   if (n === shimFile) return n;
@@ -69,11 +74,14 @@ function fixture({windows = false, npm = false, runtime = 'adjacent', groups = '
   cwds.push(options?.cwd);
   if (args.includes('list') || args.includes('ls')) return {code: failed ? 1 : 0, stdout: readback || mutations.length === 0 ? JSON.stringify(listing()) : '{'};
   mutations.push(args);
-  if (args.some(arg => arg.startsWith('gentle-pi@'))) state.peer = peerAfter;
+  runOptions.push(options);
+  if (installFailure) return {code: 1, stdout: installFailure.stdout ?? '', ...('stderrTail' in installFailure ? {stderrTail: installFailure.stderrTail} : {})};
+  if (args.some(arg => arg.startsWith('gentle-pi@') || arg.endsWith('.tgz'))) state.peer = peerAfter;
   if (args.some(arg => arg.startsWith(PI + '@'))) state.group = peerAfter;
   return {code: 0};
  };
- return {mutations, out, cwds, state, shell, selectedCli, input: {platform: windows ? 'win32' : 'linux', packageRoot: `${g1}/gentle-pi`, currentVersion: '1.1.0', cwd: '/neutral',
+ return {mutations, out, cwds, runOptions, state, shell, selectedCli, tarball, input: {platform: windows ? 'win32' : 'linux', packageRoot: `${g1}/gentle-pi`, currentVersion: '1.1.0', cwd: '/neutral',
+  home, env: configHome ? {GENTLE_PI_CONFIG_HOME: configHome} : {},
   runtime: runtime === 'adjacent' ? {kind: 'bundled', command: 'node', args: [selectedCli]} : {kind: runtime, command: shim ? shimFile : selectedCli, args: []},
   out: (line: string) => out.push(line),
   adapters: {which: async (name: string) => name === (npm ? 'npm' : 'pnpm') ? `/fake/${name}` : null, fs: {realpath, readFile}, run}}};
@@ -117,6 +125,60 @@ test('npm nests the peer under Shell and reinstalls Shell for it', async () => {
  assert.deepEqual(f.out, ['npm installed gentle-pi@4.1.0; the selected Pi is now 1.2.0 (was 1.1.0).']);
 });
 
+// #2324: main-channel Shell versions are never published; only the tarball
+// `gentle-shell upgrade --channel main` packed can reinstall that exact build.
+const MAIN = '4.2.0-main.fb5e731119a7';
+const native = (path: string, windows: boolean) => windows ? path.replaceAll('/', '\\') : path;
+
+for (const windows of [false, true]) test(`a main-channel Shell is reinstalled from its recorded tarball, never from the registry (windows: ${windows})`, async () => {
+ const f = fixture({windows, shellVersion: MAIN});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.mutations, [['add', '-g', native(f.tarball, windows), '--allow-build=gentle-pi']]);
+ assert.deepEqual(f.out, [`pnpm installed ${native(f.tarball, windows)}; the selected Pi is now 1.2.0 (was 1.1.0).`]);
+ assert.equal(f.state.group, '1.1.0');
+});
+
+test('npm reinstalls a main-channel Shell from its recorded tarball', async () => {
+ const f = fixture({npm: true, shellVersion: MAIN});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.mutations, [['install', '-g', f.tarball]]);
+});
+
+test('a main-channel tarball is found under GENTLE_PI_CONFIG_HOME', async () => {
+ const f = fixture({shellVersion: MAIN, configHome: '/custom/config'});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.mutations, [['add', '-g', '/custom/config/main/packages/gentle-pi-4.2.0-main.fb5e731119a7.tgz', '--allow-build=gentle-pi']]);
+});
+
+test('a missing main-channel tarball names the rebuild command and installs nothing', async () => {
+ const f = fixture({shellVersion: MAIN, artifact: false});
+ await assert.rejects(updateSelectedPi(f.input), {message: `gentle-shell update: the main-channel build ${f.tarball} is missing, and this unpublished build cannot be reinstalled from the registry; run 'gentle-shell upgrade --channel release' and then 'gentle-shell upgrade --channel main' to rebuild it. No installation changed.`});
+ assert.deepEqual(f.mutations, []);
+ assert.deepEqual(f.out, []);
+});
+
+// A relative config home names different folders for `upgrade` and `update`
+// run from different directories, and npm/pnpm resolve it from the neutral cwd.
+test('a relative GENTLE_PI_CONFIG_HOME is refused for a main-channel Shell without mutation', async () => {
+ const f = fixture({shellVersion: MAIN, configHome: 'relative/config'});
+ await assert.rejects(updateSelectedPi(f.input), /ownership cannot locate the main-channel build without an absolute config home/);
+ assert.deepEqual(f.mutations, []);
+ assert.deepEqual(f.out, []);
+});
+
+test('a main-channel Shell without a home directory is refused without mutation', async () => {
+ const f = fixture({shellVersion: MAIN});
+ delete (f.input as {home?: string}).home;
+ await assert.rejects(updateSelectedPi(f.input), /ownership cannot locate the main-channel build without an absolute config home/);
+ assert.deepEqual(f.mutations, []);
+});
+
+for (const runtime of ['path', 'env']) test(`a main-channel Shell never redirects the update of a selected ${runtime} Pi`, async () => {
+ const f = fixture({runtime, shellVersion: MAIN, artifact: false});
+ assert.equal(await updateSelectedPi(f.input), 0);
+ assert.deepEqual(f.mutations, [['add', '-g', `${PI}@latest`]]);
+});
+
 test('an npm PATH runtime updates the global Pi without its scripts', async () => {
  const f = fixture({npm: true, runtime: 'path'});
  assert.equal(await updateSelectedPi(f.input), 0);
@@ -184,3 +246,36 @@ test('an unrelated selected override cannot authorize the adjacent Shell group',
  await assert.rejects(updateSelectedPi(f.input), /ownership/);
  assert.deepEqual(f.mutations, []);
 });
+
+// #2371: a failed install shows the package manager it ran and one sanitized
+// line of its own output; pnpm 11 prints ERR_PNPM_* on stdout, npm on stderr.
+test('a failed pnpm install names the pnpm it ran and its ERR_PNPM line from stdout', async () => {
+ const f = fixture({shellVersion: MAIN, installFailure: {stderrTail: '',
+  stdout: `Progress: resolved 1\n\u001b[31m[ERR_PNPM_INVALID_VERSION_UNION]\u001b[39m Invalid versions union. Found: "gentle-pi@file:/home/u/x.tgz". Use exact versions only.\nDone\n`}});
+ await assert.rejects(updateSelectedPi(f.input), {message: `gentle-shell update: pnpm (/fake/pnpm) could not install ${f.tarball}\n[ERR_PNPM_INVALID_VERSION_UNION] Invalid versions union. Found: "gentle-pi@file:~/x.tgz". Use exact versions only.`});
+ assert.deepEqual(f.runOptions, [{deadlineMs: 20 * 60_000, cwd: '/neutral', stderrTail: 4096}]);
+ assert.deepEqual(f.out, []);
+});
+
+test('a failed npm install shows its stderr error line before stdout', async () => {
+ const f = fixture({npm: true, installFailure: {stdout: 'unrelated', stderrTail: 'npm error code EACCES\nnpm error Error: EACCES: permission denied\nnpm error A complete log is in /home/u/.npm/x.log\n'}});
+ await assert.rejects(updateSelectedPi(f.input), {message: 'gentle-shell update: npm (/fake/npm) could not install gentle-pi@4.1.0\nnpm error Error: EACCES: permission denied'});
+ assert.deepEqual(f.out, []);
+});
+
+test('a failed install without output keeps the single line, naming the command it ran', async () => {
+ const f = fixture({installFailure: {}});
+ await assert.rejects(updateSelectedPi(f.input), {message: 'gentle-shell update: pnpm (/fake/pnpm) could not install gentle-pi@4.1.0'});
+ assert.deepEqual(f.mutations, [['add', '-g', 'gentle-pi@4.1.0', '--allow-build=gentle-pi']]);
+});
+
+test('a stderr warning never hides the ERR_PNPM line pnpm printed on stdout', async () => {
+ const f = fixture({installFailure: {stderrTail: '(node:1) [DEP0040] DeprecationWarning: The `punycode` module is deprecated.\n',
+  stdout: '[ERR_PNPM_INVALID_VERSION_UNION] Invalid versions union.\n'}});
+ await assert.rejects(updateSelectedPi(f.input), {message: 'gentle-shell update: pnpm (/fake/pnpm) could not install gentle-pi@4.1.0\n[ERR_PNPM_INVALID_VERSION_UNION] Invalid versions union.'});
+});
+
+test('without any error line the last stderr line is shown', async () => {
+ const f = fixture({installFailure: {stderrTail: 'killed\n', stdout: 'Progress: resolved 1\n'}});
+ await assert.rejects(updateSelectedPi(f.input), {message: 'gentle-shell update: pnpm (/fake/pnpm) could not install gentle-pi@4.1.0\nkilled'});
+});

package/tests/rdd-aware-verification-contract.test.ts

@@ -59,7 +59,7 @@ const HIGH_TIER_ROW = "| high | only through `escalate` naming a Task Size high-
 const UNASSESSABLE_TIER_ROW = "| native high, unknown, or assess failed | informs only: writer self-verification stands; escalate when a named high-risk item applies |";
 // odd/tasks/verifier-admission.md S6: the sentence names the runtime admission of the verifier launch.
 const NAMED_RISK_SENTENCE =
-	"The independent verifier runs only when the change touches a named Task Size high-risk item, passed as `escalate` (the runtime admits its launch on a `Risk: item N` line, a feature-document task line, or past the context backstop); never for size, a native tier alone, a failed assessment, or the model or effort that wrote the change. An unknown `Receipt-driven development:` line never lowers a tier below `off`.";
+	"The independent verifier runs only when the change touches a named Task Size high-risk item, passed as `escalate` (runtime admits its launch on a `Risk: item N` line or sentence, a feature-document task line, or past the context backstop); never for size, a native tier alone, a failed assessment, or the model or effort that wrote the change. An unknown `Receipt-driven development:` line never lowers a tier below `off`.";
 const SPOT_CHECK_SENTENCE =
 	"The parent spot check (re-running one reported command before delivery) stays required in every tier.";
 test("trigger 5 (Verification rule) routes every RDD line through assess and the risk tier", () => {

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

@@ -405,7 +405,8 @@ test("a v9 host-mediated refuter slot routes through the host relay with its fix
 // 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 cwd = pinFixture(t);
+	isolatedAgentHome(t);
 	const lineageId = "relay-role-missing-model";
 	const input = hostMediatedRefuterCollectInput(lineageId);
 	const harness = nativeHarness([finalizeStatus(lineageId, [input])]);
@@ -1400,3 +1401,89 @@ test("a pinned profile missing a required group role is refused typed before any
 	assert.equal(modelLookups, 0, "the typed refusal fires before any model resolution");
 	assert.equal(authAttempts, 0, "the typed refusal fires before any provider auth");
 });
+
+// gentle-pi#2271: review-refuter and review-validator are provider review
+// roles, not installable agents, so nothing seeds their routing entries and
+// profiles never carry them. When the routing snapshot in effect (saved
+// routing, pin, or session binding) has no model for one of them, the relay
+// uses Pi's persisted default model, as the routing panel already promises.
+// Lens reviewers keep their fail-closed rule.
+function isolatedAgentHome(t: test.TestContext, settings?: Record<string, unknown>): void {
+	const agentHome = mkdtempSync(join(tmpdir(), "gentle-pi-relay-agent-home-"));
+	const previous = process.env.GENTLE_PI_AGENT_HOME;
+	process.env.GENTLE_PI_AGENT_HOME = agentHome;
+	t.after(() => {
+		if (previous === undefined) delete process.env.GENTLE_PI_AGENT_HOME;
+		else process.env.GENTLE_PI_AGENT_HOME = previous;
+		rmSync(agentHome, { recursive: true, force: true });
+	});
+	if (settings !== undefined) writeFileSync(join(agentHome, "settings.json"), `${JSON.stringify(settings, null, 2)}\n`);
+}
+
+const PI_DEFAULT_SETTINGS = { defaultProvider: "pidefault", defaultModel: "default-model", defaultThinkingLevel: "medium" };
+
+async function relayedRefuterRequest(t: test.TestContext, cwd: string, lineageId: string): Promise<ReviewHostRelayRequest[]> {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const harness = nativeHarness([finalizeStatus(lineageId, [hostMediatedRefuterCollectInput(lineageId)])]);
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request) => {
+		relayed.push(request);
+		return { promptByteLength: 64, resultByteLength: 32, submission: '{"admission_decision":"completed"}' };
+	});
+	await runCapture(cwd, harness, lineageId);
+	return relayed;
+}
+
+test("a refuter slot with no routing entry uses Pi's persisted default model and effort", async (t) => {
+	const cwd = pinFixture(t);
+	isolatedAgentHome(t, PI_DEFAULT_SETTINGS);
+
+	const relayed = await relayedRefuterRequest(t, cwd, "relay-role-default");
+
+	assert.equal(relayed.length, 1);
+	assert.equal(relayed[0]!.routingKey, "review-refuter");
+	assert.equal(relayed[0]!.selection, "pidefault/default-model");
+	assert.equal(relayed[0]!.thinking, "medium");
+});
+
+test("a pinned profile that omits the refuter role uses Pi's persisted default model instead of refusing", async (t) => {
+	const cwd = pinFixture(t);
+	isolatedAgentHome(t, PI_DEFAULT_SETTINGS);
+	pinLocal(cwd, "pinned-complete");
+
+	const relayed = await relayedRefuterRequest(t, cwd, "relay-role-pin-default");
+
+	assert.equal(relayed.length, 1);
+	assert.equal(relayed[0]!.selection, "pidefault/default-model");
+});
+
+test("a configured review-refuter routing entry still wins over Pi's persisted default", async (t) => {
+	const cwd = pinFixture(t);
+	isolatedAgentHome(t, PI_DEFAULT_SETTINGS);
+	writeFileSync(join(process.env.GENTLE_PI_CONFIG_HOME!, "models.json"), `${JSON.stringify({ ...GLOBAL_MODELS, "review-refuter": { model: "global/refuter-model", thinking: "high" } }, null, 2)}\n`);
+
+	const relayed = await relayedRefuterRequest(t, cwd, "relay-role-configured");
+
+	assert.equal(relayed.length, 1);
+	assert.equal(relayed[0]!.selection, "global/refuter-model");
+	assert.equal(relayed[0]!.thinking, "high");
+});
+
+test("a lens slot with no routing entry never borrows Pi's persisted default model", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = pinFixture(t);
+	isolatedAgentHome(t, PI_DEFAULT_SETTINGS);
+	pinLocal(cwd, "pinned-partial");
+	const lineageId = "relay-lens-no-default";
+	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);
+});

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

@@ -539,7 +539,11 @@ test("every in-process reviewer refusal maps to its typed relay failure code, ca
 		{ code: INPROCESS_REVIEWER_FAILURE.AUTH_UNAVAILABLE, kind: REVIEW_HOST_RELAY_FAILURE.REVIEWER_AUTH_UNAVAILABLE },
 		{ code: INPROCESS_REVIEWER_FAILURE.THINKING_INVALID, kind: REVIEW_HOST_RELAY_FAILURE.REVIEWER_THINKING_INVALID },
 		{ code: INPROCESS_REVIEWER_FAILURE.TOOL_CALL_ATTEMPTED, kind: REVIEW_HOST_RELAY_FAILURE.REVIEWER_TOOL_CALL },
-		{ code: INPROCESS_REVIEWER_FAILURE.EMPTY_OUTPUT, kind: REVIEW_HOST_RELAY_FAILURE.REVIEWER_EMPTY_OUTPUT, evidence: { stopReason: "stop" } },
+		{ code: INPROCESS_REVIEWER_FAILURE.EMPTY_OUTPUT, kind: REVIEW_HOST_RELAY_FAILURE.REVIEWER_EMPTY_OUTPUT, evidence: {
+			reviewerModel: "nan/deepseek-v4-flash", stopReason: "length",
+			usage: { input: 12, output: 64, reasoning: 64, cacheRead: 0, cacheWrite: 0, totalTokens: 76 },
+			content: { blocks: 1, textBlocks: 0, thinkingBlocks: 1, textChars: 0, thinkingChars: 16 },
+		} },
 		{ code: INPROCESS_REVIEWER_FAILURE.OUTPUT_TOO_LARGE, kind: REVIEW_HOST_RELAY_FAILURE.REVIEWER_OUTPUT_TOO_LARGE },
 		{ code: INPROCESS_REVIEWER_FAILURE.PROVIDER_FAILED, kind: REVIEW_HOST_RELAY_FAILURE.PI_FAILED },
 	];
@@ -550,7 +554,10 @@ test("every in-process reviewer refusal maps to its typed relay failure code, ca
 		assert.equal(error.message, message);
 		assert.equal(error.mutationOutcome, "none");
 		assert.equal(existsSync(fixture.submitCapturePath), false, `${code} must never reach submission`);
-		if (evidence !== undefined) assert.deepEqual(error.reviewerEvidence, evidence, `${code} must carry its outcome evidence`);
+		if (evidence !== undefined) {
+			assert.deepEqual(error.reviewerEvidence, evidence, `${code} must carry its outcome evidence`);
+			assert.doesNotMatch(JSON.stringify(error.reviewerEvidence), /errorMessage|thinkingSignature|rawStopReason|authorization|providerPayload/);
+		}
 	}
 });
 

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

@@ -53,7 +53,7 @@ test("public Anthropic non-strict adapter preserves the complete review tool dec
 	assert.deepEqual(controller.required, ["operation"]);
 	assert.deepEqual(Object.keys(controller.properties).sort(), ["operation", "lineageId", "selectionBinding", "intendedUntracked", "untrackedScope", "changeName", "idempotencyKey", "transition", "input", "outputPath", "inputPath", "operationId", "lineageIds", "workspaceRoot"].sort());
 	assert.ok(controller.properties.input.anyOf.some((schema: any) => schema.type === "object"));
-	assert.match(controller.properties.input.description, /START\/ASSESS only/);
+	assert.match(controller.properties.input.description, /START\/ASSESS\/answer-consent/);
 	assert.deepEqual(controller.properties.operation.enum, tools.get("gentle_review").parameters.properties.operation.enum);
 	for (const name of ["gentle_review_capture", "gentle_review_capture_group"]) {
 		const schema = emitted.get(name);
@@ -66,7 +66,7 @@ test("public Anthropic non-strict adapter preserves the complete review tool dec
 	let nativeCalls = 0;
 	const native = new Proxy({}, { get() { return async () => { nativeCalls++; }; } }) as NativeReviewCli;
 	for (const operation of ["start", "assess", "answer-consent", "inspect", "reset", "recover"]) {
-		const inputs = operation === "start" || operation === "assess" ? [null] : [null, { consentBinding: "opaque", answer: "granted" }];
+		const inputs = operation === "start" || operation === "assess" || operation === "answer-consent" ? [null] : [null, { consentBinding: "opaque", answer: "granted" }];
 		for (const input of inputs) {
 			const args = validateToolArguments({ ...tools.get("gentle_review"), parameters: controller }, { type: "toolCall", id: "provider-shell", name: "gentle_review", arguments: { operation, input } });
 			assert.deepEqual(args.input, input, "provider-shell validation accepts and retains this input");
@@ -89,6 +89,23 @@ test("registered review schemas admit START/ASSESS objects and ordered capture o
 	assert.deepEqual(__testing.parseReviewCaptureGroupParameters(args).collectBindings, [JSON.stringify(binding), ordered[1]]);
 });
 
+test("answer-consent admits JSON object input and coerces it cleanly (#2375)", async () => {
+	const input = { consentBinding: "bound-1", answer: "granted" };
+	assert.deepEqual(validate("gentle_review", { operation: "answer-consent", input }).input, input);
+	assert.equal(
+		__testing.parseReviewControllerParameters(validate("gentle_review", { operation: "answer-consent", input })).input,
+		JSON.stringify(input),
+	);
+	const native = { targetStatus: async () => ({ targetIdentity: "t1" }) } as unknown as NativeReviewCli;
+	const outcome = await __testing.executeReviewControllerOperation(
+		validate("gentle_review", { operation: "answer-consent", input }),
+		process.cwd(),
+		native,
+	);
+	assert.equal(outcome.operation, "answer-consent");
+	assert.match(String(outcome.outcome), /consent-binding-stale/);
+});
+
 test("validated ASSESS objects reach the mocked native facade with parsed fields", async () => {
 	const requests: unknown[] = [];
 	const native = { assess: async (request: unknown) => { requests.push(request); throw new Error("mock assessment unavailable"); } } as unknown as NativeReviewCli;
@@ -132,7 +149,7 @@ test("actual validation rejects arrays, null and coerced primitives rather than
 });
 
 test("all other controller operations keep object input fail-closed at the facade boundary (#1698)", async () => {
-	const operations = (tools.get("gentle_review").parameters.properties.operation.enum as string[]).filter((operation) => operation !== "start" && operation !== "assess" && operation !== "select-intended-untracked");
+	const operations = (tools.get("gentle_review").parameters.properties.operation.enum as string[]).filter((operation) => operation !== "start" && operation !== "assess" && operation !== "answer-consent" && operation !== "select-intended-untracked");
 	let calls = 0;
 	const native = new Proxy({}, { get() { return async () => { calls++; throw new Error("unexpected native execution"); }; } }) as NativeReviewCli;
 	for (const operation of operations) {

package/tests/review-loadout-rdd-off-sdk.test.ts

@@ -25,6 +25,12 @@ interface SessionRun {
 
 type RddMode = "on" | "off" | "throws";
 
+const NATIVE_CONTINUATION = {
+	operation: "review.status",
+	command: "gentle-ai review status --agent pi --next-transition",
+	arguments: [{ name: "--agent", value: "pi" }, { name: "--next-transition" }],
+};
+
 function nativeCli(mode: () => RddMode): NativeReviewCli {
 	return {
 		reviewMode: async () => {
@@ -34,7 +40,10 @@ function nativeCli(mode: () => RddMode): NativeReviewCli {
 		},
 		assess: async () => ({
 			schema: "gentle-ai.review-assessment/v1",
-			risk: "medium",
+			risk: "high",
+			reviewDue: true,
+			reviewDueReason: "high_risk",
+			nextTransition: NATIVE_CONTINUATION,
 			reasons: [],
 			changedPaths: 1,
 			changedLines: 3,
@@ -120,7 +129,7 @@ async function runSession(
 	});
 	try {
 		await session.bindExtensions({ mode: "json", onError: (error) => run.errors.push(error.error) });
-		next = { name: "gentle_review", arguments: { operation: "assess" } };
+		next = { name: "gentle_review", arguments: { operation: "assess", input: { escalate: { item: 4, reason: "Fixture process concurrency boundary" } } } };
 		await session.prompt("Assess the current change.", { source: "interactive" });
 		beforeSecondPrompt();
 		await session.prompt("Report the plan.", { source: "interactive" });
@@ -162,6 +171,11 @@ function registeredGuidelines(run: SessionRun): string[] {
 function assertLeanRequest(request: RecordedRequest, run: SessionRun): void {
 	assert.match(request.systemPrompt, /Receipt-driven development: off /);
 	assert.match(request.systemPrompt, LEAN_GUIDELINE);
+	assert.match(request.systemPrompt, /relay it unchanged but do not execute it while RDD is off/);
+	assert.match(request.systemPrompt, /assessment metadata does not authorize STATUS, another review lifecycle operation, or enabling RDD/);
+	assert.doesNotMatch(request.systemPrompt, /relay it unchanged and follow it/);
+	assert.match(request.systemPrompt, /Continue the returned verification plan/);
+	assert.match(request.systemPrompt, /tests, builds, and functional checks still run/);
 	for (const guideline of registeredGuidelines(run)) assert.equal(request.systemPrompt.includes(guideline), false, `RDD off must leave out: ${guideline.slice(0, 80)}`);
 	const names = request.tools.map((tool) => tool.name);
 	assert.ok(names.includes("gentle_review"));
@@ -195,6 +209,13 @@ test("RDD off: the parent request carries only the lean ASSESS loadout; RDD on:
 	assert.equal(off.assessResults.length, 1);
 	assert.equal(off.assessResults[0].isError, false);
 	assert.equal((off.assessResults[0].details as { schema?: string }).schema, "gentle-pi.review-assessment-plan/v1");
+	const plan = off.assessResults[0].details as Record<string, unknown>;
+	assert.equal(plan.rddLine, "off");
+	assert.equal(plan.reviewDue, true);
+	assert.equal(plan.reviewDueReason, "high_risk");
+	assert.deepEqual(plan.nextTransition, NATIVE_CONTINUATION);
+	assert.equal((plan.plan as Record<string, unknown>).writerSelfVerification, true);
+	assert.equal((plan.plan as Record<string, unknown>).independentVerifier, true);
 
 	for (const request of on.requests) {
 		assert.match(request.systemPrompt, /Receipt-driven development: on /);

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

@@ -7,6 +7,7 @@ import test from "node:test";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { __testing, createGentleAiExtension } from "../extensions/gentle-ai.ts";
 import { REVIEW_HOST_RELAY_FAILURE, ReviewHostRelayError } from "../lib/review-host-relay.ts";
+import { runInProcessReviewer } from "../lib/inprocess-reviewer.ts";
 import { NativeReviewIntegrationError, type NativeReviewCli } from "../lib/native-review-cli.ts";
 import { CandidateViewRegistry } from "../lib/review-candidate-view.ts";
 import type { ReviewArtifactSubjectV2, ReviewCollectInputV3, ReviewStatusV3 } from "../lib/review-integration-v2.ts";
@@ -375,6 +376,31 @@ test("a relayed empty-output failure carries the child's own evidence in the fai
 	assert.equal(failure.reviewer?.toolCallAttempted, true);
 });
 
+test("public empty-output report preserves only safe in-process completion facts", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = repository(t);
+	const { native } = transportAwareNative();
+	const outcome = await runInProcessReviewer({ selection: "nan/deepseek-v4-flash", prompt: Buffer.from("offline"), timeoutMs: 1_000, routingKey: "review-risk" }, {
+		registry: {
+			find: () => ({ provider: "nan", id: "deepseek-v4-flash" }) as never,
+			getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "PRIVATE AUTH" }),
+		},
+		complete: async () => ({ content: [{ type: "thinking", thinking: "PRIVATE THINKING" }], stopReason: "length", errorMessage: "PRIVATE ERROR", usage: { output: 64, reasoning: 64, unknown: "PRIVATE USAGE" } }) as never,
+	});
+	assert.equal(outcome.kind, "refused");
+	if (outcome.kind !== "refused") return;
+	__testing.setReviewHostRelayRunnerForTesting(async () => {
+		throw new ReviewHostRelayError(REVIEW_HOST_RELAY_FAILURE.REVIEWER_EMPTY_OUTPUT, "pi", outcome.message, { reviewerEvidence: outcome.evidence });
+	});
+	const result = await runCapture(cwd, native, "safe-evidence-lineage");
+	assert.equal(result.outcome, "pi-host-relay-transport-failure");
+	assert.deepEqual((result.failure as { reviewer: unknown }).reviewer, {
+		reviewerModel: "nan/deepseek-v4-flash", stopReason: "length", usage: { output: 64, reasoning: 64 },
+		content: { blocks: 1, textBlocks: 0, thinkingBlocks: 1, textChars: 0, thinkingChars: 16 },
+	});
+	assert.doesNotMatch(JSON.stringify(result), /PRIVATE|errorMessage|unknown|authorization/);
+});
+
 test("capture forecasts the reviewer model run once and spends nothing until it is acknowledged", async (t) => {
 	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
 	const cwd = repository(t);

package/tests/review-reminder-receipt.test.ts

@@ -5,7 +5,7 @@ import { consumeReviewMutation, pendingReviewMutation, pendingReviewMutationProf
 function fixture() {
 	let sessionId = "parent";
 	const entries: Array<{ type: string; customType: string; data: unknown }> = [];
-	const session = { getSessionId: () => sessionId, getBranch: () => entries };
+	const session = { getSessionId: () => sessionId, getBranch: () => entries, getLeafId: () => `leaf-${entries.length}`, getEntryCount: () => entries.length };
 	const host = { appendEntry: (customType: string, data: unknown) => { entries.push({ type: "custom", customType, data }); } };
 	const write = (toolCallId: string, root = "/repo") => recordReviewMutation(host, session, root, { source: "direct", toolName: "write", toolCallId });
 	return { host, session, entries, write, switchSession: (id: string) => { sessionId = id; } };
@@ -61,6 +61,36 @@ test("malformed, unknown-version, and unmatched consumption entries do not estab
 	assert.equal(pendingReviewMutation(f.session, "/repo"), captured);
 });
 
+test("the ledger scan is memoized until the next append and hosts without leaf identity stay uncached", () => {
+	let scans = 0;
+	const entries: Array<{ type: string; customType: string; data: unknown }> = [];
+	const host = { appendEntry: (customType: string, data: unknown) => { entries.push({ type: "custom", customType, data }); } };
+	const branch = () => { scans++; return entries; };
+	const session = {
+		getSessionId: () => "parent",
+		getBranch: branch,
+		getLeafId: () => `leaf-${entries.length}`,
+		getEntryCount: () => entries.length,
+	};
+	recordReviewMutation(host, session, "/repo", { source: "direct", toolName: "write", toolCallId: "a" });
+	const captured = pendingReviewMutation(session, "/repo");
+	assert.ok(captured);
+	const afterFirstScan = scans;
+	assert.equal(pendingReviewMutation(session, "/repo"), captured);
+	assert.deepEqual(pendingReviewMutationProfiles(session, "/repo"), [{}]);
+	assert.equal(scans, afterFirstScan, "an unchanged (leafId, entryCount) identity must not rescan the branch");
+	recordReviewMutation(host, session, "/repo", { source: "direct", toolName: "edit", toolCallId: "b" });
+	const afterAppend = scans;
+	const next = pendingReviewMutation(session, "/repo");
+	assert.ok(next && next !== captured, "an append invalidates the memo, so the next call sees the new mutation");
+	assert.equal(scans, afterAppend + 1);
+	const uncached = { getSessionId: () => "parent", getBranch: branch };
+	const beforeUncached = scans;
+	assert.ok(pendingReviewMutation(uncached, "/repo"));
+	assert.ok(pendingReviewMutation(uncached, "/repo"));
+	assert.equal(scans, beforeUncached + 2, "a host without leaf identity stays uncached");
+});
+
 // gentle-pi#1175 (T2): mutation receipts optionally carry the writer profile
 // the runtime resolved, so ASSESS never has to trust a model re-declaration.
 test("mutation receipts validate with or without runtime writer profile fields, never with empty ones", () => {

package/tests/session-changes.test.ts

@@ -4,6 +4,7 @@ import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { SessionChanges, readChangeSnapshot, sessionChangeRoots, SESSION_CHANGE_ENTRY, MAX_CHANGE_BYTES } from "../lib/session-changes.ts";
+import { emptyChanges } from "../lib/shell-changes.ts";
 import { SESSION_WORKTREE_ENTRY } from "../lib/session-worktree-registry.ts";
 
 const text = (text: string) => ({ kind: "text" as const, text });
@@ -12,7 +13,7 @@ const evidence = (id = "a", root = "/repo", path = "file.ts", before = text("old
 
 test("session changes starts empty without reading the worktree or its untracked contents", () => {
 	const changes = new SessionChanges("session");
-	assert.deepEqual(changes.model, { files: [], added: 0, deleted: 0 });
+	assert.deepEqual(changes.model, { ...emptyChanges(), digest: emptyChanges().digest });
 	assert.deepEqual(changes.worktrees, []);
 });