gentle-pi 2.1.2 → 2.2.0

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

@@ -0,0 +1,249 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { __testing } from "../extensions/gentle-ai.ts";
+import { NativeReviewIntegrationError, type NativeReviewCli } from "../lib/native-review-cli.ts";
+import { CandidateViewRegistry } from "../lib/review-candidate-view.ts";
+import type { ReviewCollectInputV3, ReviewStatusV3 } from "../lib/review-integration-v2.ts";
+import type { ReviewHostRelayRequest } from "../lib/review-host-relay.ts";
+
+// Third field failure on the recovered-lineage defect (2026-08-16, gentle-pi
+// main 402f9f77 + gentle-ai 2.4.0-main.20278905): STATUS recognises the
+// lineage, the Pi RELAY never runs, no lens is launched, zero mutations.
+//
+// Measured against the live binary on a faithful reproduction (linked
+// worktree, uncommitted tracked files, externally recovered successor):
+//
+//   agent-less STATUS  -> collect input arguments:
+//       lineage, expected-revision, target, repository-context, lens, order,
+//       subject-hash                      (no agent, no materialize, no submission)
+//   `--agent pi` STATUS -> the same input PLUS agent=pi, materialize=true and
+//       the provider submission (operation_token=capture-result)
+//
+// The adapter's negotiated targetStatus never sent `--agent pi`, so the
+// provider never offered the materialize-marked relay slot,
+// reviewHostRelaySlots() returned 0 for every real lineage, and the host relay
+// was unreachable. The prior fixes all exercised dispatch-shaped slots.
+//
+// Binaries older than v2.4.0 do not define `--agent` on `review status` and
+// refuse it outright, so the agent is probed rather than version-sniffed and
+// the typed refusal must reach the user instead of being swallowed.
+
+const SHA = `sha256:${"1".repeat(64)}`;
+const TRANSPORT_REFUSAL_CODE = "immutable_review_transport_unsupported";
+
+function repository(t: test.TestContext): string {
+	const cwd = mkdtempSync(join(tmpdir(), "gentle-pi-relay-transport-"));
+	t.after(() => rmSync(cwd, { recursive: true, force: true }));
+	execFileSync("git", ["init", "-b", "main"], { cwd });
+	writeFileSync(join(cwd, "app.ts"), "export const value = 1;\n");
+	execFileSync("git", ["add", "."], { cwd });
+	execFileSync("git", ["-c", "user.name=Relay", "-c", "user.email=relay@example.invalid", "commit", "-m", "base"], { cwd });
+	return cwd;
+}
+
+function collectInput(lineageId: string, materialize: boolean): ReviewCollectInputV3 {
+	const binding = [
+		{ name: "lineage", value: lineageId, token: `--lineage=${lineageId}` },
+		{ name: "expected-revision", value: SHA, token: `--expected-revision=${SHA}` },
+		{ name: "target", value: SHA, token: `--target=${SHA}` },
+		{ name: "repository-context", value: `rctx1_${"e".repeat(64)}`, token: `--repository-context=rctx1_${"e".repeat(64)}` },
+		{ name: "lens", value: "review-reliability", token: "--lens=review-reliability" },
+		{ name: "order", value: "0", token: "--order=0" },
+		{ name: "subject-hash", value: SHA, token: `--subject-hash=${SHA}` },
+	];
+	return {
+		name: "reviewer_result",
+		schema: "https://gentle-ai.dev/schema/review/reviewer/v1",
+		captureOperation: "review.capture-result",
+		arguments: materialize
+			? [...binding, { name: "agent", value: "pi", token: "--agent=pi" }, { name: "materialize", value: "true", token: "--materialize=true" }]
+			: binding,
+		artifactSubject: {
+			schema: "gentle-ai.review-artifact-subject/v2",
+			subjectHash: SHA,
+			lineageId,
+			authorityRevision: SHA,
+			targetIdentity: SHA,
+			baseTree: "3".repeat(40),
+			candidateTree: "4".repeat(40),
+			changedPathManifestSha256: SHA,
+			lens: "review-reliability",
+			selectedOrder: 0,
+		},
+		...(materialize
+			? {
+				submission: {
+					operationToken: "capture-result",
+					argumentTokens: [...binding.map((argument) => argument.token), "--input={{value}}"],
+					values: [{ slot: "reviewer_result", domain: "artifact_path_or_stdin", substitutionLocation: binding.length }],
+				},
+			}
+			: {}),
+	} as unknown as ReviewCollectInputV3;
+}
+
+function recoveredStatus(lineageId: string, materialize: boolean): ReviewStatusV3 {
+	return {
+		contract: "gentle-ai.review-integration/v2",
+		applicability: "current_target",
+		authority: { version: "compact-v2", lineageId, state: "reviewer_results_required", generation: 2, revision: SHA },
+		receipt: { status: "expected_missing" },
+		action: "finalize",
+		replayability: "not_replayable",
+		targetIdentity: SHA,
+		projection: {
+			schema: "gentle-ai.review-integration.projection/v1",
+			kind: "current-changes",
+			projection: "workspace",
+			baseTree: "3".repeat(40),
+			initialReviewTree: "4".repeat(40),
+			currentCandidateTree: "4".repeat(40),
+			pathsDigest: SHA,
+			paths: ["app.ts"],
+			intendedUntracked: [],
+			intendedUntrackedProof: SHA,
+			initialSnapshotIdentity: SHA,
+			currentSnapshotIdentity: SHA,
+		},
+		candidates: [],
+		nextTransition: { kind: "collect", reasonCode: "reviewer_results_required", collect: { inputs: [collectInput(lineageId, materialize)] } },
+		raw: { schema: "gentle-ai.review-integration.status/v5", action: "finalize", lineage_id: lineageId },
+	} as unknown as ReviewStatusV3;
+}
+
+/**
+ * Mirrors the MEASURED live provider: the materialize-marked relay slot is
+ * offered only when the caller asks for the pi agent.
+ */
+function transportAwareNative(options: { refusePiAgent?: boolean } = {}): { native: NativeReviewCli; agents: Array<string | undefined> } {
+	const agents: Array<string | undefined> = [];
+	const native = {
+		targetStatus: async (request: { lineageId?: string; agent?: string }) => {
+			agents.push(request.agent);
+			if (request.agent === "pi" && options.refusePiAgent === true) {
+				throw new NativeReviewIntegrationError({
+					schema: "gentle-ai.review-integration.failure/v2",
+					contract: "gentle-ai.review-integration/v2",
+					operation: "review.status",
+					phase: "pre_native",
+					code: TRANSPORT_REFUSAL_CODE,
+					message: "supported immutable review runtimes: claude-code, opencode, codex",
+					mutationOutcome: "none",
+					authorityApplicability: "current_target",
+					retrySafe: true,
+					replayability: "not_replayable",
+					nextAction: "stop",
+					raw: {},
+				} as never);
+			}
+			return recoveredStatus(request.lineageId ?? "relay-lineage", request.agent === "pi");
+		},
+		finalize: async () => { throw new Error("native finalize must not run while reviewer results are outstanding"); },
+	} as unknown as NativeReviewCli;
+	return { native, agents };
+}
+
+async function runFinalize(cwd: string, native: NativeReviewCli, lineageId: string, input: Record<string, unknown> = { reviewer_run_acknowledged: true }): Promise<Record<string, unknown>> {
+	return await __testing.executeReviewControllerOperation(
+		{ operation: "finalize", lineageId, input: JSON.stringify(input) },
+		cwd, new Map(), native, undefined, undefined, undefined, new CandidateViewRegistry(),
+	) as Record<string, unknown>;
+}
+
+test("the negotiated status asks for the pi agent so the provider offers its materialize relay slot", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = repository(t);
+	const lineageId = "relay-recovered-successor";
+	const { native, agents } = transportAwareNative();
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request: ReviewHostRelayRequest) => {
+		relayed.push(request);
+		return { promptByteLength: 128, resultByteLength: 64, submission: '{"admission_decision":"completed"}' };
+	});
+
+	const result = await runFinalize(cwd, native, lineageId);
+
+	assert.ok(agents.includes("pi"), "the controller must negotiate STATUS for the pi reviewer transport");
+	assert.equal(relayed.length, 1, "the materialize-marked slot must reach the host relay");
+	assert.ok(relayed[0]!.captureArgumentTokens.includes("--materialize=true"));
+	assert.ok(relayed[0]!.submission !== undefined, "the provider submission drives the completing form");
+	const hostRelay = result.host_relay as { transport: string; captured_slots: readonly unknown[] } | undefined;
+	assert.ok(hostRelay !== undefined, "the envelope reports the relay capture");
+	assert.equal(hostRelay.transport, "pi_host_relay");
+	assert.equal(hostRelay.captured_slots.length, 1);
+});
+
+test("finalize forecasts the reviewer model run once and spends nothing until it is acknowledged", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = repository(t);
+	const lineageId = "forecast-lineage";
+	const { native } = transportAwareNative();
+	let launches = 0;
+	__testing.setReviewHostRelayRunnerForTesting(async () => {
+		launches += 1;
+		return { promptByteLength: 128, resultByteLength: 64, submission: '{"admission_decision":"completed"}' };
+	});
+
+	// An unacknowledged finalize must forecast, never spend.
+	const forecast = await runFinalize(cwd, native, lineageId, {});
+	assert.equal(launches, 0, "no reviewer model run may start before the forecast is acknowledged");
+	assert.equal(forecast.status, "blocked");
+	assert.equal(forecast.outcome, "reviewer-model-run-forecast");
+	assert.equal(forecast.mutation_performed, false);
+	assert.equal(forecast.mutation_outcome, "none");
+	const cost = forecast.cost_forecast as { transport: string; model_runs: number; lenses: readonly string[]; side_effects: readonly string[] };
+	assert.equal(cost.transport, "pi_host_relay");
+	assert.equal(cost.model_runs, 1, "one model run per outstanding lens, forecast once before launch");
+	assert.deepEqual(cost.lenses, ["review-reliability"]);
+	assert.ok(cost.side_effects.length > 0);
+	assert.match(String(forecast.reason), /model run/i);
+	assert.match(String(forecast.next_action), /reviewer_run_acknowledged/);
+
+	// The acknowledged finalize runs exactly the forecast work.
+	const acknowledged = await runFinalize(cwd, native, lineageId, { reviewer_run_acknowledged: true });
+	assert.equal(launches, 1, "the acknowledged finalize runs the forecast model run");
+	assert.equal((acknowledged.host_relay as { captured_slots: readonly unknown[] }).captured_slots.length, 1);
+});
+
+test("a provider that refuses the pi transport surfaces the typed cause and still returns status", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = repository(t);
+	const lineageId = "legacy-transport-lineage";
+	const { native, agents } = transportAwareNative({ refusePiAgent: true });
+	let relayCalls = 0;
+	__testing.setReviewHostRelayRunnerForTesting(async () => {
+		relayCalls += 1;
+		return { promptByteLength: 1, resultByteLength: 1, submission: "{}" };
+	});
+
+	const result = await runFinalize(cwd, native, lineageId);
+
+	assert.ok(agents.includes("pi"), "the transport is probed once");
+	assert.ok(agents.includes(undefined), "a refusal falls back to the agent-less status instead of failing the operation");
+	assert.equal(relayCalls, 0, "no relay slot exists on a provider without the pi transport");
+	// Deliverable: the user sees the real typed cause, never a generic
+	// candidate-view message.
+	const transport = result.relay_transport as { supported: boolean; code: string; message: string } | undefined;
+	assert.ok(transport !== undefined, "the envelope must report the transport refusal");
+	assert.equal(transport.supported, false);
+	assert.equal(transport.code, TRANSPORT_REFUSAL_CODE);
+	assert.match(transport.message, /immutable review runtimes/i);
+	assert.doesNotMatch(JSON.stringify(result), /no current controller-owned candidate view/);
+	// The lifecycle still routes: reviewer results remain outstanding.
+	assert.equal(result.outcome, "reviewer-results-required");
+});
+
+test("the pi transport is probed once per provider and the refusal is remembered", async (t) => {
+	const cwd = repository(t);
+	const { native, agents } = transportAwareNative({ refusePiAgent: true });
+	await runFinalize(cwd, native, "probe-lineage");
+	const afterFirst = agents.filter((agent) => agent === "pi").length;
+	await runFinalize(cwd, native, "probe-lineage");
+	const afterSecond = agents.filter((agent) => agent === "pi").length;
+	assert.equal(afterFirst, 1, "the first flow probes the pi transport exactly once");
+	assert.equal(afterSecond, 1, "a remembered refusal is never re-probed for the same provider");
+});

