gentle-pi 2.4.0 → 2.6.0

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

@@ -3,6 +3,7 @@ import { realpathSync } from "node:fs";
 import test from "node:test";
 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 piPretty from "../extensions/pi-pretty.ts";
 import quietTools, {
 	countNonEmptyLines,
@@ -172,6 +173,7 @@ test("quiet tool rendering registers noisy built-in tools", () => {
 		for (const toolName of ["read", "bash", "grep", "find", "ls", "edit", "write"]) {
 			const tool = tools.get(toolName);
 			assert.ok(tool, `missing quiet renderer for ${toolName}`);
+			assert.equal(tool.renderShell, "self", `${toolName} must opt out of Pi's painted Box`);
 			assert.equal(typeof tool.execute, "function", `${toolName} must delegate execution`);
 			assert.ok(tool.parameters, `${toolName} must preserve built-in parameters`);
 		}
@@ -180,7 +182,16 @@ test("quiet tool rendering registers noisy built-in tools", () => {
 
 test("quiet tool execution uses the tool-call cwd", async () => {
 	const tool = registeredQuietTools().get("bash");
-	const output = extractTextContent(await tool.execute("tool-call", { command: "pwd" }, new AbortController().signal, undefined, { cwd: "/tmp" })).trim();
+	const context = {
+		cwd: "/tmp",
+		sessionManager: {
+			getSessionId: () => "quiet-tool-test",
+			getSessionFile: () => undefined,
+		},
+	};
+	const output = extractTextContent(
+		await tool.execute("tool-call", { command: "pwd" }, new AbortController().signal, undefined, context),
+	).trim();
 	// pwd prints the physical directory: on macOS /tmp is a symlink to /private/tmp.
 	assert.equal(output, realpathSync("/tmp"));
 	assert.notEqual(output, process.cwd());
@@ -472,21 +483,21 @@ test("quiet tool rendering hides every collapsed direct Gentle AI result and pre
 	const nonText = renderToString(tool.renderResult({ content: [{ type: "image", data: "opaque", mimeType: "image/png" }] }, { expanded: false, isPartial: false }, passthroughTheme, { args: { command } }));
 
 	assert.equal([...textRose].length, 2);
-	assert.equal(call.trimEnd(), `${textRose} Gentle AI · running · review status`);
-	assert.equal(collapsed, expandHint);
-	assert.equal(collapsed.split("\n")[0], expandHint);
+	assert.equal(cardTitle(call), `🌹︎ Gentle AI · running · review status`);
+	assert.match(cardBody(collapsed), /\d+ lines?\b/);
+	assert.match(cardBody(collapsed), /\d+ lines?\b/);
 	assert.doesNotMatch(collapsed, /next_transition|stop/);
-	assert.equal(expanded.split("\n")[0], '{"next_transition":"stop"}');
+	assert.equal(cardBody(expanded).split("\n")[0], '{"next_transition":"stop"}');
 	assert.match(expanded, /"next_transition":"stop"/);
 	assert.doesNotMatch(expanded, /to expand/);
-	assert.equal(failure, expandHint);
+	assert.match(cardBody(failure), /\d+ lines?\b/);
 	assert.doesNotMatch(failure, /review status failed|authority unavailable|lineage=secret/);
 	assert.match(expandedFailure, /review status failed: authority unavailable/);
 	assert.match(expandedFailure, /lineage=secret/);
 	assert.doesNotMatch(expandedFailure, /to expand/);
-	assert.doesNotMatch(expandedFailure, /\x1b\[/);
-	assert.equal(empty, "");
-	assert.equal(nonText, "");
+	assert.doesNotMatch(cardBody(expandedFailure), /\x1b\[/);
+	assert.equal(cardBody(empty), "");
+	assert.equal(cardBody(nonText), "");
 });
 
 test("quiet tool rendering transitions one Gentle AI header through lifecycle states", () => {
@@ -528,16 +539,16 @@ test("quiet tool rendering transitions one Gentle AI header through lifecycle st
 	assert.strictEqual(initial, running);
 	assert.strictEqual(running, completed);
 	assert.strictEqual(completed, failed);
-	assert.equal(initialText, "<warning>🌹︎ Gentle AI · running · review status</warning>");
-	assert.equal(runningText, "<warning>🌹︎ Gentle AI · running · review status</warning>");
-	assert.equal(completedText, "<success>🌹︎ Gentle AI · completed · review status</success>");
-	assert.equal(failedText, "<error>🌹︎ Gentle AI · failed · review status</error>");
+	assert.equal(cardTitle(initialText), "🌹︎ Gentle AI · running · review status"); assert.equal(cardTone(initialText), "warning");
+	assert.equal(cardTitle(runningText), "🌹︎ Gentle AI · running · review status"); assert.equal(cardTone(runningText), "warning");
+	assert.equal(cardTitle(completedText), "🌹︎ Gentle AI · completed · review status"); assert.equal(cardTone(completedText), "success");
+	assert.equal(cardTitle(failedText), "🌹︎ Gentle AI · failed · review status"); assert.equal(cardTone(failedText), "error");
 	assert.doesNotMatch(failedText, /private-change/);
 });
 
 test("quiet Bash keeps direct Gentle AI calls seamless while streaming", () => {
 	const tool = registeredQuietTools().get("bash");
-	const rose = /🌹︎/;
+	const rose = /🌹︎ Gentle AI/;
 	const render = (command: string, state: Record<string, unknown>, overrides: Record<string, unknown> = {}) => {
 		const component = tool.renderCall({ command }, passthroughTheme, routineRenderContext({ args: { command }, state, argsComplete: false, ...overrides }));
 		return [component, renderToString(component)] as const;
@@ -545,14 +556,14 @@ test("quiet Bash keeps direct Gentle AI calls seamless while streaming", () => {
 	const command = "gentle-ai review status --token 'lineage-secret";
 	const state = {};
 	const [preparing, collapsed] = render(command, state);
-	assert.equal(collapsed, "🌹︎ Gentle AI · preparing · review status");
+	assert.equal(cardTitle(collapsed), "🌹︎ Gentle AI · preparing · review status");
 	assert.doesNotMatch(collapsed, /token|lineage-secret/);
 	const expanded = render(command, state, { expanded: true, lastComponent: preparing })[1];
-	assert.match(expanded, /^🌹︎ Gentle AI · preparing · review status\n\$ gentle-ai review status --token 'lineage-secret$/);
+	assert.equal(cardTitle(expanded), "🌹︎ Gentle AI · preparing · review status"); assert.equal(cardBody(expanded), "$ gentle-ai review status --token 'lineage-secret");
 
 	const direct = "gentle-ai review status";
 	const [running, runningText] = render(direct, state, { argsComplete: true, executionStarted: true, lastComponent: preparing });
-	assert.strictEqual(running, preparing); assert.equal(runningText, "🌹︎ Gentle AI · running · review status");
+	assert.strictEqual(running, preparing); assert.equal(cardTitle(runningText), "🌹︎ Gentle AI · running · review status");
 	const genericState = {};
 	const [generic, genericText] = render("gentle-ai review status | cat", genericState);
 	assert.doesNotMatch(genericText, rose); assert.match(genericText, /\| cat/);
@@ -569,7 +580,7 @@ test("quiet Bash keeps direct Gentle AI calls seamless while streaming", () => {
 	assert.equal(genericResult.split("\n")[0], "generic result");
 	const directState = {}; render(direct, directState, { argsComplete: true });
 	const directResult = renderToolResult(tool, textResult("direct result"), { expanded: false, isPartial: false }, { args: { command: direct }, state: directState, argsComplete: true });
-	assert.equal(directResult, keyHint("app.tools.expand", "to expand"));
+	assert.match(cardBody(directResult), /\d+ lines?\b/);
 });
 
 test("quiet tool rendering displays only finite safe Gentle AI operation paths", () => {
@@ -635,7 +646,7 @@ test("quiet tool rendering displays only finite safe Gentle AI operation paths",
 				routineRenderContext({ args: { command } }),
 			),
 		);
-		assert.equal(rendered.trimEnd(), `${rose} Gentle AI · running · ${path}`, command);
+		assert.equal(cardTitle(rendered), `🌹︎ Gentle AI · running · ${path}`, command);
 		assert.doesNotMatch(rendered, /change-123|private|secret|lineage|sha256|result\.json|incident\.json/);
 	}
 });
@@ -658,7 +669,7 @@ test("quiet tool rendering covers version and future standalone Gentle AI comman
 		const rendered = renderToString(
 			tool.renderCall({ command }, passthroughTheme, routineRenderContext({ args: { command } })),
 		);
-		assert.equal(rendered.trimEnd(), `${rose} Gentle AI · running · ${path}`, command);
+		assert.equal(cardTitle(rendered), `🌹︎ Gentle AI · running · ${path}`, command);
 		assert.doesNotMatch(rendered, /authorization-root|secret-change|private|C:\\\\private/);
 	}
 });
@@ -686,7 +697,7 @@ test("quiet tool rendering recognizes exact quoted, escaped, Windows, and comman
 
 	for (const command of routineCommands) {
 		const call = renderToString(tool.renderCall({ command }, passthroughTheme, { args: { command } }));
-		assert.equal(call.trimEnd(), "🌹︎ Gentle AI · running · version", command);
+		assert.equal(cardTitle(call), "🌹︎ Gentle AI · running · version", command);
 	}
 
 	for (const command of ["'gentle-ai-copy' version", '"gentle-ai-copy.exe" version', "'gentle-ai' version && echo done"] as const) {
@@ -713,7 +724,7 @@ test("quiet tool rendering recognizes only the exact resolved dev binary", () =>
 	] as const;
 	for (const [command, operationPath] of cases) {
 		const call = renderToString(tool.renderCall({ command }, statusTheme, routineRenderContext({ args: { command } })));
-		assert.equal(call.trimEnd(), `<warning>🌹︎ Gentle AI · running · ${operationPath}</warning>`, command);
+		assert.equal(cardTitle(call), `🌹︎ Gentle AI · running · ${operationPath}`, command); assert.equal(cardTone(call), "warning", command);
 		assert.doesNotMatch(call, /gentle-ai-main|private|secret|hidden/);
 	}
 	const command = `${devPath} review status --prompt hidden-prompt --lineage lineage-secret --body private-body`;
@@ -728,11 +739,11 @@ test("quiet tool rendering recognizes only the exact resolved dev binary", () =>
 	const expanded = renderToolResult(tool, textResult(text), { expanded: true, isPartial: false, isError: true }, lifecycleContext);
 	const refreshed = renderToolResult(tool, textResult("result-secret"), { expanded: false, isPartial: false }, { args: { command: refreshedCommand } });
 	const hint = keyHint("app.tools.expand", "to expand");
-	assert.equal(collapsed, hint);
-	assert.equal(collapsed.split(hint).length - 1, 1);
+	assert.match(cardBody(collapsed), /\d+ lines?\b/);
+	assert.equal(cardBody(collapsed).split(hint).length - 1, 0);
 	assert.doesNotMatch(collapsed, /private|lineage|secret|hidden|error/);
 	assert.match(expanded, /private failure|lineage=secret body=hidden/);
-	assert.doesNotMatch(expanded, /to expand|\x1b\[/);
+	assert.doesNotMatch(cardBody(expanded), /to expand|\x1b\[/);
 	assert.doesNotMatch(refreshed, /result-secret/);
 	assert.ok(resolutions > 1);
 });
@@ -794,12 +805,12 @@ test("quiet tool rendering hides the routine partial result because the header o
 		),
 	);
 
-	assert.equal(partial, expandHint);
-	assert.equal(partial.split(expandHint).length - 1, 1);
+	assert.match(cardBody(partial), /\d+ lines?\b/);
+	assert.equal(cardBody(partial).split(expandHint).length - 1, 0);
 	assert.match(partialExpanded, /"status":"running"/);
 	assert.doesNotMatch(partialExpanded, /to expand/);
-	assert.equal(partialFailure, expandHint);
-	assert.equal(completed, expandHint);
+	assert.match(cardBody(partialFailure), /\d+ lines?\b/);
+	assert.match(cardBody(completed), /\d+ lines?\b/);
 
 	const partialExpandedFailure = renderToString(
 		tool.renderResult(
@@ -810,7 +821,7 @@ test("quiet tool rendering hides the routine partial result because the header o
 		),
 	);
 	assert.match(partialExpandedFailure, /review status failed: authority unavailable/);
-	assert.doesNotMatch(partialExpandedFailure, /\x1b\[/);
+	assert.doesNotMatch(cardBody(partialExpandedFailure), /\x1b\[/);
 });
 
 test("quiet tool rendering collapses grant calls to action and authorization-root cardinality", () => {
@@ -844,8 +855,8 @@ test("quiet tool rendering collapses grant calls to action and authorization-roo
 	assert.strictEqual(running, completed);
 	assert.strictEqual(completed, failed);
 	const rendered = renderToString(failed);
-	assert.equal(rendered, "<error>🌹︎ Gentle AI · failed · sdd attempt grant · 2 roots</error>");
-	assert.doesNotMatch(rendered, /authorization-root|secret-change|repo\/root|other\/root|audit:|\x1b\[/);
+	assert.equal(cardTitle(rendered), "🌹︎ Gentle AI · failed · sdd attempt grant · 2 roots"); assert.equal(cardTone(rendered), "error");
+	assert.doesNotMatch(rendered.split(keyHint("app.tools.expand", "to expand")).join(""), /authorization-root|secret-change|repo\/root|other\/root|audit:|\x1b\[/);
 });
 
 test("quiet tool rendering counts grant authorization roots without rendering values", () => {
@@ -863,7 +874,7 @@ test("quiet tool rendering counts grant authorization roots without rendering va
 
 	for (const [command, expected] of cases) {
 		const rendered = renderToString(tool.renderCall({ command }, passthroughTheme, { args: { command } }));
-		assert.equal(rendered.trimEnd(), `🌹︎ Gentle AI · running · ${expected}`, command);
+		assert.equal(cardTitle(rendered), `🌹︎ Gentle AI · running · ${expected}`, command);
 		assert.doesNotMatch(rendered, /authorization-root|\/repo\/root|\/one|\/two|\/three|change/);
 	}
 });
@@ -883,8 +894,8 @@ test("quiet tool rendering hides invocation secrets from collapsed Gentle AI cal
 		),
 	);
 
-	assert.equal(call.trimEnd(), "🌹︎ Gentle AI · running · review finalize");
-	assert.equal(collapsed, keyHint("app.tools.expand", "to expand"));
+	assert.equal(cardTitle(call), "🌹︎ Gentle AI · running · review finalize");
+	assert.match(cardBody(collapsed), /\d+ lines?\b/);
 	for (const forbidden of ["hidden-prompt", "lineage-secret", "private-body", "/private/root", "audit:"]) {
 		assert.doesNotMatch(call, new RegExp(forbidden));
 		assert.doesNotMatch(collapsed, new RegExp(forbidden));
@@ -973,7 +984,7 @@ test("quiet tool rendering sanitizes collapsed output and call rows", () => {
 
 	const carriageReturn = renderToolResult(tools.get("bash"), textResult("prefix\rSECRET\r\nnext"), { expanded: false, isPartial: false }, { args: { command: "printf output" } });
 	assert.match(collapsed, /safered/);
-	assert.doesNotMatch(collapsed, /\x1b\[31m|\x1b\[0m/);
+	assert.doesNotMatch(cardBody(collapsed), /\x1b\[31m|\x1b\[0m/);
 	assert.equal(call.trimEnd(), "$ echo red");
 	assert.match(carriageReturn, /prefixSECRET\nnext/);
 	assert.doesNotMatch(carriageReturn, /\r/);
@@ -1064,7 +1075,7 @@ test("quiet tool rendering recognizes a quoted exact dev override path containin
 	const command = `"${devPath}" review status "literal \\$|#;"`;
 	const call = renderToString(tool.renderCall({ command }, passthroughTheme, { args: { command } }));
 	const collapsed = renderToolResult(tool, textResult("private result"), { expanded: false, isPartial: false }, { args: { command } });
-	assert.equal(call.trimEnd(), "🌹︎ Gentle AI · running · review status");
+	assert.equal(cardTitle(call), "🌹︎ Gentle AI · running · review status");
 	assert.doesNotMatch(call, /\/opt\/Gentle AI\/gentle-ai|literal/);
 	assert.doesNotMatch(collapsed, /private result/);
 });
@@ -1274,3 +1285,52 @@ test("quiet tool rendering respects command and env wrapper order", () => {
 	assert.equal(gentleAiRoutineCommand({ command }), undefined);
 	assertGenericBash(bash, command);
 });
+
+test("quiet tool rendering lets a final result promote a replayed call card to its outcome", async () => {
+	// The promotion invalidates after the render returns (a microtask), never inside it.
+	const flush = () => new Promise((resolve) => queueMicrotask(() => resolve(undefined)));
+	const { pi, tools } = createPi();
+	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
+	const tool = tools.get("bash");
+	const command = "gentle-ai review status";
+	const state = {};
+	let invalidations = 0;
+	const replayed = routineRenderContext({ args: { command }, state, argsComplete: false, executionStarted: false, isPartial: false, invalidate: () => { invalidations += 1; } });
+
+	const call = tool.renderCall({ command }, statusTheme, replayed);
+	assert.equal(cardTitle(renderToString(call)), "🌹︎ Gentle AI · preparing · review status");
+	renderToString(tool.renderResult(textResult("done"), { expanded: false, isPartial: false }, statusTheme, replayed));
+	assert.equal(invalidations, 0, "never reentrant");
+	await flush();
+	assert.equal(invalidations, 1);
+	const promoted = tool.renderCall({ command }, statusTheme, { ...replayed, lastComponent: call });
+	assert.strictEqual(promoted, call);
+	assert.equal(cardTitle(renderToString(promoted)), "🌹︎ Gentle AI · completed · review status");
+	assert.equal(cardTone(renderToString(promoted)), "success");
+
+	renderToString(tool.renderResult(textResult("boom"), { expanded: false, isPartial: false }, statusTheme, { ...replayed, isError: true }));
+	await flush();
+	assert.equal(invalidations, 2);
+	assert.equal(cardTitle(renderToString(tool.renderCall({ command }, statusTheme, { ...replayed, lastComponent: call }))), "🌹︎ Gentle AI · failed · review status");
+	renderToString(tool.renderResult(textResult("boom"), { expanded: false, isPartial: false }, statusTheme, { ...replayed, isError: true }));
+	await flush();
+	assert.equal(invalidations, 2, "an unchanged outcome must not request another render");
+});
+
+test("quiet tool rendering puts the expand key in the finished call card's top rule, not in the result", () => {
+	const { pi, tools } = createPi();
+	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
+	const tool = tools.get("bash");
+	const command = "gentle-ai review status";
+	const running = renderToString(tool.renderCall({ command }, passthroughTheme, routineRenderContext({ args: { command }, executionStarted: true, isPartial: true })));
+	assert.equal(cardHint(running), undefined, "a running call has nothing to expand yet");
+	const completed = renderToString(tool.renderCall({ command }, passthroughTheme, routineRenderContext({ args: { command }, executionStarted: true, isPartial: false, expanded: false })));
+	assert.match(cardHint(completed) ?? "", /to expand$/);
+	assert.equal(cardTitle(completed), "🌹︎ Gentle AI · completed · review status");
+	const expanded = renderToString(tool.renderCall({ command }, passthroughTheme, routineRenderContext({ args: { command }, executionStarted: true, isPartial: false, expanded: true })));
+	assert.match(cardHint(expanded) ?? "", /to collapse$/);
+	const collapsedResult = renderToolResult(tool, textResult("{\"next_transition\":\"stop\"}"), { expanded: false, isPartial: false }, { args: { command } });
+	assert.equal(cardBody(collapsedResult), "1 line");
+	assert.equal(cardBody(renderToolResult(tool, textResult("a\nb\nc"), { expanded: false, isPartial: false }, { args: { command } })), "3 lines");
+	assert.match(collapsedResult.split("\n").pop() ?? "", /╰─+╯$/);
+});

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

@@ -0,0 +1,226 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+
+// ---------------------------------------------------------------------------
+// gentle-pi#661/#662: RDD-aware verification rule for delegated work.
+//
+// The bounded writer always self-verifies: it runs the parent-authorized
+// `## Verification` commands itself and reports observed output. Whether a
+// SEPARATE `gentle-ai-verify` delegation is also required depends on the
+// 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
+//                         `{"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`.
+// 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
+// restating it, and that `## Known environmental failures` has one canonical
+// definition (owned by the worker asset) that the delegation asset
+// references rather than duplicates.
+// ---------------------------------------------------------------------------
+
+const ROOT = join(import.meta.dirname, "..");
+
+function read(relativePath: string): string {
+	return readFileSync(join(ROOT, relativePath), "utf8");
+}
+
+function countOccurrences(haystack: string, needle: string): number {
+	return haystack.split(needle).length - 1;
+}
+
+const delegation = read("assets/orchestrator-delegation.md");
+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 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 |";
+const UNASSESSABLE_TIER_ROW = "| unknown / assess failed | treated as high |";
+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 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 the native risk tier table exactly once, with all four rows", () => {
+	for (const row of [TIER_TABLE_HEADER, PASSIVE_TIER_ROW, MEDIUM_TIER_ROW, HIGH_TIER_ROW, UNASSESSABLE_TIER_ROW]) {
+		assert.equal(countOccurrences(delegation, row), 1, `expected exactly one occurrence of tier table row: ${row}`);
+	}
+});
+
+test("trigger 5 states the small-model bias and the unknown-never-lowers-a-tier rule", () => {
+	assert.ok(delegation.includes(SMALL_MODEL_BIAS_SENTENCE), "trigger 5 is missing the small-model bias sentence");
+});
+
+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}`);
+	}
+	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]) {
+		assert.equal(countOccurrences(delegation, sentence), 1, `expected exactly one occurrence of: ${sentence.slice(0, 60)}...`);
+	}
+});
+
+test("trigger 5 never restates the retired #661 off/unknown non-trivial judgment", () => {
+	assert.doesNotMatch(delegation, /non-trivial change, in addition to the writer's own report/);
+	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", () => {
+	assert.match(
+		delegation,
+		/per the RDD-aware Verification rule \(trigger 5 under Mandatory Delegation Triggers, gentle-pi#661\)/,
+	);
+	assert.match(delegation, /the normative on\/off\/unknown routing lives there, not here/);
+});
+
+test("delegation overlay's trigger 5 (Verification rule) is RDD-aware", () => {
+	assert.match(delegation, /\*\*Verification rule\*\*.*RDD-aware/);
+});
+
+test("delegation overlay reserves separate exploration for parent routing decisions", () => {
+	assert.match(delegation, /exploration stays reserved for when the parent needs the map to decide or route/i);
+	assert.match(delegation, /reading that prepares a write belongs with the writer/i);
+});
+
+test("delegation overlay keeps the required headings", () => {
+	for (const heading of [
+		"### Delegation Rules",
+		"#### Background Subagent Policy",
+		"#### Allowed edit surfaces (MANDATORY)",
+		"### 3. SDD (optional)",
+	]) {
+		assert.ok(delegation.includes(heading), `delegation overlay lost required heading: ${heading}`);
+	}
+});
+
+test("worker asset declares the Verification section after Test discipline", () => {
+	const testDisciplineIndex = worker.indexOf("## Test discipline");
+	const verificationIndex = worker.indexOf("## Verification");
+	const interactionIndex = worker.indexOf("## Interaction contract");
+	assert.ok(testDisciplineIndex >= 0, "worker asset lost ## Test discipline");
+	assert.ok(verificationIndex >= 0, "worker asset is missing ## Verification");
+	assert.ok(interactionIndex >= 0, "worker asset lost ## Interaction contract");
+	assert.ok(
+		testDisciplineIndex < verificationIndex && verificationIndex < interactionIndex,
+		"## Verification must sit between ## Test discipline and ## Interaction contract",
+	);
+});
+
+test("worker asset requires foreground, one-at-a-time verification with nothing left unreported", () => {
+	for (const clause of [
+		"in the foreground",
+		"one at a time",
+		"Never launch a verification command in the background",
+		"never end the task with a listed command unreported",
+	]) {
+		assert.ok(worker.includes(clause), `worker asset is missing: ${clause}`);
+	}
+});
+
+test("worker asset reports each verification command as <exact command>: <observed result> in validation", () => {
+	assert.ok(worker.includes("`<exact command>: <observed result>`"));
+	assert.ok(worker.includes("in `validation`"));
+});
+
+// ---------------------------------------------------------------------------
+// Contract consistency (`## Known environmental failures`): defined exactly
+// once, in the worker asset, as "exact test names (or exact command lines)
+// that already fail on the base"; the writer reports those as evidence, but
+// any OTHER failing required command still forces `status: partial`. The
+// delegation asset must reference this same definition, not restate it.
+// ---------------------------------------------------------------------------
+
+test("worker asset owns the canonical Known environmental failures definition", () => {
+	assert.ok(worker.includes("## Known environmental failures"));
+	assert.match(worker, /this is the canonical definition; other assets reference it, they do not restate it/i);
+	assert.match(worker, /lists exact test names or exact command lines that already fail on the base/i);
+	assert.match(worker, /Any OTHER required command that fails -- one not named under that heading -- still forces `status: partial`\./);
+});
+
+test("delegation asset references the worker's Known environmental failures definition instead of restating it", () => {
+	assert.match(
+		delegation,
+		/`## Known environmental failures` follows the same definition as `gentle-ai-worker`'s Verification contract: exact pre-existing base failures reported as evidence, never blockers -- any other failing required command still forces `status: partial`\./,
+	);
+	// The full canonical wording ("lists exact test names or exact command
+	// lines that already fail on the base") must not be duplicated here.
+	assert.doesNotMatch(delegation, /lists exact test names or exact command lines that already fail on the base/i);
+});
+
+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.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,
+	);
+});
+
+test("worker keeps candidate review disposition and lifecycle parent-owned", () => {
+	for (const clause of [
+		"The primary parent owns candidate review disposition and lifecycle, including preflight and any explicit candidate-level opt-out.",
+		"Never search for, request, or invoke review tools, including `gentle_review`.",
+		"Missing review tools never block this worker's implementation or verification handoff.",
+	]) {
+		assert.ok(worker.includes(clause), `worker asset is missing: ${clause}`);
+	}
+});
+
+test("worker asset keeps the existing Return contract fields", () => {
+	for (const field of [
+		"status: completed | partial | blocked | interaction_required",
+		"summary:",
+		"files_changed:",
+		"tdd_evidence:",
+		"validation:",
+		"risks:",
+		"review_focus:",
+		"skill_resolution:",
+		"interaction_required:",
+	]) {
+		assert.ok(worker.includes(field), `worker asset lost Return contract field: ${field}`);
+	}
+});