gentle-pi 4.0.0 → 4.2.0

package/tests/quiet-tool-rendering.test.ts

@@ -1,10 +1,14 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { initTheme, keyHint } from "@earendil-works/pi-coding-agent";
 import { imageFallback, visibleWidth } from "@earendil-works/pi-tui";
 import { cardBody, cardHint, cardTitle, cardTone } from "./gentle-card-text.ts";
 import { CARD_STYLE, cardStyle, setCardStyle } from "../lib/shell-card.ts";
 import { stripAnsi } from "../lib/terminal-theme.ts";
+import { CARD_CONTENT, cardContent, setCardContent } from "../lib/card-content-policy.ts";
 import piPretty from "../extensions/pi-pretty.ts";
 import productionQuietTools, {
 	createQuietToolRenderer,
@@ -252,7 +256,7 @@ test("quiet tool rendering can be disabled by env", () => {
 
 test("pi-pretty suppresses overlapping tools before quiet tools register", async () => {
 	await withEnvAsync(
-		{ GENTLE_PI_QUIET_TOOLS: undefined, PRETTY_DISABLE_TOOLS: "multi_grep" },
+		{ GENTLE_PI_AGENTS_CHILD: undefined, GENTLE_PI_QUIET_TOOLS: undefined, PRETTY_DISABLE_TOOLS: "multi_grep" },
 		async () => {
 			const { pi, tools } = createPi({ throwOnToolConflict: true });
 
@@ -270,7 +274,7 @@ test("pi-pretty suppresses overlapping tools before quiet tools register", async
 
 test("pi-pretty preserves byte-exact model-visible read results when quiet tools suppress its renderer", async () => {
 	await withEnvAsync(
-		{ GENTLE_PI_QUIET_TOOLS: undefined, PRETTY_DISABLE_TOOLS: undefined },
+		{ GENTLE_PI_AGENTS_CHILD: undefined, GENTLE_PI_QUIET_TOOLS: undefined, PRETTY_DISABLE_TOOLS: undefined },
 		async () => {
 			const { pi, hooks } = createPi();
 			await piPretty(pi as any, fakePiPrettyDeps as any);
@@ -293,6 +297,7 @@ test("pi-pretty preserves byte-exact model-visible read results when quiet tools
 test("pi-pretty suppression is skipped when quiet tools are disabled", async () => {
 	await withEnvAsync(
 		{
+			GENTLE_PI_AGENTS_CHILD: undefined,
 			GENTLE_PI_QUIET_TOOLS: "0",
 			PRETTY_DISABLE_TOOLS: undefined,
 			PRETTY_ENABLE_TOOLS: "ls",
@@ -424,7 +429,7 @@ test("quiet Bash errors preserve meaningful rows for both public output ordering
 			["probe stderr detail \x1b[31mwith terminal color\x1b[0m", ["", ""]],
 			["probe exit status: 7", []],
 		]],
-	] as const;
+	] satisfies ReadonlyArray<readonly [string, ReadonlyArray<readonly [string, readonly string[]]>]>;
 	assert.equal(cases.length, 2);
 	const args = { command: "false" };
 	const renderResult = (result: any, expanded: boolean) => tool.renderResult(result, { expanded, isPartial: false, isError: true }, passthroughTheme, { args, isError: true });
@@ -989,6 +994,62 @@ test("quiet tool rendering keeps concise collapsed edit and write summaries", ()
 	assert.equal(formatToolResultOutput("write", textResult("Successfully wrote 12 bytes\n" + text) as any, { expanded: false }), "\n✓ wrote 12 bytes");
 });
 
+test("quiet write expansion shows the complete written content without changing the compact summary", () => {
+	const tool = registeredQuietTools().get("write");
+	const content = Array.from({ length: 12 }, (_, index) => `written line ${index + 1}`).join("\n");
+	const result = textResult("Successfully wrote 182 bytes to file.ts");
+	const context = { args: { path: "file.ts", content } };
+
+	assert.equal(renderToolResult(tool, result, { expanded: true, isPartial: false }, context), content);
+	assert.equal(renderToolResult(tool, result, { expanded: false, isPartial: false }, context), "✓ wrote 182 bytes");
+});
+
+test("quiet write expansion renders content after a real built-in write", async () => {
+	const cwd = await mkdtemp(join(tmpdir(), "gentle-write-expanded-"));
+	try {
+		const tool = registeredQuietTools().get("write");
+		const args = { path: "example.ts", content: "export const answer = 42;\n" };
+		const result = await tool.execute("write-expanded", args, undefined, undefined, { cwd });
+
+		assert.equal(await readFile(join(cwd, args.path), "utf8"), args.content);
+		assert.match(extractTextContent(result), /Successfully wrote/);
+		assert.doesNotMatch(extractTextContent(result), /export const answer/);
+		assert.equal(renderToolResult(tool, result, { expanded: true, isPartial: false }, { args }), args.content);
+	} finally {
+		await rm(cwd, { recursive: true, force: true });
+	}
+});
+
+test("quiet write expansion sanitizes content and respects narrow card widths", () => {
+	const tool = registeredQuietTools().get("write");
+	const content = "first\n\nsafe\x1b]52;c;Y2xpcGJvYXJk\x07\x1b[2Jdone\n界e\u0301😀";
+	const result = textResult("Successfully wrote to file.ts");
+	const context = { args: { path: "file.ts", content } };
+	const options = { expanded: true, isPartial: false };
+
+	assert.equal(renderToolResult(tool, result, options, context), "first\n\nsafedone\n界e\u0301😀");
+	const lines = frameLines(tool.renderResult(result, options, passthroughTheme, context), 16);
+	assert.ok(lines.every((line) => visibleWidth(line) <= 16));
+	assert.doesNotMatch(lines.join("\n"), /\x1b/);
+});
+
+test("quiet write expansion preserves failures, partial results and fallback confirmations", () => {
+	const tool = registeredQuietTools().get("write");
+	const context = { args: { path: "file.ts", content: "not written" } };
+	const options = { expanded: true, isPartial: false };
+	for (const errorContext of [context, { ...context, isError: true }]) {
+		const rendered = renderToolResult(tool, textResult("EACCES: permission denied"), { ...options, isError: true }, errorContext);
+		assert.equal(rendered, "EACCES: permission denied");
+	}
+	const partial = renderToolResult(tool, textResult("writing…"), { expanded: true, isPartial: true }, context);
+	assert.match(partial, /writing…/);
+	assert.doesNotMatch(partial, /not written/);
+	const confirmation = "Successfully wrote 0 bytes to file.ts";
+	for (const fallbackContext of [{}, { args: {} }, { args: { content: 42 } }, { args: { content: "" } }]) {
+		assert.equal(renderToolResult(tool, textResult(confirmation), options, fallbackContext), confirmation);
+	}
+});
+
 test("quiet tool rendering sanitizes collapsed output and call rows", () => {
 	const { pi, tools } = createPi();
 	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
@@ -1586,3 +1647,99 @@ test("quiet cards stay outlined in the neon style with a background-capable them
 	assert.match(rows.at(-1)!, /^╰─+╯$/);
 	assert.doesNotMatch(rows.join("\n"), /▎/);
 });
+
+// The Card content slot is process-wide; each test that needs a level sets it
+// and restores the previous one.
+function useCardContent(t: { after(fn: () => void): void }, level: (typeof CARD_CONTENT)[keyof typeof CARD_CONTENT]): void {
+	const previous = cardContent();
+	t.after(() => setCardContent(previous));
+	setCardContent(level);
+}
+
+test("the Card content preference defaults to the result previews", () => {
+	assert.equal(cardContent(), CARD_CONTENT.DEFAULT);
+	const rendered = renderToolResult(registeredQuietTools().get("read"), textResult("first line\nsecond line"), { expanded: false, isPartial: false }, {});
+	assert.match(rendered, /first line/);
+});
+
+test("minimal command-only cards keep the bounded error tail of failed calls", (t) => {
+	useCardContent(t, CARD_CONTENT.MINIMAL);
+	const tools = registeredQuietTools();
+	for (const toolName of ["read", "bash", "write", "grep", "find", "ls", "edit"] as const) {
+		const rendered = renderToolResult(tools.get(toolName), textResult("error one\nerror two\nerror three\nerror four"), { expanded: false, isPartial: false, isError: true }, toolName === "bash" ? { args: { command: "false" } } : {});
+		assert.match(rendered, /error two\nerror three\nerror four/, `${toolName}: a failed call says why while collapsed`);
+		assert.doesNotMatch(rendered, /to expand/);
+	}
+});
+
+test("every quiet tool card shows only the command while collapsed and stays expandable", (t) => {
+	useCardContent(t, CARD_CONTENT.MINIMAL);
+	const tools = registeredQuietTools();
+	const finished = { isPartial: false, executionStarted: true };
+	const cases: Array<[string, Record<string, unknown>, string, string]> = [
+		["read", { path: "a.ts" }, "first line\nsecond line", "first line"],
+		["write", { path: "b.ts", content: "body" }, "Successfully wrote 4 bytes", "body"],
+		["bash", { command: "printf hi" }, "hi\nthere", "there"],
+		["grep", { pattern: "needle", path: "src" }, "src/a.ts:1:needle", "src/a.ts:1:needle"],
+		["find", { pattern: "*.ts", path: "src" }, "src/a.ts\nsrc/b.ts", "src/b.ts"],
+		["ls", { path: "src" }, "file-a.ts\nfile-b.ts", "file-b.ts"],
+		["edit", { path: "file.ts", edits: [] }, "Applied edits", "Applied edits"],
+	];
+	for (const [name, args, output, visible] of cases) {
+		const tool = tools.get(name);
+		const context = routineRenderContext({ args, ...finished });
+		const callRows = tool.renderCall(args, passthroughTheme, context).render(120).map(stripAnsi);
+		assert.ok(callRows.some((row) => row.includes("to expand")), `${name}: the expand key stays`);
+		const collapsed = renderToString(tool.renderResult(textResult(output), { expanded: false, isPartial: false }, passthroughTheme, context));
+		assert.equal(collapsed.trim(), "", `${name}: no result rows while collapsed`);
+		const expanded = renderToString(tool.renderResult(textResult(output), { expanded: true, isPartial: false }, passthroughTheme, context));
+		assert.match(expanded, new RegExp(visible.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")), `${name}: expanding reveals the result`);
+	}
+});
+
+test("the default Card content preference restores result previews and native bash drawing", () => {
+	const tools = registeredQuietTools();
+	const read = tools.get("read");
+	setCardContent(CARD_CONTENT.DEFAULT);
+	try {
+		const context = routineRenderContext({ args: { path: "a.ts" }, executionStarted: true, isPartial: false });
+		const collapsed = renderToString(read.renderResult(textResult("first line\nsecond line"), { expanded: false, isPartial: false }, passthroughTheme, context));
+		assert.match(collapsed, /first line\nsecond line/, "default content keeps the read preview");
+		const write = renderToString(tools.get("write").renderResult(textResult("Successfully wrote 4 bytes"), { expanded: false, isPartial: false }, passthroughTheme, routineRenderContext({ args: { path: "b.ts", content: "body" }, executionStarted: true, isPartial: false })));
+		assert.match(write, /wrote 4 bytes/, "default content keeps the write summary");
+
+		const { pi } = createPi();
+		const resolvers: Array<(toolName: string, next: () => unknown) => unknown> = [];
+		(pi as any).registerToolRenderer = (resolver: (toolName: string, next: () => unknown) => unknown) => {
+			resolvers.push(resolver);
+		};
+		withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
+		const native = { marker: "native" };
+		assert.equal(resolvers.at(-1)!("bash", () => native), native, "default content defers bash drawing to the native renderer");
+		assert.equal(resolvers.at(-1)!("read", () => native), native, "every other tool still defers");
+	} finally {
+		setCardContent(CARD_CONTENT.DEFAULT);
+	}
+});
+
+test("the production factory takes over native bash drawing through a tool renderer resolver", (t) => {
+	useCardContent(t, CARD_CONTENT.MINIMAL);
+	const { pi } = createPi();
+	const resolvers: Array<(toolName: string, next: () => unknown) => unknown> = [];
+	(pi as any).registerToolRenderer = (resolver: (toolName: string, next: () => unknown) => unknown) => {
+		resolvers.push(resolver);
+	};
+	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
+	assert.ok(resolvers.length >= 1, "quiet tools registers a tool renderer resolver");
+	const resolver = resolvers.at(-1)!;
+	const native = { marker: "native" };
+	assert.equal(resolver("read", () => native), native, "every other tool keeps the next renderer");
+	const bash = resolver("bash", () => native) as any;
+	assert.notEqual(bash, native);
+	assert.equal(bash.renderShell, "self");
+	assert.equal(typeof bash.renderCall, "function");
+	assert.equal(typeof bash.renderResult, "function");
+	const call = bash.renderCall({ command: "printf hi", timeout: 5 }, passthroughTheme, routineRenderContext({ args: { command: "printf hi", timeout: 5 }, executionStarted: true, isPartial: false }));
+	assert.match(renderToString(call), /printf hi \(timeout 5s\)/);
+});
+

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

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import test from "node:test";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
+import { readDelegationDetail } from "./support/orchestrator-modules.ts";
 
 // ---------------------------------------------------------------------------
 // gentle-pi#661/#662: RDD-aware verification rule for delegated work.
@@ -14,15 +15,14 @@ import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
 // rendered `Receipt-driven development:` line, stated normatively exactly
 // once in trigger 5 (Verification rule) and referenced -- not restated --
 // everywhere else in this asset:
-//   - `on`             -> the writer's own report is the verification of
-//                         record; `gentle-ai-verify` is on-demand, except
-//                         passive risk, which gets a structural readback.
-//   - `off`/`unknown`  -> gentle-pi#662: the parent calls `gentle_review` with
+//   - every line (`on`, `off`, `unknown`) -> verify-always-rdd-high S1: the
+//                         parent calls `gentle_review` with
 //                         `{"operation":"assess"}` over the writer's diff and
 //                         follows the returned plan by native risk tier
 //                         (passive/medium/high/unassessable), instead of a
-//                         blanket non-trivial judgment. An unknown RDD line
-//                         never lowers a tier below `off`.
+//                         blanket non-trivial judgment.
+//   - `on`             -> the native review is an additional outside view; it
+//                         never replaces or skips the tier's verification.
 // These tests assert the exact distinctive sentences (not bare words like
 // `off`/`unknown`/`partial`/`blocked`), that the tier table is stated exactly
 // once, that the routing ladder paragraph references trigger 5 rather than
@@ -41,14 +41,14 @@ function countOccurrences(haystack: string, needle: string): number {
 	return haystack.split(needle).length - 1;
 }
 
-const delegation = read("assets/orchestrator-delegation.md");
+const delegation = readDelegationDetail();
 const worker = read("assets/agents/gentle-ai-worker.md");
 
-const ON_SENTENCE =
-	"When the line reads `on`, that writer report is the verification of record, and the native review is the independent check the writer cannot influence";
-const OFF_UNKNOWN_SENTENCE =
-	'When the line reads `off` or `unknown`, after the writer returns, call `gentle_review` with `{"operation":"assess"}` over the writer\'s diff and follow the returned plan instead of judging non-triviality from the task description: the operation resolves the native risk tier and states exactly who verifies next.';
-const TIER_TABLE_HEADER = "| Native risk tier | Verification when RDD is `off`/`unknown` |";
+const ROUTING_SENTENCE =
+	'After the writer returns, call `gentle_review` with `{"operation":"assess"}` over the writer\'s diff and follow the returned plan, whatever the `Receipt-driven development:` line reads (`on`, `off`, or `unknown`), instead of judging non-triviality from the task description: the operation resolves the native risk tier and states exactly who verifies next.';
+const RDD_ON_SENTENCE =
+	"When the line reads `on`, the native review is an additional outside view of the change; it never replaces or skips the tier's verification, and the tier's verifier runs before review.";
+const TIER_TABLE_HEADER = "| Native risk tier | Verification (any RDD state) |";
 const PASSIVE_TIER_ROW = "| passive | structural readback by the parent; no separate verifier, no tests |";
 const MEDIUM_TIER_ROW = "| medium | writer self-verification stands; a separate `gentle-ai-verify` run is added only when the writer profile is a small model (mini or low effort) |";
 const HIGH_TIER_ROW = "| high | writer self-verification plus a separate `gentle-ai-verify` run, always |";
@@ -57,19 +57,15 @@ const SMALL_MODEL_BIAS_SENTENCE =
 	"The small-model bias raises the tier by one for verification purposes (medium becomes high); 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.";
-// gentle-pi#668: the `on` branch of trigger 5 holds only while the native
-// review actually reaches a terminal outcome for this candidate -- a decline,
-// a clone-local disable, or a refused START/STATUS all fall back to the exact
-// same risk-gated path as `off`.
-const ON_BRANCH_FALLBACK_SENTENCE =
-	'That `on` branch holds only while the native review actually reaches a terminal outcome for this candidate (gentle-pi#668): a human decline of the consent envelope for this candidate (candidate-scoped, never the RDD kill switch), a clone-local RDD disable discovered mid-flow, or a refused START/STATUS all fall back to the risk-gated path exactly as `off` -- call `gentle_review` with `{"operation":"assess"}` (pass `nativeReviewOutcome` when the parent already knows it; the tool derives it from what it itself observed for the candidate otherwise, failing closed to `unknown` when it cannot) and follow the returned plan.';
-
-test("trigger 5 (Verification rule) states the exact on-line routing: writer report is the verification of record", () => {
-	assert.ok(delegation.includes(ON_SENTENCE), "trigger 5 is missing the exact on-line sentence");
+test("trigger 5 (Verification rule) routes every RDD line through assess and the risk tier", () => {
+	assert.ok(delegation.includes(ROUTING_SENTENCE), "trigger 5 is missing the exact routing sentence");
 });
 
-test("trigger 5 states the exact off/unknown-line routing: the parent calls gentle_review's assess operation and follows the returned plan", () => {
-	assert.ok(delegation.includes(OFF_UNKNOWN_SENTENCE), "trigger 5 is missing the exact off/unknown-line sentence");
+test("trigger 5 states that with RDD on the native review adds an outside view and never replaces verification", () => {
+	assert.ok(delegation.includes(RDD_ON_SENTENCE), "trigger 5 is missing the RDD-on sentence");
+	for (const banned of ["verification of record", "becomes on-demand", "on-demand only", "on-demand verify"]) {
+		assert.ok(!delegation.includes(banned), `the native review still replaces verification somewhere: ${banned}`);
+	}
 });
 
 test("trigger 5 states the native risk tier table exactly once, with all four rows", () => {
@@ -86,21 +82,14 @@ test("trigger 5 keeps the parent spot check requirement in every tier", () => {
 	assert.ok(delegation.includes(SPOT_CHECK_SENTENCE), "trigger 5 is missing the parent spot check sentence");
 });
 
-test("trigger 5 states that the on branch holds only while the native review closes for this candidate, falling back to the off path exactly once (gentle-pi#668)", () => {
-	assert.equal(countOccurrences(delegation, ON_BRANCH_FALLBACK_SENTENCE), 1, "trigger 5 is missing (or duplicates) the on-branch fallback sentence");
-});
-
-test("the on-branch fallback sentence names all three non-closed triggers and never introduces a forbidden native RDD marker", () => {
-	for (const clause of ["decline", "clone-local", "refused START/STATUS"]) {
-		assert.ok(ON_BRANCH_FALLBACK_SENTENCE.includes(clause), `on-branch fallback sentence missing: ${clause}`);
-	}
+test("trigger 5 never introduces a forbidden native RDD marker", () => {
 	for (const marker of ["gentle-ai review status", "next_transition", "review.capture-result", "review.validate", "reviewGate.result"]) {
 		assert.ok(!delegation.includes(marker), `stale/forbidden RDD marker introduced: ${marker}`);
 	}
 });
 
-test("the on-line and off/unknown-line routing sentences appear exactly once each (normative statement lives only in trigger 5)", () => {
-	for (const sentence of [ON_SENTENCE, OFF_UNKNOWN_SENTENCE]) {
+test("the routing and RDD-on sentences appear exactly once each (normative statement lives only in trigger 5)", () => {
+	for (const sentence of [ROUTING_SENTENCE, RDD_ON_SENTENCE]) {
 		assert.equal(countOccurrences(delegation, sentence), 1, `expected exactly one occurrence of: ${sentence.slice(0, 60)}...`);
 	}
 });
@@ -110,15 +99,15 @@ test("trigger 5 never restates the retired #661 off/unknown non-trivial judgment
 	assert.doesNotMatch(delegation, /purely passive documentation with no behavior to verify/);
 });
 
-test("the Simple Delegation paragraph references trigger 5 instead of restating the on/off/unknown routing", () => {
+test("the Simple Delegation paragraph references trigger 3 instead of restating the on/off/unknown routing", () => {
 	assert.match(
 		delegation,
-		/per the RDD-aware Verification rule \(trigger 5 under Mandatory Delegation Triggers, gentle-pi#661\)/,
+		/per the RDD-aware Verification rule \(trigger 3 under Mandatory Delegation Triggers, gentle-pi#661\)/,
 	);
-	assert.match(delegation, /the normative on\/off\/unknown routing lives there, not here/);
+	assert.match(delegation, /the normative on\/off\/unknown routing lives in `orchestrator-verification.md`, not here/);
 });
 
-test("delegation overlay's trigger 5 (Verification rule) is RDD-aware", () => {
+test("delegation overlay's Verification rule is RDD-aware", () => {
 	assert.match(delegation, /\*\*Verification rule\*\*.*RDD-aware/);
 });
 
@@ -194,8 +183,8 @@ test("delegation asset references the worker's Known environmental failures defi
 });
 
 test("worker asset never claims completion while a required verification command fails under RDD, except a named environmental failure", () => {
-	assert.match(worker, /this report is the verification of record/i);
-	assert.match(worker, /native review remains the independent check/i);
+	assert.doesNotMatch(worker, /verification of record/i);
+	assert.match(worker, /this report is your self-verification; the risk tier decides whether an independent verifier also runs/i);
 	assert.match(
 		worker,
 		/never report `status: completed` while a required command under `## Verification` is failing, unless that exact failure is named under `## Known environmental failures`\./i,
@@ -279,8 +268,7 @@ const SHARED_POLICY_PHRASES: ReadonlyArray<readonly [string, string]> = [
 	["runtime writer profile", "runtime-recorded model and effort of the pending mutations"],
 	["caller profile is only a fallback", "only a fallback when no runtime evidence exists"],
 	["conservative small-model bias", "keeps the conservative small-model bias"],
-	["non-closed outcomes fall back", "declined, unavailable, or unknown"],
-	["unknown is never closed", "unknown is never treated as closed"],
+	["native review never replaces verification (verify-always-rdd-high S1)", "native review is an additional outside view"],
 	["functional checks still run", "a native code review is not a substitute for applicable functional checks"],
 ];
 

package/tests/rdd-status-line.test.ts

@@ -306,3 +306,55 @@ test("the on and off renders are never longer than the unknown (worst-case) rend
 		}
 	}
 });
+
+// gentle-shell#1029: the rendered RDD line is part of the cached system-prompt
+// prefix. A re-read after the TTL that fails or times out must not flip a
+// known on/off line to "unknown" and back: the last successfully read status
+// stays until the native reader reports a different status.
+test("resolveRddModeStatus keeps the last known status when a later re-read fails", async () => {
+	clearRddStatusMemoForTesting();
+	const cwd = "/repo-sticky-status";
+	let clock = 1_000_000;
+	const now = () => clock;
+	let fail = false;
+	let calls = 0;
+	const cli: Pick<NativeReviewCli, "reviewMode"> = {
+		async reviewMode() {
+			calls += 1;
+			if (fail) throw new Error("native review CLI unavailable");
+			return modeResult("on", NATIVE_REVIEW_MODE_SOURCE.GLOBAL);
+		},
+	};
+	const first = await resolveRddModeStatus(cli, cwd, undefined, now);
+	assert.equal(first?.effective, "on");
+	fail = true;
+	clock += RDD_STATUS_MEMO_TTL_MS + 1;
+	const second = await resolveRddModeStatus(cli, cwd, undefined, now);
+	assert.equal(calls, 2, "the expired memo must still trigger a re-read");
+	assert.deepEqual(second, first, "a failed re-read must keep the last known status, not render unknown");
+	assert.equal(
+		await resolveRddStatusLine(cli, cwd, undefined, now),
+		"Receipt-driven development: on (decided by global)",
+	);
+});
+
+test("resolveRddModeStatus still follows a real status change after a re-read", async () => {
+	clearRddStatusMemoForTesting();
+	const cwd = "/repo-status-change";
+	let clock = 1_000_000;
+	const now = () => clock;
+	let effective: "on" | "off" = "on";
+	const cli: Pick<NativeReviewCli, "reviewMode"> = {
+		async reviewMode() { return modeResult(effective, NATIVE_REVIEW_MODE_SOURCE.GLOBAL); },
+	};
+	assert.equal((await resolveRddModeStatus(cli, cwd, undefined, now))?.effective, "on");
+	effective = "off";
+	clock += RDD_STATUS_MEMO_TTL_MS + 1;
+	assert.equal((await resolveRddModeStatus(cli, cwd, undefined, now))?.effective, "off");
+});
+
+test("resolveRddModeStatus stays unknown when no status was ever read", async () => {
+	clearRddStatusMemoForTesting();
+	const cli = fakeReviewMode(() => { throw new Error("never available"); });
+	assert.equal(await resolveRddModeStatus(cli, "/repo-never-known"), undefined);
+});

package/tests/render-cache-performance.test.ts

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { closeSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { compare, outputDescriptor, percentile, summarize } from "../scripts/render-cache-performance.mjs";
+
+test("summaries preserve raw samples and interpolate percentiles", () => {
+	const samples = [4, 1, 3, 2];
+	assert.equal(percentile(samples, 0.5), 2.5);
+	assert.ok(Math.abs(percentile(samples, 0.95)! - 3.85) < 1e-10);
+	assert.deepEqual(samples, [4, 1, 3, 2]);
+	assert.deepEqual(summarize([]), { count: 0, median: null, p95: null, max: null });
+});
+
+const run = () => ({ metadata: { piVersion: "1.1.0", editorIdentityVerified: true }, cases: [{
+	spec: { tools: 100, scenario: "scroll" }, coldScreen: "cold", screens: ["screen"], wallMs: [2, 2],
+}] });
+
+test("comparison requires identical cold and warm outputs and host identity", () => {
+	const before = run();
+	const after = run();
+	after.cases[0]!.wallMs = [1, 1];
+	assert.equal(compare(before, after)[0]!.speedup, 2);
+	after.cases[0]!.screens = ["changed"];
+	assert.throws(() => compare(before, after));
+	after.cases[0]!.screens = ["screen"];
+	after.cases[0]!.coldScreen = "changed";
+	assert.throws(() => compare(before, after), "cold output must also agree");
+	after.cases[0]!.coldScreen = "cold";
+	after.metadata.piVersion = "other-host";
+	assert.throws(() => compare(before, after), "cannot compare different Pi versions");
+});
+
+test("report outputs cannot overwrite files or enter protected roots via symlinks", () => {
+	const home = mkdtempSync(join(tmpdir(), "render-cache-output-"));
+	try {
+		const source = join(home, "source"); mkdirSync(source);
+		symlinkSync(source, join(home, "alias"), "dir");
+		assert.throws(() => outputDescriptor(join(home, "alias", "report.json"), [source]));
+		const existing = join(home, "existing.json"); writeFileSync(existing, "keep");
+		assert.throws(() => outputDescriptor(existing, [source]));
+		symlinkSync(existing, join(home, "link.json"));
+		assert.throws(() => outputDescriptor(join(home, "link.json"), [source]));
+		assert.equal(readFileSync(existing, "utf8"), "keep");
+		closeSync(outputDescriptor(join(home, "new.json"), [source]));
+	} finally { rmSync(home, { recursive: true, force: true }); }
+});