package/tests/runtime-harness.mjs

@@ -11,6 +11,7 @@ import { matchesKey } from "@earendil-works/pi-tui";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { stripAnsi } from "../lib/terminal-theme.ts";
 import { domainHashV1 } from "../lib/review-canonical.ts";
+import { resolveGentleAiBinary } from "../lib/gentle-ai-binary.ts";
 import { NativeReviewCliV216, NATIVE_REVIEW_ERROR_CODE, NativeReviewCliError } from "../lib/native-review-cli.ts";
 
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -196,6 +197,23 @@ async function run() {
 	process.env.GENTLE_PI_CONFIG_HOME = globalConfigHome;
 	process.env.GENTLE_PI_AGENT_HOME = globalAgentHome;
 	process.env.GENTLE_PI_TEST_ASSETS_DIR = ambientTestAssetsDir;
+	// The harness already sandboxes its config and agent homes; the review kill
+	// switch is the one piece of machine state it was still inheriting. Several
+	// lifecycle-gate assertions below only reach their subject while
+	// receipt-driven development is on — with it off, gateLifecycleCommand
+	// returns undefined before deriving any target, which is correct behavior
+	// but not what those assertions are about.
+	//
+	// gentle-ai v2.4.0 made the switch opt-in, so an unconfigured machine now
+	// resolves to off. Until then the harness passed or failed on whatever the
+	// operator happened to have set, which made it green locally and red on a
+	// fresh CI runner from identical bytes. It now owns a sandbox HOME and opts
+	// in explicitly, the same way a user does, so the gates are what is under
+	// test rather than the machine.
+	const reviewHome = await tempWorkspace();
+	process.env.HOME = reviewHome;
+	const reviewModeEnable = execFileSync(resolveGentleAiBinary(ROOT, process.platform), ["review", "mode", "enable", "--scope", "global", "--json"], { cwd: ROOT, encoding: "utf8", env: { ...process.env, HOME: reviewHome } });
+	assert.match(reviewModeEnable, /"effective": "on"/, "the harness sandbox HOME must have receipt-driven development explicitly enabled");
 	const globalModelsPath = join(globalConfigHome, "models.json");
 	const globalSubagentsPath = join(globalAgentHome, "subagents.json");
 	const { pi, hooks, commands, flags, tools } = createPi();
@@ -217,6 +235,7 @@ async function run() {
 		assert.ok(tools.has(toolName), `missing quiet built-in tool renderer ${toolName}`);
 	}
 	assert.ok(tools.has("gentle_review"), "missing registered bounded review controller tool");
+	assert.ok(tools.has("gentle_review_scope"), "missing registered bounded review scope tool");
 	assert.deepEqual(
 		tools.get("gentle_review").parameters.properties.operation.enum.filter((operation) => operation.includes("supersession") || operation === "supersede" || operation === "reconcile-authority"),
 		["reconcile-authority"],
@@ -536,7 +555,7 @@ async function run() {
 		const executableDigest = "dcc846103b16d365eaeeb9d7f289c23fc4f2897f23def1cb3fe7f05557b64705";
 		const capabilitiesBody = {
 			...capabilitiesFixture,
-			package: { ...capabilitiesFixture.package, version: "2.2.2" },
+			package: { ...capabilitiesFixture.package, version: "2.4.0" },
 		};
 		const statusBody = {
 			schema: "gentle-ai.review-integration.status/v3",
@@ -624,6 +643,76 @@ async function run() {
 		await rm(join(globalConfigHome, "banner.json"), { force: true });
 	}
 
+	// issue-301: cancelling the color picker must be a no-op — no write,
+	// no notify, and the previously saved color must survive byte/semantically
+	// unchanged. Covers both entry points: /gentle:banner-color picker
+	// (cancelled), and /gentle:banner -> Color row -> nested picker (cancelled).
+	// Also covers an invalid non-empty argument, which must still open the
+	// picker and treat its cancellation as a no-op.
+	const cancelPickerCwd = await tempWorkspace();
+	try {
+		const bannerConfigPath = join(globalConfigHome, "banner.json");
+		const seeded = {
+			showRose: false,
+			showTextLogo: false,
+			color: "green",
+		};
+		const seededJson = `${JSON.stringify(seeded, null, 2)}\n`;
+		await writeFile(bannerConfigPath, seededJson, "utf8");
+
+		const cancelCtx = createCtx(cancelPickerCwd, true);
+
+		// (a) /gentle:banner-color picker cancelled: seeded color unchanged, no notify.
+		cancelCtx.ui.notifications.length = 0;
+		cancelCtx.ui.selections.length = 0;
+		cancelCtx.ui.select = async (label, options) => {
+			cancelCtx.ui.selections.push({ label, options });
+			return undefined;
+		};
+		await commands.get("gentle:banner-color").handler("", cancelCtx);
+		let afterCancel = await readFile(bannerConfigPath, "utf8");
+		assert.equal(afterCancel, seededJson, "banner-color cancel must not rewrite banner.json");
+		assert.equal(cancelCtx.ui.selections.length, 1, "banner-color cancel must open the picker once");
+		assert.equal(cancelCtx.ui.notifications.length, 0, "banner-color cancel must not notify");
+
+		// (d) invalid non-empty /gentle:banner-color input still opens picker;
+		//     cancelling it is a no-op.
+		cancelCtx.ui.notifications.length = 0;
+		cancelCtx.ui.selections.length = 0;
+		await commands.get("gentle:banner-color").handler("purple", cancelCtx);
+		afterCancel = await readFile(bannerConfigPath, "utf8");
+		assert.equal(afterCancel, seededJson, "banner-color invalid+cancel must not rewrite banner.json");
+		assert.equal(cancelCtx.ui.selections.length, 1, "invalid banner-color arg must still open the picker");
+		assert.equal(cancelCtx.ui.notifications.length, 0, "banner-color invalid+cancel must not notify");
+
+		// (b) /gentle:banner selects the Color row, then the nested picker is
+		//     cancelled: seeded color unchanged, no notify. The outer select
+		//     returns the Color row; the nested select returns undefined.
+		cancelCtx.ui.notifications.length = 0;
+		cancelCtx.ui.selections.length = 0;
+		let selectCall = 0;
+		cancelCtx.ui.select = async (label, options) => {
+			cancelCtx.ui.selections.push({ label, options });
+			selectCall += 1;
+			// First call: outer "Startup banner" menu -> pick the Color row.
+			// Second call: nested color picker -> cancel (undefined).
+			return selectCall === 1 ? options[options.length - 1] : undefined;
+		};
+		await commands.get("gentle:banner").handler("", cancelCtx);
+		afterCancel = await readFile(bannerConfigPath, "utf8");
+		assert.equal(afterCancel, seededJson, "banner Color-row cancel must not rewrite banner.json");
+		assert.equal(cancelCtx.ui.selections.length, 2, "banner Color-row flow must open outer then nested picker");
+		assert.equal(cancelCtx.ui.notifications.length, 0, "banner Color-row cancel must not notify");
+
+		// Sanity: the seeded config round-trips through normalization unchanged,
+		// proving the byte equality above is semantic, not a test artifact.
+		const reparsed = JSON.parse(await readFile(bannerConfigPath, "utf8"));
+		assert.deepEqual(reparsed, seeded, "seeded non-default color must round-trip semantically");
+	} finally {
+		await rm(cancelPickerCwd, { recursive: true, force: true });
+		await rm(join(globalConfigHome, "banner.json"), { force: true });
+	}
+
 	const noUiCwd = await tempWorkspace();
 	try {
 		for (const handler of hooks.get("session_start")) {
@@ -640,22 +729,22 @@ async function run() {
 			"session_start must not install project-local SDD chains",
 		);
 		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+		// gentle-pi#311 P5: the Pi-authored adversarial role agents are retired;
+		// installation must not (re)create them.
 		const installedRefuterPath = join(globalAgentHome, "agents", "review-refuter.md");
-		assert.equal(existsSync(installedRefuterPath), true);
-		assert.deepEqual(
-			readAgentDefinition(await readFile(installedRefuterPath, "utf8")),
-			{ name: "review-refuter", tools: ["read", "grep", "find"] },
-			"isolated package installation must activate only the refuter inspection tools",
+		assert.equal(existsSync(installedRefuterPath), false, "the retired review-refuter agent must not be installed");
+		assert.equal(
+			existsSync(join(globalAgentHome, "agents", "review-validator.md")),
+			false,
+			"the retired review-validator agent must not be installed",
 		);
-		const installedRefuterSource = await readFile(installedRefuterPath, "utf8");
-		assert.match(
-			installedRefuterSource,
-			/^tools:\n {2}- "\*": false$/m,
-			"installed refuter must lead its tool map with the deny-all rule",
+		const installedExplorePath = join(globalAgentHome, "agents", "gentle-ai-explore.md");
+		assert.equal(existsSync(installedExplorePath), true);
+		assert.deepEqual(
+			readAgentDefinition(await readFile(installedExplorePath, "utf8")),
+			{ name: "gentle-ai-explore", tools: ["read", "grep", "find", "codegraph"] },
+			"isolated package installation must activate only the explorer inspection tools",
 		);
-		assert.match(installedRefuterSource, /complete inferential-severe frozen-row list once/);
-		assert.match(installedRefuterSource, /refuted \| corroborated \| inconclusive/);
-		assert.doesNotMatch(installedRefuterSource, /general, correctness, impact\/exploitability, or reproducibility/);
 		const installedRiskSource = await readFile(
 			join(globalAgentHome, "agents", "review-risk.md"),
 			"utf8",
@@ -685,6 +774,13 @@ async function run() {
 		].join("\n");
 		await writeFile(installedRefuterPath, samePathUserRefuter);
 		delete managedAssetsManifest.assets["agents/review-refuter.md"];
+		// Retirement sweep: a hash-proven package-managed copy of a retired
+		// asset is deleted on refresh; the user-authored same-path refuter
+		// above must survive because its hash proves nothing.
+		const retiredManagedValidatorPath = join(globalAgentHome, "agents", "review-validator.md");
+		const retiredManagedValidator = "stale managed validator\n";
+		await writeFile(retiredManagedValidatorPath, retiredManagedValidator);
+		managedAssetsManifest.assets["agents/review-validator.md"] = sha256(retiredManagedValidator);
 		await mkdir(join(globalAgentHome, "subagents"), { recursive: true });
 		const userRefuterOverride = join(globalAgentHome, "subagents", "review-refuter.md");
 		await writeFile(userRefuterOverride, "user refuter override must stay\n");
@@ -738,6 +834,24 @@ async function run() {
 			"user refuter override must stay\n",
 			"package refresh must not rewrite or certify an explicit user refuter",
 		);
+		assert.equal(
+			existsSync(retiredManagedValidatorPath),
+			false,
+			"session refresh must delete a hash-proven package-managed copy of a retired asset",
+		);
+		const refreshedManagedAssets = JSON.parse(
+			await readFile(managedAssetsManifestPath, "utf8"),
+		);
+		assert.equal(
+			refreshedManagedAssets.assets["agents/review-validator.md"],
+			undefined,
+			"a retired asset must lose package-managed ownership",
+		);
+		assert.equal(
+			refreshedManagedAssets.assets["agents/review-refuter.md"],
+			undefined,
+			"a user-authored same-path retired asset must stay unowned",
+		);
 	} finally {
 		await rm(noUiCwd, { recursive: true, force: true });
 	}
@@ -1007,6 +1121,82 @@ async function run() {
 		await rm(engramSddCwd, { recursive: true, force: true });
 	}
 
+	// Issue #64: selecting engram as the artifact store must not cause
+	// /sdd-init to create openspec/ or openspec/config.yaml.
+	const engramSddInitCwd = await tempWorkspace();
+	try {
+		pi.setActiveTools(["read", "bash", "edit", "write", "mem_save"]);
+		const ctx = createCtx(engramSddInitCwd, true, "engram-sdd-init-session");
+		ctx.ui.select = async (label, options) => {
+			if (label === "SDD artifact store") return "engram";
+			return options[0];
+		};
+		await commands.get("gentle:sdd-preflight").handler("", ctx);
+		await commands.get("sdd-init").handler("", ctx);
+		assert.equal(
+			existsSync(join(engramSddInitCwd, "openspec")),
+			false,
+			"/sdd-init must not create openspec/ when artifactStore is engram",
+		);
+		assert.equal(
+			existsSync(join(engramSddInitCwd, "openspec", "config.yaml")),
+			false,
+			"/sdd-init must not write openspec/config.yaml when artifactStore is engram",
+		);
+		assert.doesNotMatch(
+			ctx.ui.notifications.at(-1).message,
+			/Wrote openspec\/config\.yaml/,
+			"/sdd-init must not announce openspec/config.yaml when artifactStore is engram",
+		);
+		assert.match(
+			ctx.ui.notifications.at(-1).message,
+			/SDD initialized for engram:/,
+		);
+		assert.equal(ctx.ui.notifications.at(-1).level, "info");
+	} finally {
+		pi.setActiveTools(["read", "bash", "edit", "write"]);
+		await rm(engramSddInitCwd, { recursive: true, force: true });
+	}
+
+	// Issue #64 counterpart: the engram skip must stay narrow. Selecting both
+	// still has to create the full openspec/ scaffold and write config.yaml,
+	// so an over-broad skip is caught here instead of in the field.
+	const bothSddInitCwd = await tempWorkspace();
+	try {
+		pi.setActiveTools(["read", "bash", "edit", "write", "mem_save"]);
+		const ctx = createCtx(bothSddInitCwd, true, "both-sdd-init-session");
+		ctx.ui.select = async (label, options) => {
+			if (label === "SDD artifact store") return "both";
+			return options[0];
+		};
+		await commands.get("gentle:sdd-preflight").handler("", ctx);
+		await commands.get("sdd-init").handler("", ctx);
+		assert.equal(
+			existsSync(join(bothSddInitCwd, "openspec", "specs")),
+			true,
+			"/sdd-init must create openspec/specs when artifactStore is both",
+		);
+		assert.equal(
+			existsSync(join(bothSddInitCwd, "openspec", "changes", "archive")),
+			true,
+			"/sdd-init must create openspec/changes/archive when artifactStore is both",
+		);
+		assert.equal(
+			existsSync(join(bothSddInitCwd, "openspec", "config.yaml")),
+			true,
+			"/sdd-init must write openspec/config.yaml when artifactStore is both",
+		);
+		assert.match(
+			ctx.ui.notifications.at(-1).message,
+			/Wrote openspec\/config\.yaml/,
+			"/sdd-init must announce openspec/config.yaml when artifactStore is both",
+		);
+		assert.equal(ctx.ui.notifications.at(-1).level, "info");
+	} finally {
+		pi.setActiveTools(["read", "bash", "edit", "write"]);
+		await rm(bothSddInitCwd, { recursive: true, force: true });
+	}
+
 	const directEngramToolCwd = await tempWorkspace();
 	try {
 		pi.setActiveTools(["read", "bash", "edit", "write", "engram_mem_save"]);
@@ -1699,6 +1889,44 @@ async function run() {
 		const restoredAgent = await readFile(join(modelsCwd, ".pi", "agents", "sdd-apply.md"), "utf8");
 		assert.match(restoredAgent, /model: restore\/provider/);
 		assert.match(restoredAgent, /thinking: high/);
+
+		// issue #286: `thinking: "max"` must survive save normalization and
+		// reach both subagents.json (effort) and agent frontmatter (thinking).
+		ctx.ui.custom = () =>
+			Promise.resolve({
+				type: "save",
+				config: { "sdd-apply": { model: "openai/gpt-5", thinking: "max" } },
+			});
+		await commands.get("gentle:models").handler("", ctx);
+		const maxSavedConfig = JSON.parse(await readFile(globalModelsPath, "utf8"));
+		assert.equal(maxSavedConfig["sdd-apply"].thinking, "max");
+		const maxSubagents = JSON.parse(
+			await readFile(join(modelsCwd, ".pi", "subagents.json"), "utf8"),
+		);
+		assert.equal(maxSubagents.model_profiles["sdd-apply"].effort, "max");
+		const maxApplyAgent = await readFile(
+			join(modelsCwd, ".pi", "agents", "sdd-apply.md"),
+			"utf8",
+		);
+		assert.match(maxApplyAgent, /thinking: max/);
+
+		// issue #286: effort picker must offer `max` after `xhigh` and save it.
+		let maxPickerCalls = 0;
+		ctx.ui.custom = (factory) =>
+			new Promise((resolve) => {
+				maxPickerCalls += 1;
+				const panel = factory(null, null, null, resolve);
+				if (maxPickerCalls === 1) {
+					panel.handleInput(kittyE); // open effort picker (set-all row)
+					for (let i = 0; i < 7; i++) panel.handleInput("j"); // max
+					panel.handleInput("\r");
+					panel.handleInput("\u0013"); // ctrl+s saves the draft
+					return;
+				}
+			});
+		await commands.get("gentle:models").handler("", ctx);
+		const pickerMaxConfig = JSON.parse(await readFile(globalModelsPath, "utf8"));
+		assert.equal(pickerMaxConfig["sdd-apply"].thinking, "max");
 	} finally {
 		await rm(modelsCwd, { recursive: true, force: true });
 		await rm(globalModelsPath, { force: true });

package/tests/sdd-agent-tools.test.ts

@@ -5,7 +5,6 @@ import test from "node:test";
 
 const repoRoot = process.cwd();
 const assetsAgentsDir = join(repoRoot, "assets", "agents");
-const REVIEW_REFUTER_TOOLS = ["read", "grep", "find"];
 const GENERIC_ROLE_TOOLS: Record<string, string[]> = {
 	"gentle-ai-explore.md": ["read", "grep", "find", "codegraph"],
 	"gentle-ai-worker.md": ["read", "grep", "find", "edit", "write", "bash", "mem_save"],
@@ -61,18 +60,18 @@ function assertGenericRoleBody(fileName: string, source: string): void {
 }
 
 const requiredToolsByAgent: Record<string, string[]> = {
-	"sdd-apply.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
-	"sdd-archive.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save"],
-	"sdd-design.md": ["read", "grep", "glob", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
-	"sdd-explore.md": ["read", "grep", "glob", "edit", "write", "mem_save"],
-	"sdd-init.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
-	"sdd-onboard.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
-	"sdd-proposal.md": ["read", "grep", "glob", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
-	"sdd-spec.md": ["read", "grep", "glob", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
-	"sdd-status.md": ["read", "grep", "glob", "bash", "mem_search", "mem_get_observation"],
-	"sdd-sync.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
-	"sdd-tasks.md": ["read", "grep", "glob", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
-	"sdd-verify.md": ["read", "grep", "glob", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-apply.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
+	"sdd-archive.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-design.md": ["read", "grep", "find", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-explore.md": ["read", "grep", "find", "edit", "write", "mem_save"],
+	"sdd-init.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
+	"sdd-onboard.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
+	"sdd-proposal.md": ["read", "grep", "find", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-spec.md": ["read", "grep", "find", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-status.md": ["read", "grep", "find", "bash", "mem_search", "mem_get_observation"],
+	"sdd-sync.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save", "mem_update"],
+	"sdd-tasks.md": ["read", "grep", "find", "edit", "write", "mem_search", "mem_get_observation", "mem_save"],
+	"sdd-verify.md": ["read", "grep", "find", "edit", "write", "bash", "mem_search", "mem_get_observation", "mem_save"],
 };
 
 test("SDD package agents declare role-appropriate tools as YAML arrays", () => {
@@ -123,25 +122,11 @@ test("generic non-SDD agents declare exact role tool allowlists", () => {
 	}
 });
 
-test("review-refuter exposes only complete-list inspection tools", () => {
-	const path = join(assetsAgentsDir, "review-refuter.md");
-	assert.ok(existsSync(path), "review-refuter.md must exist");
-	const entries = readTools(path);
-	assert.equal(entries[0], '"*": false', "review-refuter must lead with the deny-all rule");
-	assert.deepEqual(entries.slice(1), REVIEW_REFUTER_TOOLS);
-
-	const frontmatter = readFrontmatter(path);
-	assert.match(frontmatter, /^name:\s*review-refuter$/m);
-	for (const forbidden of [
-		"bash",
-		"edit",
-		"write",
-		"task",
-		"subagent",
-		"subagent_run",
-		"mem_save",
-		"mem_update",
-	]) {
-		assert.doesNotMatch(frontmatter, new RegExp(`^  - ${forbidden}$`, "m"));
+test("the retired Pi adversarial role agents are not packaged", () => {
+	// gentle-pi#311 P5: the refuter and targeted validator verdicts execute
+	// through Go-owned pi processes via provider-rendered self-contained
+	// vectors; no Pi agent definition may reintroduce a Pi-authored verdict.
+	for (const retired of ["review-refuter.md", "review-validator.md"]) {
+		assert.ok(!existsSync(join(assetsAgentsDir, retired)), `${retired} must stay deleted`);
 	}
 });

package/tests/skill-collision-prefixes.test.ts

@@ -16,6 +16,7 @@ const PREFIXED_NAMES: Record<string, string> = {
 	"chained-pr": "gentle-ai-chained-pr",
 	"issue-creation": "gentle-ai-issue-creation",
 	"judgment-day": "gentle-ai-judgment-day",
+	"rdd-defect-workflow": "gentle-ai-rdd-defect-workflow",
 	"skill-creator": "gentle-ai-skill-creator",
 	"skill-improver": "gentle-ai-skill-improver",
 };