gentle-pi 2.4.0 → 2.6.0

package/tests/runtime-harness.mjs

@@ -11,8 +11,10 @@ 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 { canonicalHash } from "../lib/review-transaction.ts";
 
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const { createGentleAiExtension } = await import(pathToFileURL(join(ROOT, "extensions/gentle-ai.ts")).href);
 const EXTENSIONS = [
 	"extensions/gentle-ai.ts",
 	"extensions/quiet-tools.ts",
@@ -29,6 +31,8 @@ const EXPECTED_BANNER_COMMANDS = [
 ];
 
 const EXPECTED_COMMANDS = [
+	"gentle:install-delegation",
+	"gentle:install-review",
 	"gentle:install-sdd",
 	"gentle:sdd-preflight",
 	"gentle-sdd-status",
@@ -43,6 +47,7 @@ const EXPECTED_COMMANDS = [
 ];
 
 const FORBIDDEN_COMPAT_COMMANDS = [
+	"gentle:install-assets",
 	// The SDD entry points carry the gentle- prefix so they read identically in
 	// Claude Code and Pi. The bare names are retired without an alias.
 	"sdd-init",
@@ -308,7 +313,6 @@ async function run() {
 			},
 		};
 		const lastEventPi = createPi();
-		const { createGentleAiExtension } = await import(pathToFileURL(join(ROOT, "extensions/gentle-ai.ts")).href);
 		createGentleAiExtension({ nativeReviewCli })(lastEventPi.pi);
 		const controller = lastEventPi.tools.get("gentle_review");
 		const capture = lastEventPi.tools.get("gentle_review_capture");
@@ -489,11 +493,19 @@ async function run() {
 		assert.match(applyPromptResult.systemPrompt, /### apply instructions/);
 		const statusCtx = createCtx(promptCwd, true);
 		await commands.get("gentle-sdd-status").handler("status-demo --json", statusCtx);
-		assert.match(statusCtx.ui.notifications.at(-1).message, /"schemaName": "gentle-pi\.sdd-status"/);
+		assert.match(statusCtx.ui.notifications.at(-1).message, /"schemaName": "gentle-ai\.sdd-status"/);
 		const continueCtx = createCtx(promptCwd, true);
+		let markerConfirmations = 0;
+		continueCtx.ui.confirm = async (_title, message) => {
+			assert.ok(message.includes(join(promptCwd, "openspec/changes/status-demo/.gentle-ai-instance")));
+			assert.match(message, /no source roots and no persistent authority/);
+			markerConfirmations += 1;
+			return true;
+		};
 		await commands.get("gentle-sdd-continue").handler("status-demo", continueCtx);
-		assert.match(continueCtx.ui.notifications.at(-1).message, /Native SDD Dispatcher/);
-		assert.match(continueCtx.ui.notifications.at(-1).message, /nextPhase: sdd-apply/);
+		assert.equal(markerConfirmations, 1);
+		assert.match(continueCtx.ui.notifications.at(-1).message, /Native SDD Status Engine/);
+		assert.match(continueCtx.ui.notifications.at(-1).message, /"nextRecommended": "apply"/);
 		const { execFileSync } = await import("node:child_process");
 		execFileSync("git", ["init"], { cwd: promptCwd, stdio: "ignore" });
 		const recoveryRequiredDirectory = join(promptCwd, ".git", "gentle-ai", "reviews", "control", "recovery-required-v1");
@@ -505,7 +517,7 @@ async function run() {
 		const blockedContinueCtx = createCtx(promptCwd, true);
 		await commands.get("gentle-sdd-continue").handler("status-demo", blockedContinueCtx);
 		assert.doesNotMatch(blockedContinueCtx.ui.notifications.at(-1).message, /resolve-review:/);
-		assert.match(blockedContinueCtx.ui.notifications.at(-1).message, /nextPhase: sdd-apply/);
+		assert.match(blockedContinueCtx.ui.notifications.at(-1).message, /"nextRecommended": "apply"/);
 	} finally {
 		await rm(promptCwd, { recursive: true, force: true });
 	}
@@ -583,6 +595,124 @@ async function run() {
 			undefined,
 			"a writer may dispatch when context carries narrow task-scoped repository-relative paths",
 		);
+
+		const interactiveSddDispatch = {
+			agent: "sdd-remediate",
+			task: "Correct the bound failed verification evidence.",
+			context: "Retain the parent-supplied remediation scope.",
+			mode: "task",
+		};
+		assert.equal(
+			await toolHook({ toolName: "subagent_run", input: interactiveSddDispatch }, createCtx(toolCwd, true, "interactive-sdd-parent")),
+			undefined,
+			"an interactive parent may dispatch an SDD child only after preflight resolves",
+		);
+		assert.match(
+			interactiveSddDispatch.context,
+			/^## SDD Session Preflight\nThese SDD preferences are explicit current-session choices\./,
+			"the parent-confirmed rendered preflight must be transported through the RPC child's context",
+		);
+		const rpcChildCwd = await tempWorkspace();
+		try {
+			const rpcChild = createPi();
+			createGentleAiExtension({ processEnv: { GENTLE_PI_AGENTS_CHILD: "1" } })(rpcChild.pi);
+			const rpcChildCtx = createCtx(rpcChildCwd, false, "delegated-rpc-sdd-child");
+			rpcChildCtx.mode = "rpc";
+			const rpcChildPrompt = await rpcChild.hooks.get("before_agent_start")[0](
+				{ agentName: "sdd-remediate", systemPrompt: "You are the SDD remediate executor for Gentle AI." },
+				rpcChildCtx,
+			);
+			assert.doesNotMatch(rpcChildPrompt.systemPrompt, /## SDD Session Preflight/);
+			assert.equal(
+				existsSync(join(rpcChildCwd, ".pi", "gentle-ai", "sdd-preflight.json")),
+				false,
+				"a delegated RPC child must not silently originate or persist defaults",
+			);
+		} finally {
+			await rm(rpcChildCwd, { recursive: true, force: true });
+		}
+
+		const canonicalFrozenFindingRow = '{"id":"JD-A-001","lens":"judgment-day","location":"extensions/gentle-ai.ts:1","severity":"CRITICAL","status_at_freeze":"open","evidence_class":"deterministic","evidence_claim":"The frozen finding has concrete user impact."}';
+		const canonicalFrozenFindingRows = [JSON.parse(canonicalFrozenFindingRow)];
+		const canonicalFrozenLedgerHash = canonicalHash(canonicalFrozenFindingRows);
+		const canonicalJdFixTask = [
+			"Apply the controller-authorized fix.",
+			"",
+			"## Judgment Day activation",
+			"User explicitly requested Judgment Day.",
+			"",
+			"## Exact authorized severe IDs",
+			"- `JD-A-001`",
+			"",
+			"## Judgment Day correction batch",
+			"Round: 1 of 2.",
+			`Frozen ledger SHA-256: \`${canonicalFrozenLedgerHash}\``,
+			"",
+			"## Exact frozen finding rows",
+			canonicalFrozenFindingRow,
+			"",
+			"## Allowed edit surfaces",
+			"extensions/gentle-ai.ts",
+			"tests/runtime-harness.mjs",
+		].join("\n");
+		const orderedFrozenFindingRows = [
+			...canonicalFrozenFindingRows,
+			{ ...canonicalFrozenFindingRows[0], id: "JD-B-002", location: "tests/runtime-harness.mjs:1" },
+		];
+		const reversedFrozenFindingRows = [...orderedFrozenFindingRows].reverse();
+		const rowOrderMismatchJdFixTask = canonicalJdFixTask
+			.replace("- `JD-A-001`", "- `JD-A-001`\n- `JD-B-002`")
+			.replace(canonicalFrozenLedgerHash, canonicalHash(reversedFrozenFindingRows))
+			.replace(canonicalFrozenFindingRow, reversedFrozenFindingRows.map((row) => JSON.stringify(row)).join("\n"));
+		const incorrectFrozenLedgerHash = `${canonicalFrozenLedgerHash.slice(0, -1)}${canonicalFrozenLedgerHash.endsWith("0") ? "1" : "0"}`;
+		for (const [label, input] of [
+			["missing activation", { agent: "jd-fix-agent", task: "## Allowed edit surfaces\nextensions/gentle-ai.ts", mode: "task" }],
+			["duplicate activation", { agent: "jd-fix-agent", task: `${canonicalJdFixTask}\n\n## Judgment Day activation\nUser explicitly requested Judgment Day.`, mode: "task" }],
+			["missing severe IDs", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("## Exact authorized severe IDs\n- `JD-A-001`\n", ""), mode: "task" }],
+			["duplicate severe ID bindings", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("- `JD-A-001`", "- `JD-A-001`\n- `JD-A-001`"), mode: "task" }],
+			["duplicate severe ID sections", { agent: "jd-fix-agent", task: canonicalJdFixTask, context: "## Exact authorized severe IDs\n- `JD-B-002`", mode: "task" }],
+			["malformed activation", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("User explicitly requested Judgment Day.", "Judgment Day is explicitly activated for this dispatch."), mode: "task" }],
+			["extra activation line", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("User explicitly requested Judgment Day.", "User explicitly requested Judgment Day.\nUnexpected activation detail."), mode: "task" }],
+			["malformed severe ID", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("- `JD-A-001`", "JD-A-001"), mode: "task" }],
+			["empty severe IDs", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("- `JD-A-001`", ""), mode: "task" }],
+			["missing correction batch", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace(`## Judgment Day correction batch\nRound: 1 of 2.\nFrozen ledger SHA-256: \`${canonicalFrozenLedgerHash}\`\n`, ""), mode: "task" }],
+			["duplicate correction batch", { agent: "jd-fix-agent", task: `${canonicalJdFixTask}\n## Judgment Day correction batch\nRound: 2 of 2.\nFrozen ledger SHA-256: \`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\``, mode: "task" }],
+			["out-of-order correction batch", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace(`## Judgment Day correction batch\nRound: 1 of 2.\nFrozen ledger SHA-256: \`${canonicalFrozenLedgerHash}\`\n\n## Exact frozen finding rows\n${canonicalFrozenFindingRow}`, `## Exact frozen finding rows\n${canonicalFrozenFindingRow}\n\n## Judgment Day correction batch\nRound: 1 of 2.\nFrozen ledger SHA-256: \`${canonicalFrozenLedgerHash}\``), mode: "task" }],
+			["invalid correction round", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("Round: 1 of 2.", "Round: 3 of 2."), mode: "task" }],
+			["uppercase frozen ledger hash", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace(canonicalFrozenLedgerHash, canonicalFrozenLedgerHash.toUpperCase()), mode: "task" }],
+			["incorrect frozen ledger hash", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace(canonicalFrozenLedgerHash, incorrectFrozenLedgerHash), mode: "task" }],
+			["extra correction batch line", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("Round: 1 of 2.", "Round: 1 of 2.\nUnexpected line"), mode: "task" }],
+			["missing frozen rows", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace(`## Exact frozen finding rows\n${canonicalFrozenFindingRow}\n`, ""), mode: "task" }],
+			["malformed frozen row", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace(canonicalFrozenFindingRow, "{"), mode: "task" }],
+			["duplicate frozen row", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace(canonicalFrozenFindingRow, `${canonicalFrozenFindingRow}\n${canonicalFrozenFindingRow}`), mode: "task" }],
+			["mismatched frozen row ID", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace(canonicalFrozenFindingRow, canonicalFrozenFindingRow.replace("JD-A-001", "JD-B-002")), mode: "task" }],
+			["frozen row order mismatch", { agent: "jd-fix-agent", task: rowOrderMismatchJdFixTask, mode: "task" }],
+			["extra frozen row field", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace(canonicalFrozenFindingRow, canonicalFrozenFindingRow.replace("}", ",\"extra\":true}")), mode: "task" }],
+			["non-Judgment-Day frozen row", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("\"lens\":\"judgment-day\"", "\"lens\":\"review-risk\""), mode: "task" }],
+			["non-open frozen row", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("\"status_at_freeze\":\"open\"", "\"status_at_freeze\":\"closed\""), mode: "task" }],
+			["non-severe frozen row", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("\"severity\":\"CRITICAL\"", "\"severity\":\"WARNING\""), mode: "task" }],
+			["empty frozen evidence", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("\"evidence_claim\":\"The frozen finding has concrete user impact.\"", "\"evidence_claim\":\"\""), mode: "task" }],
+			["missing edit surface", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("## Allowed edit surfaces\nextensions/gentle-ai.ts\ntests/runtime-harness.mjs", ""), mode: "task" }],
+			["invalid edit surface", { agent: "jd-fix-agent", task: canonicalJdFixTask.replace("## Allowed edit surfaces\nextensions/gentle-ai.ts", "## Allowed edit surfaces\n."), mode: "task" }],
+			["mixed", { agent: ["jd-fix-agent", "gentle-ai-worker"], task: canonicalJdFixTask, mode: "task" }],
+			["agent array", { agent: ["jd-fix-agent"], task: canonicalJdFixTask, mode: "task" }],
+			["agents array", { agents: ["jd-fix-agent"], task: canonicalJdFixTask, mode: "task" }],
+			["duplicate agent binding", { agent: "jd-fix-agent", agents: "jd-fix-agent", task: canonicalJdFixTask, mode: "task" }],
+		]) {
+			const original = structuredClone(input);
+			const result = await toolHook({ toolName: "subagent_run", input }, createCtx(toolCwd));
+			assert.equal(result?.block, true, `${label} jd-fix-agent dispatch must be blocked`);
+			assert.match(result?.reason ?? "", /Judgment Day fix dispatch/i);
+			assert.deepEqual(input, original, `${label} jd-fix-agent rejection must not mutate input`);
+		}
+		assert.equal(
+			await toolHook(
+				{ toolName: "subagent_run", input: { agent: "jd-fix-agent", task: canonicalJdFixTask, mode: "task" } },
+				createCtx(toolCwd),
+			),
+			undefined,
+			"a canonical explicit Judgment Day fix dispatch with narrow edit surfaces may run",
+		);
 		for (const [label, input] of [
 			[
 				"valid scope followed by a repository-root scope",
@@ -883,7 +1013,10 @@ async function run() {
 	}
 
 	const noUiCwd = await tempWorkspace();
+	const startupAgentHome = join(noUiCwd, "agent-home");
+	process.env.GENTLE_PI_AGENT_HOME = startupAgentHome;
 	try {
+		const globalAgentHome = startupAgentHome;
 		for (const handler of hooks.get("session_start")) {
 			await handler({ reason: "startup" }, createCtx(noUiCwd, false));
 		}
@@ -897,7 +1030,15 @@ async function run() {
 			false,
 			"session_start must not install project-local SDD chains",
 		);
-		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "gentle-ai", "support")), false);
+		for (const diagnostic of ["gentle:status", "gentle:doctor"]) {
+			const ctx = createCtx(noUiCwd, true);
+			await commands.get(diagnostic).handler("", ctx);
+			assert.match(ctx.ui.notifications.at(-1).message, /Global SDD assets: on demand/);
+			assert.doesNotMatch(ctx.ui.notifications.at(-1).message, /install-sdd --force/);
+		}
 		// 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");
@@ -920,6 +1061,8 @@ async function run() {
 		);
 		assert.match(installedRiskSource, /exactly once against the supplied `initial_review_tree`/);
 		assert.match(installedRiskSource, /cannot authorize transitions, fixes, receipts, gates, or delivery/);
+		await commands.get("gentle:sdd-preflight").handler("", createCtx(noUiCwd, false, "startup-sdd-install"));
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
 		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
 		assert.equal(existsSync(join(globalAgentHome, "gentle-ai", "support", "sdd-status-contract.md")), true);
 		const managedAssetsManifestPath = join(globalAgentHome, "gentle-ai", "managed-assets.json");
@@ -968,10 +1111,24 @@ async function run() {
 		for (const handler of hooks.get("session_start")) {
 			await handler({ reason: "startup" }, createCtx(noUiCwd, false));
 		}
+		for (const [key, stale] of [
+			["agents/sdd-apply.md", previousManagedApply],
+			["chains/sdd-full.chain.md", previousManagedChain],
+			["gentle-ai/support/sdd-status-contract.md", previousManagedSupport],
+		]) {
+			assert.equal(await readFile(join(globalAgentHome, key), "utf8"), stale,
+				"startup must preserve existing SDD package content without explicit routing");
+		}
+		assert.equal(existsSync(retiredManagedValidatorPath), false, "review retirement still runs at startup");
+		const driftCtx = createCtx(noUiCwd, true);
+		await commands.get("gentle:status").handler("", driftCtx);
+		assert.match(driftCtx.ui.notifications.at(-1).message, /Global SDD assets stale: 3 file\(s\).*install-sdd --force/);
+		assert.doesNotMatch(driftCtx.ui.notifications.at(-1).message, /install-(delegation|review) --force/);
+		await commands.get("gentle:sdd-preflight").handler("", createCtx(noUiCwd, false, "startup-sdd-refresh"));
 		assert.notEqual(
 			await readFile(join(globalAgentHome, "agents", "sdd-apply.md"), "utf8"),
 			"stale global apply\n",
-			"session_start must refresh stale global SDD agents",
+			"SDD preflight must refresh stale global SDD agents",
 		);
 		assert.equal(
 			await readFile(installedRefuterPath, "utf8"),
@@ -981,12 +1138,12 @@ async function run() {
 		assert.notEqual(
 			await readFile(join(globalAgentHome, "chains", "sdd-full.chain.md"), "utf8"),
 			"stale global chain\n",
-			"session_start must refresh stale global SDD chains",
+			"SDD preflight must refresh stale global SDD chains",
 		);
 		assert.notEqual(
 			await readFile(join(globalAgentHome, "gentle-ai", "support", "sdd-status-contract.md"), "utf8"),
 			"stale global status contract\n",
-			"session_start must refresh stale global SDD support files",
+			"SDD preflight must refresh stale global SDD support files",
 		);
 		assert.equal(
 			await readFile(join(noUiCwd, ".pi", "agents", "sdd-apply.md"), "utf8"),
@@ -1022,11 +1179,16 @@ async function run() {
 			"a user-authored same-path retired asset must stay unowned",
 		);
 	} finally {
+		process.env.GENTLE_PI_AGENT_HOME = globalAgentHome;
 		await rm(noUiCwd, { recursive: true, force: true });
 	}
 
 	const lazySddCwd = await tempWorkspace();
+	const lazyAgentHome = join(lazySddCwd, "agent-home");
+	process.env.GENTLE_PI_AGENT_HOME = lazyAgentHome;
 	try {
+		// This scenario must not inherit SDD definitions from earlier startup tests.
+		const globalAgentHome = lazyAgentHome;
 		await writeFile(
 			globalModelsPath,
 			JSON.stringify({ "sdd-apply": { model: "openai/gpt-5", thinking: "high" } }, null, 2),
@@ -1082,6 +1244,7 @@ async function run() {
 			{ action: "continue" },
 		);
 		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), false);
 
 		assert.deepEqual(
 			await inputHook({ text: "vamos con sdd", source: "interactive" }, ctx),
@@ -1094,13 +1257,13 @@ async function run() {
 		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-sync.md")), true);
 		assert.equal(existsSync(join(globalAgentHome, "gentle-ai", "support", "sdd-status-contract.md")), true);
 		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
-		assert.equal(ctx.ui.selections.length, 0, "automatic SDD triggers must not render confirmation-only selectors");
-		assert.match(ctx.ui.notifications.at(-1).message, /Preference source: canonical default or persisted preference/);
+		assert.equal(ctx.ui.selections.length, 1, "first interactive SDD trigger confirms session suggestions");
+		assert.match(ctx.ui.notifications.at(-1).message, /Preference source: explicit session choice/);
 		assert.deepEqual(
 			await inputHook({ text: "please use sdd for this change", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
-		assert.equal(ctx.ui.selections.length, 0, "natural SDD triggers reuse preferences without prompts");
+		assert.equal(ctx.ui.selections.length, 1, "natural SDD triggers reuse confirmed session choices");
 		assert.deepEqual(
 			await inputHook({ text: "/sdd", source: "interactive" }, ctx),
 			{ action: "continue" },
@@ -1113,7 +1276,7 @@ async function run() {
 			await inputHook({ text: "/sdd:plan", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
-		assert.equal(ctx.ui.selections.length, 0, "slash SDD triggers use automatic defaults without prompts");
+		assert.equal(ctx.ui.selections.length, 1, "slash SDD triggers reuse confirmed session choices");
 
 		assert.deepEqual(
 			await inputHook({ text: "/sdd-plan this change", source: "interactive" }, ctx),
@@ -1141,14 +1304,14 @@ async function run() {
 				"global SDD model routing must be materialized in agent frontmatter, not project settings overrides",
 			);
 		}
-		assert.equal(ctx.ui.selections.length, 0, "automatic SDD routing must not render confirmation-only selectors");
-		assert.match(ctx.ui.notifications.at(-1).message, /Preference source: canonical default or persisted preference/);
+		assert.equal(ctx.ui.selections.length, 1, "automatic SDD routing reuses session confirmation");
+		assert.match(ctx.ui.notifications.at(-1).message, /Preference source: explicit session choice/);
 		await commands.get("gentle:status").handler("", ctx);
 		assert.match(ctx.ui.notifications.at(-1).message, /Global SDD assets stale: 0 file\(s\)/);
 		assert.doesNotMatch(ctx.ui.notifications.at(-1).message, /install-sdd --force/);
 
 		await inputHook({ text: "/sdd-plan another change", source: "interactive" }, ctx);
-		assert.equal(ctx.ui.selections.length, 0, "automatic preflight should remain prompt-free for the session");
+		assert.equal(ctx.ui.selections.length, 1, "resolved preflight must not prompt again in this session");
 		const promptHook = hooks.get("before_agent_start")[0];
 		const promptResult = await promptHook({ systemPrompt: "base" }, ctx);
 		assert.match(promptResult.systemPrompt, /SDD Session Preflight/);
@@ -1163,6 +1326,7 @@ async function run() {
 			"non-SDD subagents must not receive parent harness or SDD preflight prompts",
 		);
 	} finally {
+		process.env.GENTLE_PI_AGENT_HOME = globalAgentHome;
 		await rm(lazySddCwd, { recursive: true, force: true });
 		await rm(globalModelsPath, { force: true });
 	}
@@ -1177,23 +1341,63 @@ async function run() {
 			});
 			assert.equal(existsSync(join(slashSddCwd, ".pi", "agents", "sdd-apply.md")), false);
 			assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
-			assert.equal(ctx.ui.selections.length, 0, `${text} should use automatic preflight without selectors`);
+			assert.equal(ctx.ui.selections.length, 1, `${text} must confirm the fresh interactive session`);
 		} finally {
 			await rm(slashSddCwd, { recursive: true, force: true });
 		}
 	}
 
+	const commandPreflightCwd = await tempWorkspace();
+	try {
+		const command = commands.get("gentle:sdd-preflight");
+		const interactive = createCtx(commandPreflightCwd, true, "explicit-command-regression");
+		await command.handler("", interactive);
+		const first = interactive.ui.selections.length;
+		await command.handler("", interactive);
+		const reused = interactive.ui.selections.length;
+		const select = interactive.ui.select;
+		interactive.ui.select = async (label, options) => {
+			const value = await select(label, options);
+			return label === "SDD execution mode" ? "interactive" : value;
+		};
+		interactive.ui.input = async () => "650";
+		await command.handler("--edit", interactive);
+		const edited = interactive.ui.selections.length;
+		await command.handler("", interactive);
+		assert.equal(interactive.ui.selections.length, edited, "edited choices also reuse without prompting");
+		const saved = JSON.parse(await readFile(join(commandPreflightCwd, ".pi", "gentle-ai", "sdd-preflight.json"), "utf8"));
+		assert.equal(saved.executionMode, "interactive");
+		assert.equal(saved.reviewBudgetLines, 650);
+		const rpc = createCtx(commandPreflightCwd, true, "explicit-command-rpc-regression");
+		rpc.mode = "rpc";
+		let rpcInputs = 0;
+		rpc.ui.input = async (_label, placeholder) => { rpcInputs += 1; return placeholder; };
+		await command.handler("", rpc);
+		await command.handler("--edit", rpc);
+		const noUi = createCtx(commandPreflightCwd, false, "explicit-command-no-ui-regression");
+		let noUiInputs = 0;
+		noUi.ui.input = async (_label, placeholder) => { noUiInputs += 1; return placeholder; };
+		await command.handler("", noUi);
+		await command.handler("--edit", noUi);
+		assert.deepEqual({ first, reused, edited, rpc: rpc.ui.selections.length, noUi: noUi.ui.selections.length },
+			{ first: 1, reused: 1, edited: 3, rpc: 0, noUi: 0 },
+			"explicit command confirms once, reuses unless --edit, and never prompts headless callers");
+		assert.deepEqual({ rpcInputs, noUiInputs }, { rpcInputs: 0, noUiInputs: 0 });
+	} finally {
+		await rm(commandPreflightCwd, { recursive: true, force: true });
+	}
+
 	const commandSddCwd = await tempWorkspace();
 	try {
 		const ctx = createCtx(commandSddCwd, true, "command-session");
-		await commands.get("gentle:sdd-preflight").handler("", ctx);
+		await commands.get("gentle:sdd-preflight").handler("--edit", ctx);
 		assert.equal(existsSync(join(commandSddCwd, ".pi", "agents", "sdd-apply.md")), false);
 		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
 		assert.equal(ctx.ui.selections.length, 2, "explicit preflight prompts intentional choice fields");
 		assert.equal(ctx.ui.selections.some(({ label }) => label === "SDD artifact store"), false, "one-option artifact store must be elided");
 		assert.match(ctx.ui.notifications.at(-1).message, /Preference source: explicit session choice/);
-		await commands.get("gentle:sdd-preflight").handler("", ctx);
-		assert.equal(ctx.ui.selections.length, 4, "explicit preflight remains an intentional re-prompt");
+		await commands.get("gentle:sdd-preflight").handler("--edit", ctx);
+		assert.equal(ctx.ui.selections.length, 4, "--edit remains an intentional re-prompt");
 	} finally {
 		await rm(commandSddCwd, { recursive: true, force: true });
 	}
@@ -1212,7 +1416,7 @@ async function run() {
 		assert.equal(existsSync(join(sddAgentGuardCwd, ".pi", "chains", "sdd-full.chain.md")), false);
 		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
 		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
-		assert.equal(ctx.ui.selections.length, 0, "automatic SDD-agent startup must not render selectors");
+		assert.equal(ctx.ui.selections.length, 1, "fresh interactive SDD-agent startup requires confirmation");
 		assert.match(promptResult.systemPrompt, /SDD Session Preflight/);
 		assert.doesNotMatch(
 			promptResult.systemPrompt,
@@ -1233,7 +1437,7 @@ async function run() {
 			},
 			ctx,
 		);
-		assert.equal(ctx.ui.selections.length, 0, "SDD-agent startup should reuse automatic preferences");
+		assert.equal(ctx.ui.selections.length, 1, "SDD-agent startup reuses confirmed session preferences");
 		assert.doesNotMatch(
 			reusedPromptResult.systemPrompt,
 			/el Gentleman Identity and Harness/,
@@ -1243,6 +1447,21 @@ async function run() {
 		await rm(sddAgentGuardCwd, { recursive: true, force: true });
 	}
 
+	const unresolvedSddCwd = await tempWorkspace();
+	try {
+		const ctx = createCtx(unresolvedSddCwd, true, "unresolved-preflight-session");
+		ctx.ui.select = async () => undefined;
+		assert.deepEqual(await hooks.get("input")[0]({ text: "/sdd", source: "interactive" }, ctx), { action: "handled" });
+		const result = await hooks.get("before_agent_start")[0]({ agentName: "sdd-explore", systemPrompt: "SDD executor" }, ctx);
+		assert.match(result.systemPrompt, /SDD preflight unresolved/);
+		assert.match(result.systemPrompt, /STOP: Do not initialize/);
+		assert.doesNotMatch(result.systemPrompt, /## SDD Session Preflight/);
+		assert.equal(existsSync(join(unresolvedSddCwd, "openspec", "config.yaml")), false);
+		assert.equal(existsSync(join(unresolvedSddCwd, ".pi", "gentle-ai", "sdd-preflight.json")), false);
+	} finally {
+		await rm(unresolvedSddCwd, { recursive: true, force: true });
+	}
+
 	const noUiSddAgentCwd = await tempWorkspace();
 	try {
 		const ctx = createCtx(noUiSddAgentCwd, false, "no-ui-sdd-agent-session");
@@ -1280,7 +1499,7 @@ async function run() {
 	try {
 		pi.setActiveTools(["read", "bash", "edit", "write", "mem_save"]);
 		const ctx = createCtx(engramSddCwd, true, "engram-session");
-		await commands.get("gentle:sdd-preflight").handler("", ctx);
+		await commands.get("gentle:sdd-preflight").handler("--edit", ctx);
 		assert.deepEqual(ctx.ui.selections[1].options, ["openspec", "engram", "hybrid"]);
 	} finally {
 		pi.setActiveTools(["read", "bash", "edit", "write"]);
@@ -1297,7 +1516,7 @@ async function run() {
 			if (label === "SDD artifact store") return "engram";
 			return options[0];
 		};
-		await commands.get("gentle:sdd-preflight").handler("", ctx);
+		await commands.get("gentle:sdd-preflight").handler("--edit", ctx);
 		await commands.get("gentle-sdd-init").handler("", ctx);
 		assert.equal(
 			existsSync(join(engramSddInitCwd, "openspec")),
@@ -1335,7 +1554,7 @@ async function run() {
 			if (label === "SDD artifact store") return "hybrid";
 			return options[0];
 		};
-		await commands.get("gentle:sdd-preflight").handler("", ctx);
+		await commands.get("gentle:sdd-preflight").handler("--edit", ctx);
 		await commands.get("gentle-sdd-init").handler("", ctx);
 		assert.equal(
 			existsSync(join(bothSddInitCwd, "openspec", "specs")),
@@ -1374,6 +1593,149 @@ async function run() {
 		await rm(directEngramToolCwd, { recursive: true, force: true });
 	}
 
+	for (const owner of ["sdd", "delegation", "review"]) {
+		const fixture = await tempWorkspace();
+		const agentHome = join(fixture, "agent-home");
+		const representatives = {
+			sdd: "sdd-apply.md",
+			delegation: "gentle-ai-worker.md",
+			review: "review-risk.md",
+		};
+		try {
+			process.env.GENTLE_PI_AGENT_HOME = agentHome;
+			process.env.GENTLE_PI_CONFIG_HOME = join(fixture, "config");
+			await mkdir(process.env.GENTLE_PI_CONFIG_HOME);
+			await writeFile(join(process.env.GENTLE_PI_CONFIG_HOME, "models.json"),
+				JSON.stringify({ [representatives[owner].replace(/\.md$/, "")]: "test/installer-must-not-apply" }));
+			const ctx = createCtx(fixture, true);
+			const command = commands.get(`gentle:install-${owner}`);
+			assert.ok(command, `missing owner installer: ${owner}`);
+			await command.handler("", ctx);
+			for (const [candidate, name] of Object.entries(representatives)) {
+				assert.equal(existsSync(join(agentHome, "agents", name)), candidate === owner,
+					`${owner} installation must not install ${candidate} assets`);
+			}
+			assert.equal(existsSync(join(fixture, ".pi", "agents")), false);
+			assert.match(ctx.ui.notifications.at(-1).message, /assets installed: \d+ agent\(s\), \d+ chain\(s\), \d+ support file\(s\)/);
+			const selectedPath = join(agentHome, "agents", representatives[owner]);
+			const packaged = await readFile(selectedPath, "utf8");
+			assert.doesNotMatch(packaged, /test\/installer-must-not-apply/);
+			const manifestPath = join(agentHome, "gentle-ai", "managed-assets.json");
+			const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+			for (const [candidate, name] of Object.entries(representatives)) {
+				const stale = `stale managed ${candidate}\n`;
+				await writeFile(join(agentHome, "agents", name), stale);
+				manifest.assets[`agents/${name}`] = sha256(stale);
+			}
+			await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+			await command.handler("", ctx);
+			assert.equal(await readFile(selectedPath, "utf8"), `stale managed ${owner}\n`,
+				"repair without --force must preserve existing files");
+			await command.handler("--force", ctx);
+			assert.equal(await readFile(selectedPath, "utf8"), packaged);
+			const refreshed = JSON.parse(await readFile(manifestPath, "utf8"));
+			for (const [candidate, name] of Object.entries(representatives)) {
+				if (candidate === owner) continue;
+				assert.equal(await readFile(join(agentHome, "agents", name), "utf8"), `stale managed ${candidate}\n`);
+				assert.equal(refreshed.assets[`agents/${name}`], manifest.assets[`agents/${name}`]);
+			}
+			const userEdit = `${packaged}\nUser-owned instructions must survive.\n`;
+			await writeFile(selectedPath, userEdit);
+			await command.handler("--force", ctx);
+			assert.equal(await readFile(selectedPath, "utf8"), userEdit);
+			assert.equal(existsSync(join(agentHome, "subagents.json")), false,
+				"owner installers must not apply model routing");
+			await commands.get("gentle:status").handler("", ctx);
+			const label = owner === "sdd" ? "SDD" : owner;
+			assert.ok(ctx.ui.notifications.at(-1).message.includes(`Global ${label} user overrides: 1 file(s)`));
+		} finally {
+			process.env.GENTLE_PI_CONFIG_HOME = globalConfigHome;
+			process.env.GENTLE_PI_AGENT_HOME = globalAgentHome;
+			await rm(fixture, { recursive: true, force: true });
+		}
+	}
+
+	const repairFixture = await tempWorkspace();
+	try {
+		process.env.GENTLE_PI_AGENT_HOME = join(repairFixture, "agent-home");
+		const ctx = createCtx(repairFixture, true);
+		await commands.get("gentle:install-sdd").handler("", ctx);
+		for (const diagnostic of ["gentle:status", "gentle:doctor"]) {
+			await commands.get(diagnostic).handler("", ctx);
+			const message = ctx.ui.notifications.at(-1).message;
+			assert.match(message, /\/gentle:install-delegation --force/,
+				`${diagnostic} must provide a repair for missing delegation assets`);
+			assert.match(message, /\/gentle:install-review --force/,
+				`${diagnostic} must provide a repair for missing review assets`);
+			assert.doesNotMatch(message, /install-sdd --force/);
+		}
+		const manifest = JSON.parse(await readFile(join(process.env.GENTLE_PI_AGENT_HOME, "gentle-ai", "managed-assets.json"), "utf8"));
+		for (const key of Object.keys(manifest.assets)) {
+			await rm(join(process.env.GENTLE_PI_AGENT_HOME, key));
+		}
+		for (const diagnostic of ["gentle:status", "gentle:doctor"]) {
+			await commands.get(diagnostic).handler("", ctx);
+			assert.match(ctx.ui.notifications.at(-1).message, /Global SDD assets stale: [1-9]\d* file\(s\).*install-sdd --force/);
+			assert.doesNotMatch(ctx.ui.notifications.at(-1).message, /on demand/,
+				"managed installation evidence must survive missing SDD files");
+		}
+	} finally {
+		process.env.GENTLE_PI_AGENT_HOME = globalAgentHome;
+		await rm(repairFixture, { recursive: true, force: true });
+	}
+
+	for (const trigger of ["gentle:sdd-preflight", "gentle-sdd-init"]) {
+		const fixture = await tempWorkspace();
+		const agentHome = join(fixture, "agent-home");
+		try {
+			process.env.GENTLE_PI_AGENT_HOME = agentHome;
+			const command = commands.get(trigger);
+			await command.handler("", createCtx(fixture, true, `${trigger}-install`));
+			assert.equal(existsSync(join(agentHome, "agents", "gentle-ai-worker.md")), false,
+				`${trigger} must not install delegation assets`);
+			assert.equal(existsSync(join(agentHome, "agents", "review-risk.md")), false,
+				`${trigger} must not install review assets`);
+			const manifestPath = join(agentHome, "gentle-ai", "managed-assets.json");
+			const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+			const managedKeys = [
+				"agents/sdd-apply.md",
+				"chains/sdd-full.chain.md",
+				"gentle-ai/support/sdd-status-contract.md",
+			];
+			const originals = new Map();
+			for (const key of managedKeys) {
+				originals.set(key, await readFile(join(agentHome, key), "utf8"));
+			}
+			const untouchedKeys = ["agents/gentle-ai-worker.md", "agents/review-risk.md"];
+			for (const key of [...managedKeys, ...untouchedKeys]) {
+				await writeFile(join(agentHome, key), `stale ${key}\n`);
+				manifest.assets[key] = sha256(`stale ${key}\n`);
+			}
+			await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+			const userPath = join(agentHome, "agents", "sdd-spec.md");
+			const userEdit = `${await readFile(userPath, "utf8")}\nUser-owned instructions.\n`;
+			await writeFile(userPath, userEdit);
+			const projectOverride = join(fixture, ".pi", "agents", "sdd-apply.md");
+			await mkdir(dirname(projectOverride), { recursive: true });
+			await writeFile(projectOverride, "Project override must survive.\n");
+			await command.handler("", createCtx(fixture, true, `${trigger}-refresh`));
+			for (const key of managedKeys) {
+				assert.equal(await readFile(join(agentHome, key), "utf8"), originals.get(key),
+					`${trigger} must refresh managed ${key} on demand`);
+			}
+			const refreshed = JSON.parse(await readFile(manifestPath, "utf8"));
+			for (const key of untouchedKeys) {
+				assert.equal(await readFile(join(agentHome, key), "utf8"), `stale ${key}\n`);
+				assert.equal(refreshed.assets[key], manifest.assets[key]);
+			}
+			assert.equal(await readFile(userPath, "utf8"), userEdit);
+			assert.equal(await readFile(projectOverride, "utf8"), "Project override must survive.\n");
+		} finally {
+			process.env.GENTLE_PI_AGENT_HOME = globalAgentHome;
+			await rm(fixture, { recursive: true, force: true });
+		}
+	}
+
 	const installCwd = await tempWorkspace();
 	try {
 		const ctx = createCtx(installCwd, true);
@@ -1388,19 +1750,51 @@ async function run() {
 	}
 
 	const staleAssetsCwd = await tempWorkspace();
+	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
+	const previousHome = process.env.HOME;
+	const previousUserProfile = process.env.USERPROFILE;
 	try {
-		await mkdir(join(staleAssetsCwd, ".pi", "agents"), { recursive: true });
+		const diagnosticsAgentHome = join(staleAssetsCwd, "agent-home");
+		const diagnosticsHome = staleAssetsCwd;
+		process.env.GENTLE_PI_AGENT_HOME = diagnosticsAgentHome;
+		process.env.HOME = diagnosticsHome;
+		process.env.USERPROFILE = diagnosticsHome;
+		for (const [dir, name] of [
+			[join(diagnosticsAgentHome, "subagents"), "sdd-apply.md"],
+			[join(diagnosticsHome, ".agents"), "sdd-archive.md"],
+			[join(staleAssetsCwd, ".agents"), "sdd-design.md"],
+			[join(staleAssetsCwd, ".pi", "agents"), "sdd-spec.md"],
+			[join(staleAssetsCwd, ".pi", "subagents"), "sdd-sync.md"],
+		]) {
+			await mkdir(dir, { recursive: true });
+			await writeFile(
+				join(dir, name),
+				`---\nname: ${name.replace(/\.md$/, "")}\n---\nintentional SDD override\n`,
+			);
+		}
+		await mkdir(join(diagnosticsAgentHome, "subagents", "nested"), { recursive: true });
+		await mkdir(join(diagnosticsAgentHome, "agents", "nested"), { recursive: true });
+		await mkdir(join(staleAssetsCwd, ".agents", "skills", "ignored"), { recursive: true });
+		await writeFile(
+			join(diagnosticsAgentHome, "subagents", "nested", "renamed-agent.md"),
+			"---\nname: sdd-apply\n---\nintentional nested SDD override\n",
+		);
+		await writeFile(
+			join(diagnosticsAgentHome, "agents", "nested", "managed-copy.md"),
+			"---\nname: sdd-apply\n---\npackage-managed root is excluded\n",
+		);
+		await writeFile(
+			join(staleAssetsCwd, ".agents", "skills", "ignored", "SKILL.md"),
+			"---\nname: sdd-apply\n---\nskills are not agent definitions\n",
+		);
 		await mkdir(join(staleAssetsCwd, ".pi", "chains"), { recursive: true });
 		await mkdir(join(staleAssetsCwd, ".pi", "gentle-ai", "support"), { recursive: true });
-		await writeFile(join(staleAssetsCwd, ".pi", "agents", "sdd-apply.md"), "stale apply\n");
-		await writeFile(join(staleAssetsCwd, ".pi", "agents", "sdd-spec.md"), "stale spec\n");
-		await writeFile(join(staleAssetsCwd, ".pi", "agents", "sdd-custom-debug.md"), "custom debug agent\n");
 		await writeFile(join(staleAssetsCwd, ".pi", "chains", "sdd-full.chain.md"), "stale chain\n");
 		await writeFile(join(staleAssetsCwd, ".pi", "gentle-ai", "support", "sdd-status-contract.md"), "stale status contract\n");
 		const ctx = createCtx(staleAssetsCwd, true);
 		await commands.get("gentle:status").handler("", ctx);
-		assert.match(ctx.ui.notifications.at(-1).message, /Project-local SDD agent overrides: 2 file\(s\)/);
-		assert.match(ctx.ui.notifications.at(-1).message, /local SDD agents shadow package assets/);
+		assert.match(ctx.ui.notifications.at(-1).message, /Active SDD agent overrides: 6 file\(s\)/);
+		assert.match(ctx.ui.notifications.at(-1).message, /active non-builtin SDD agents shadow package assets/);
 		await commands.get("gentle:doctor").handler("", ctx);
 		assert.match(ctx.ui.notifications.at(-1).message, /el Gentleman doctor/);
 		assert.match(ctx.ui.notifications.at(-1).message, /Sensitive-path guard active/);
@@ -1412,6 +1806,12 @@ async function run() {
 		assert.match(ctx.ui.notifications.at(-1).message, /Engram memory tools not active in this session/);
 		pi.setActiveTools(["read", "bash", "edit", "write"]);
 	} finally {
+		if (previousAgentHome === undefined) delete process.env.GENTLE_PI_AGENT_HOME;
+		else process.env.GENTLE_PI_AGENT_HOME = previousAgentHome;
+		if (previousHome === undefined) delete process.env.HOME;
+		else process.env.HOME = previousHome;
+		if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = previousUserProfile;
 		await rm(staleAssetsCwd, { recursive: true, force: true });
 	}
 
@@ -1426,12 +1826,20 @@ async function run() {
 		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-sync.md")), true);
 		assert.equal(existsSync(join(globalAgentHome, "gentle-ai", "support", "sdd-status-contract.md")), true);
 		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
-		assert.equal(ctx.ui.selections.length, 0, "sdd-init uses automatic preflight defaults");
-		assert.match(ctx.ui.notifications[0].message, /SDD preflight complete/);
+		assert.equal(ctx.ui.selections.length, 1, "sdd-init confirms session preflight before project initialization");
+		assert.match(ctx.ui.notifications[1].message, /SDD preflight complete/);
 		assert.match(ctx.ui.notifications.at(-1).message, /Wrote openspec\/config\.yaml/);
-
-		await commands.get("gentle:sdd-preflight").handler("", ctx);
-		assert.equal(ctx.ui.selections.length, 2, "explicit preflight prompts after automatic sdd-init");
+		const initializedConfig = await readFile(join(sddCwd, "openspec", "config.yaml"), "utf8");
+		const explore = await hooks.get("before_agent_start")[0]({ agentName: "sdd-explore", systemPrompt: "You are the SDD explore executor for Gentle AI." }, ctx);
+		assert.match(explore.systemPrompt, /explicit current-session choices/);
+		assert.equal(ctx.ui.selections.length, 1, "confirmation -> sdd-init -> explore must reuse the resolved preflight");
+		const nextSession = createCtx(sddCwd, true, "cold-start-with-saved-preferences");
+		await hooks.get("input")[0]({ text: "/sdd", source: "interactive" }, nextSession);
+		assert.equal(nextSession.ui.selections.length, 1, "saved preferences still require confirmation in a new session");
+		assert.equal(await readFile(join(sddCwd, "openspec", "config.yaml"), "utf8"), initializedConfig, "new session confirmation must not reset project initialization");
+
+		await commands.get("gentle:sdd-preflight").handler("--edit", ctx);
+		assert.equal(ctx.ui.selections.length, 3, "--edit permits changes after confirmed sdd-init");
 	} finally {
 		await rm(sddCwd, { recursive: true, force: true });
 	}
@@ -1446,9 +1854,9 @@ async function run() {
 		await writeFile(globalModelsPath, "{ invalid json");
 		const ctx = createCtx(invalidSddInitCwd, true, "invalid-sdd-init-session");
 		await commands.get("gentle-sdd-init").handler("", ctx);
-		assert.equal(ctx.ui.notifications[0].level, "warning");
-		assert.match(ctx.ui.notifications[0].message, /Model routing skipped:/);
-		assert.match(ctx.ui.notifications[0].message, /models\.json/);
+		assert.equal(ctx.ui.notifications[1].level, "warning");
+		assert.match(ctx.ui.notifications[1].message, /Model routing skipped:/);
+		assert.match(ctx.ui.notifications[1].message, /models\.json/);
 		assert.match(ctx.ui.notifications.at(-1).message, /Wrote openspec\/config\.yaml/);
 		const preservedAgent = await readFile(
 			join(invalidSddInitCwd, ".pi", "agents", "sdd-apply.md"),