gentle-pi 2.6.4 → 3.0.0

package/tests/sdd-native-managed-uptake.test.ts

@@ -154,7 +154,7 @@ if (!childRole) test("installed AI producer → fixed Pi extensions → managed
 			},
 		}, { askUser: async () => ({ cancelled: true }) });
 		try {
-			const task = runner.run({ agent: { ...actor(phase), ...(phase === "research" ? { tools: ["read", "write", "fetch_content"] } : {}) }, prompt: "Controlled boundary probe only; no implementation or acceptance.", label: undefined, context: phase === "research" ? JSON.stringify(status) : undefined, mode: "task", cwd, parentSessionId: "uptake", model: undefined, thinking: undefined, sessionDir: join(directory, "sessions"), resumeSessionPath: undefined, env: { PATH: process.env.PATH, HOME: home, PI_CODING_AGENT_DIR: home, GENTLE_PI_AGENT_HOME: home, PI_OFFLINE: "1", UPTAKE_CHILD: "1", UPTAKE_RUN: directory, UPTAKE_SCRIPT: scriptPath, GENTLE_PI_GENTLE_AI_DEV_BINARY: binary, ...(phase === "research" ? { [RESEARCH_CHILD_TOOLS_ENV]: JSON.stringify(["read", "write", "fetch_content"]) } : {}), ...options.env }, extensionPaths: [...fixed, ...(options.absentTool ? [] : [docExtension])], researchSelection: selection, researchArtifact: options.artifact, sddRemediation: options.remediation, ...(phase === "research" ? {} : { sddChange: { phase, changeName: "uptake", workspaceRoot: cwd, ...options.selection } }) });
+			const task = runner.run({ agent: { ...actor(phase), ...(phase === "research" ? { tools: ["read", "write", "fetch_content"] } : {}) }, prompt: "Controlled boundary probe only; no implementation or acceptance.", label: undefined, context: phase === "research" ? JSON.stringify(status) : undefined, mode: "task", cwd, parentSessionId: "uptake", model: undefined, thinking: undefined, sessionDir: join(directory, "sessions"), resumeSessionPath: undefined, env: { PATH: process.env.PATH, HOME: home, PI_CODING_AGENT_DIR: home, GENTLE_PI_AGENT_HOME: home, PI_OFFLINE: "1", UPTAKE_CHILD: "1", UPTAKE_RUN: directory, UPTAKE_SCRIPT: scriptPath, GENTLE_PI_GENTLE_AI_DEV_BINARY: binary, ...(phase === "research" ? { [RESEARCH_CHILD_TOOLS_ENV]: JSON.stringify(["read", "write", "fetch_content"]) } : {}), ...options.env }, extensionPaths: [...fixed, ...(options.absentTool ? [] : [docExtension])], researchSelection: selection, sddRemediation: options.remediation, ...(phase === "research" ? {} : { sddChange: { phase, changeName: "uptake", workspaceRoot: cwd, ...options.selection } }) });
 			const result = await runner.waitFor(task.id);
 			assert.equal(launches.length, 1);
 			assert.deepEqual(launches[0].args.flatMap((arg, i, args) => arg === "--extension" ? [args[i + 1]] : []), [...fixed, ...(options.absentTool ? [] : [docExtension])]);
@@ -173,31 +173,21 @@ if (!childRole) test("installed AI producer → fixed Pi extensions → managed
 		assert.equal(ended(observed, "read").length, 1); assert.equal(ended(observed, "read")[0].isError, false);
 		assert.match(JSON.stringify(ended(observed, "read")[0].result), /Native uptake controlled fixture/);
 	});
-	const path = join(change, "research.md"), initial = '{"revision":1,"outcome":"blocked"}', next = '{"revision":2,"outcome":"partial","intent":"retain docs request"}';
-	const artifact = { store: "openspec", worktree: cwd, changeName: "uptake", retainedIntent: "retain docs request", locators: [{ artifact: "research", path, revision: 1, digest: digest(initial) }] };
-	writeFileSync(path, initial);
-	for (const absentTool of [true, false]) await t.test(`research provisioning absent=${absentTool} retains bounded denial persistence`, async () => {
-		const content = absentTool ? next : '{"revision":3,"outcome":"partial","intent":"retain docs request"}';
-		if (!absentTool) { artifact.locators[0].revision = 2; artifact.locators[0].digest = digest(next); }
-		const observed = await run(`research-${absentTool}`, "research", [[["fetch_content", {}]], [["read", { path }]], [["write", { path, content }]], [["read", { path }]], [["write", { path: join(cwd, "forbidden"), content }]]], { artifact, absentTool });
+	const path = join(change, "research.md");
+	for (const absentTool of [true, false]) await t.test(`output-only research provisioning absent=${absentTool} preserves parent ownership`, async () => {
+		const content = "# Partial research\nExternal questions remain open.\n";
+		const before = existsSync(path) ? readFileSync(path, "utf8") : undefined;
+		const observed = await run(`research-${absentTool}`, "research", [[["fetch_content", {}]], [["read", { path }]], [["write", { path, content }]]], { absentTool });
 		assert.equal(observed.result.status, "completed", JSON.stringify(observed.result));
-		assert.ok(JSON.stringify(observed.input).includes("gentle-ai.sdd-status"));
 		assert.equal(ended(observed, "fetch_content")[0].isError, absentTool);
 		assert.equal(existsSync(join(observed.directory, "fetch-calls")), !absentTool);
+		for (const tool of ["read", "write"]) assert.equal(ended(observed, tool)[0].isError, true);
+		assert.equal(existsSync(path) ? readFileSync(path, "utf8") : undefined, before);
+		// Scripted parent persistence/readback, not autonomous model proof.
+		writeFileSync(path, content);
 		assert.equal(readFileSync(path, "utf8"), content);
-		assert.equal(existsSync(join(cwd, "forbidden")), false);
-		assert.equal(ended(observed, "write")[1].isError, true);
-		assert.match(JSON.stringify(ended(observed, "read").at(-1).result), /Readback identity matched/);
 		if (!absentTool) assert.equal(json(join(observed.directory, "inventory.json")).find(tool => tool.name === "fetch_content").sourceInfo.path, docExtension);
 	});
-	for (const fault of ["stale", "worktree"]) await t.test(`research ${fault} refuses before mutation`, async () => {
-		const bytes = readFileSync(path, "utf8");
-		const scope = { ...artifact, worktree: fault === "worktree" ? root : cwd, locators: [{ ...artifact.locators[0], revision: 3, digest: fault === "stale" ? "0".repeat(64) : digest(bytes) }] };
-		const observed = await run(`research-${fault}`, "research", [[["read", { path }]], [["write", { path, content: '{"revision":4}' }]]], { artifact: scope });
-		assert.equal(ended(observed, "read")[0].isError, true);
-		assert.equal(ended(observed, "write")[0].isError, true);
-		assert.equal(readFileSync(path, "utf8"), bytes);
-	});
 
 	await t.test("wrong native worktree refuses actual child tool work", async () => {
 		const observed = await run("wrong-worktree", "apply", [[["read", { path: join(change, "proposal.md") }]]], { selection: { workspaceRoot: root } });
@@ -211,7 +201,7 @@ if (!childRole) test("installed AI producer → fixed Pi extensions → managed
 		rmSync(definition.filePath);
 		let acquires = 0;
 		try {
-			await assert.rejects(admitManagedRemediation({ agent: definition, cwd, sddChange: { phase: "remediate", changeName: "uptake", workspaceRoot: cwd, failedEvidenceRevision: `sha256:${"a".repeat(64)}` } } as unknown as TaskRequest, {}, { ...native, sddAttemptAcquire: async () => { acquires++; throw new Error("Must not acquire"); } } as unknown as import("../lib/native-review-cli.ts").NativeReviewCli, async () => {}), /unsupported/i);
+			await assert.rejects(admitManagedRemediation({ agent: definition, cwd, sddChange: { phase: "remediate", changeName: "uptake", workspaceRoot: cwd, failedEvidenceRevision: `sha256:${"a".repeat(64)}` } } as unknown as TaskRequest, {}, { ...native, sddAttemptAcquire: async () => { acquires++; throw new Error("Must not acquire"); } } as unknown as import("../lib/native-review-cli.ts").NativeReviewCli), /unsupported/i);
 			assert.equal(acquires, 0);
 		} finally { writeFileSync(definition.filePath, bytes); }
 	});

package/tests/sdd-no-attempts-contract.test.ts

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+test("ordinary SDD instructions keep native selection and TDD without attempt launch governance", () => {
+	const read = (path: string) => readFileSync(new URL(`../${path}`, import.meta.url), "utf8");
+	const workflow = read("assets/sdd-orchestrator-workflow.md");
+	const status = read("assets/support/sdd-status-contract.md");
+	for (const text of [workflow, status, read("assets/agents/sdd-remediate.md")]) {
+		assert.doesNotMatch(text, /sdd-attempt (acquire|settle)|Native Runtime Attempt Authority|compact acquire\/settle/);
+	}
+	assert.match(workflow, /Strict TDD/);
+	assert.match(status, /native.*authoritative|authoritative.*native/i);
+	assert.match(status, /edit.*grant|grant.*edit/i);
+});

package/tests/sdd-odd-integration.test.ts

@@ -0,0 +1,33 @@
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import test from "node:test";
+
+const read = (path: string) => readFileSync(new URL(`../${path}`, import.meta.url), "utf8");
+
+test("integrated organic continuity and selected SDD keep separate persistence ownership", () => {
+	const memory = read("assets/orchestrator-memory.md");
+	assert.match(memory, /one feature document, not a separate plan file or topic/);
+	assert.match(memory, /odd\/tasks\/<feature-name>\.md/);
+	assert.match(memory, /odd\/<feature-name>\/tasks/);
+	assert.match(memory, /Research is output-only/);
+	assert.match(memory, /Except for output-only `sdd-research`/);
+	assert.match(memory, /do not switch the selected store/);
+	const delegation = read("assets/orchestrator-delegation.md");
+	assert.match(delegation, /organic work, not explicitly selected SDD/);
+	assert.match(delegation, /do not create a specialized agent or invoke `sdd-research`/);
+	assert.match(read("assets/agents/sdd-research.md"), /Do not read local artifacts/);
+	assert.match(read("assets/sdd-orchestrator-workflow.md"), /Optional research takes precedence/);
+});
+
+test("integrated TDD guidance preserves native SDD completion without retired consumers", () => {
+	const wrapper = read("extensions/gentle-ai.ts"), tasks = read("assets/agents/sdd-tasks.md");
+	assert.match(wrapper, /Use configured TDD mode, source, and exact runner/);
+	assert.doesNotMatch(wrapper + tasks, /If tests exist(?:, use strict TDD| or strict TDD)/);
+	assert.match(tasks, /Only when configured strict TDD is active/);
+	assert.match(read("assets/agents/sdd-apply.md"), /native task progress and authorized scope/);
+	assert.match(read("assets/agents/sdd-verify.md"), /Archive admission follows fresh native status and real permissions/);
+	assert.match(read("assets/chains/sdd-full.chain.md"), /apply -> archive/);
+	for (const path of ["assets/agents/sdd-sync.md", "lib/openspec-guardrails.ts"]) {
+		assert.equal(existsSync(new URL(`../${path}`, import.meta.url)), false, path);
+	}
+});

package/tests/sdd-optional-research.test.ts

@@ -0,0 +1,124 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import gentleAgents from "../extensions/gentle-agents.ts";
+
+interface HookEvent {
+	systemPrompt?: string;
+	toolName?: string;
+	toolCallId?: string;
+	input?: Record<string, unknown>;
+	content?: Array<{ type: "text"; text: string }>;
+	isError?: boolean;
+}
+interface HookResult { block?: boolean; reason?: string; isError?: boolean; systemPrompt?: string }
+type Hook = (event: HookEvent, ctx: { cwd: string }) => HookResult | undefined;
+
+function child(cwd: string, artifact?: unknown, selection?: unknown) {
+	const hooks = new Map<string, Hook>();
+	let active = ["read", "grep", "find", "write", "edit", "mem_save", "mem_search", "mem_get_observation", "web_search", "subagent_parent_message"];
+	let source = "/installed/search.ts";
+	const pi = { on: (name: string, hook: Hook) => hooks.set(name, hook),
+		getActiveTools: () => active,
+		getAllTools: () => active.map(name => ({ name, sourceInfo: { source: "extension", path: source } })),
+		appendEntry: () => assert.fail("research must not create a second persistence checkpoint"),
+	};
+	gentleAgents(pi as unknown as ExtensionAPI, { GENTLE_PI_AGENTS_CHILD: "1", GENTLE_PI_RESEARCH_TOOLS: JSON.stringify(active),
+		GENTLE_PI_RESEARCH_SELECTION: JSON.stringify(selection ?? null), GENTLE_PI_RESEARCH_ARTIFACT: JSON.stringify(artifact ?? null) });
+	// No physical session file or pre-existing artifact is necessary.
+	const ctx = { cwd };
+	hooks.get("before_agent_start")!({ systemPrompt: "Research a question" }, ctx);
+	return {
+		call: (toolName: string, input: Record<string, unknown> = {}) => hooks.get("tool_call")!({ toolName, input, toolCallId: "call" }, ctx),
+		result: (toolName: string, input: Record<string, unknown>, content: string, isError = false) => {
+			const event = { toolName, input, toolCallId: "call", content: [{ type: "text" as const, text: content }], isError };
+			return { ...event, ...hooks.get("tool_result")?.(event, ctx) };
+		},
+		deactivate: (name: string) => { active = active.filter(tool => tool !== name); },
+		replaceSource: () => { source = "/different/search.ts"; },
+	};
+}
+
+function workspace(t: test.TestContext) {
+	const cwd = realpathSync(mkdtempSync(join(tmpdir(), "pi-optional-research-")));
+	t.after(() => rmSync(cwd, { recursive: true, force: true }));
+	return cwd;
+}
+
+test("optional research is output-only even with historical artifact identity", t => {
+ const cwd = workspace(t);
+ const path = join(cwd, "openspec/changes/demo/research.md"), content = '{"revision":1,"outcome":"partial"}';
+ mkdirSync(join(cwd, "openspec/changes/demo"), { recursive: true });
+ writeFileSync(path, content);
+ const h = child(cwd, { store: "openspec", worktree: cwd, changeName: "demo", retainedIntent: "Research question", locators: [{ artifact: "research", path, revision: 1, digest: createHash("sha256").update(content).digest("hex") }] });
+ for (const tool of ["read", "grep", "find", "write", "edit", "mem_save", "mem_search", "mem_get_observation", "bash"]) {
+  assert.equal(h.call(tool, { path, content: "overwrite", id: 1 })?.block, true, tool);
+ }
+ assert.equal(readFileSync(path, "utf8"), content);
+ assert.equal(h.call("subagent_parent_message", { message: "Partial findings; external sources unavailable." }), undefined);
+ assert.equal(h.result("web_search", {}, "Partial search results").isError, false);
+ assert.equal(h.result("web_search", {}, "Permission denied", true).isError, true);
+});
+
+test("optional research uses individually authorized external tools but never invents grants", t => {
+	const cwd = workspace(t);
+	const selection = { "open-web": { tools: ["web_search"], extensions: { web_search: "/installed/search.ts" } } };
+	const h = child(cwd, undefined, selection);
+	assert.equal(h.call("web_search", { query: "official reference" }), undefined);
+	assert.equal(h.call("fetch_content", { url: "https://example.com" })?.block, true);
+	assert.equal(h.call("mcp", {})?.block, true);
+	h.replaceSource();
+	assert.equal(h.call("web_search", {})?.block, true, "changed extension provenance revokes the route");
+	const inactive = child(cwd, undefined, selection); inactive.deactivate("web_search");
+	assert.equal(inactive.call("web_search", {})?.block, true);
+	assert.equal(child(cwd).call("web_search", {})?.block, true, "availability alone is not authorization");
+});
+
+if (process.env.SDD_TEST_ENGRAM) test("research parent can persist first partial artifact through actual isolated Engram", t => {
+	const cwd = workspace(t), project = "research-fixture", binary = process.env.SDD_TEST_ENGRAM!;
+	const env = { ...process.env, ENGRAM_DATA_DIR: join(cwd, "memory"), ENGRAM_PROJECT: project };
+	// Establish a known test project, not a research artifact or session checkpoint.
+	execFileSync(binary, ["save", "Fixture context", "Isolated project context", "--project", project], { cwd, env, stdio: "pipe" });
+	const invoke = (name: string, args: Record<string, unknown>) => {
+		const messages = [
+			{ jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "research-integration", version: "1" } } },
+			{ jsonrpc: "2.0", method: "notifications/initialized" },
+			{ jsonrpc: "2.0", id: 2, method: "tools/call", params: { name, arguments: args } },
+		];
+		const raw = execFileSync(binary, ["mcp", "--project", project], { cwd, env, encoding: "utf8", input: messages.map(value => JSON.stringify(value)).join("\n") + "\n", timeout: 15_000 });
+		const response = raw.trim().split("\n").map(line => JSON.parse(line)).find(value => value.id === 2);
+		assert.ok(response?.result && !response.error);
+		assert.notEqual(response.result.isError, true);
+		return response.result.content.map((part: { text: string }) => part.text).join("");
+	};
+	const engram = { project, topic_key: "sdd/demo/research" };
+	// The parent owns persistence; research child hooks never perform or approve it.
+	const input = { ...engram, title: "Partial documentation research", content: "External sources unavailable; product question remains unanswered.", capture_prompt: false };
+	const saved = invoke("mem_save", input);
+	const id = JSON.parse(saved).id; assert.ok(Number.isSafeInteger(id));
+	const readback = invoke("mem_get_observation", { id });
+	assert.ok(JSON.parse(readback).result.includes(input.content));
+
+});
+
+
+test("optional research handoff keeps first file persistence and readback parent-owned", t => {
+ const cwd = workspace(t), path = join(cwd, "openspec/changes/demo/research.md");
+ const findings = "# Research\nPartial findings; external sources unavailable.\n";
+ assert.equal(child(cwd).call("write", { path, content: findings })?.block, true);
+ // This models the parent using its existing file tools, not a child persistence adapter.
+ mkdirSync(join(cwd, "openspec/changes/demo"), { recursive: true });
+ writeFileSync(path, findings);
+ assert.equal(readFileSync(path, "utf8"), findings);
+ const workflow = readFileSync(new URL("../assets/sdd-orchestrator-workflow.md", import.meta.url), "utf8");
+ const gate = workflow.slice(workflow.indexOf("## Automatic Mode Gatekeeper"));
+ assert.ok(gate.indexOf("Optional research takes precedence") < gate.indexOf("**Contract conformance:**"));
+ assert.match(gate, /accept honest partial, unavailable, or inline findings without requiring an artifact or retry/);
+ assert.match(workflow, /parent owns local reads, product choices, and any authorized persistence\/readback/);
+ assert.match(workflow, /First artifacts and in-memory sessions require no prior identity or checkpoint/);
+});

package/tests/sdd-planning-routing-contract.test.ts

@@ -30,7 +30,7 @@ for (const [index, path] of paths.entries()) {
 			"stop for ambiguous change selection, unresolved session preflight, or unsafe action context",
 			"prove planned writes are within the authoritative workspace or allowed edit roots",
 			"workspace-planning without allowed edit roots remains read-only",
-			"Planning does not bypass the init guard, pre-proposal gate, or phase approval requirements",
+			"Planning does not bypass the init guard, optional research guidance, or phase approval requirements",
 			"never infer a route from prose",
 			"Keep genuine blockers in `blockedReasons` and non-blocking diagnostics in `notes`, never in `nextRecommended`",
 			"report them without discarding them to enable a route",

package/tests/sdd-preflight-rpc-input.test.ts

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
+import { isSddPreflightTrigger, sddPreflightDiskPath } from "../lib/sdd-preflight.ts";
+
+// gentle-pi#1001: the natural-language SDD `input` hook called the parent-only
+// preflight resolver for every matching prompt, RPC children included.
+// `ensureSddPreflight` rejects RPC by design, the hook caught that rejection and
+// answered `handled`, and Pi's `AgentSession.prompt()` accepts handled input and
+// returns before `before_agent_start` and the model loop. A delegated child
+// therefore ACKed a prompt it never ran: no agent_start, zero turns, zero tool
+// calls, and a stall that only surfaced as the runner's inactivity timeout.
+//
+// An RPC child consumes the parent-rendered preflight block transported in its
+// task context. It must never originate preflight, and the interceptor must
+// never consume a delegated prompt on its behalf.
+
+type InputResult = { action: "continue" | "handled" };
+type InputHandler = (event: { text?: unknown }, ctx: ExtensionContext) => Promise<InputResult>;
+
+const DELEGATED_SDD_TASK = "Implement the accepted SDD change.";
+
+function inputHook(): InputHandler {
+	const handlers = new Map<string, InputHandler>();
+	const pi = {
+		on(name: string, handler: InputHandler) {
+			handlers.set(name, handler);
+		},
+		events: { emit() {} },
+		registerCommand() {},
+		registerTool() {},
+		getActiveTools: () => [],
+	} as unknown as ExtensionAPI;
+	createGentleAiExtension({ nativeReviewCli: null })(pi);
+	const input = handlers.get("input");
+	assert.equal(typeof input, "function", "the extension must register an input hook");
+	return input as InputHandler;
+}
+
+function ctx(overrides: Record<string, unknown>): ExtensionContext {
+	return {
+		cwd: process.cwd(),
+		hasUI: true,
+		ui: { notify() {} },
+		sessionManager: { getSessionId: () => "sdd-preflight-rpc-input" },
+		...overrides,
+	} as unknown as ExtensionContext;
+}
+
+test("the delegated task text reaches the preflight interceptor", () => {
+	// Guards the premise of the tests below: if the classifier stops matching
+	// this text they would pass for the wrong reason.
+	assert.equal(isSddPreflightTrigger(DELEGATED_SDD_TASK), true);
+});
+
+test("an RPC child's matching prompt is not consumed by the preflight interceptor", async () => {
+	const input = inputHook();
+	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-rpc-input-"));
+	const notifications: string[] = [];
+	try {
+		const result = await input(
+			{ text: DELEGATED_SDD_TASK },
+			ctx({
+				cwd,
+				mode: "rpc",
+				sessionManager: { getSessionId: () => "sdd-preflight-rpc-child" },
+				ui: { notify: (message: string) => notifications.push(message) },
+			}),
+		);
+		assert.deepEqual(result, { action: "continue" }, "a delegated prompt must reach the agent");
+		assert.deepEqual(notifications, [], "an RPC child must not originate preflight at all");
+		assert.equal(existsSync(sddPreflightDiskPath(cwd)), false, "an RPC child must not persist defaults");
+	} finally {
+		await rm(cwd, { recursive: true, force: true });
+	}
+});
+
+test("an RPC child's ordinary prompt still continues", async () => {
+	const input = inputHook();
+	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-rpc-input-control-"));
+	try {
+		const result = await input(
+			{ text: "Implement a small Rust selection type." },
+			ctx({ cwd, mode: "rpc", sessionManager: { getSessionId: () => "sdd-preflight-rpc-control" } }),
+		);
+		assert.deepEqual(result, { action: "continue" });
+		assert.equal(existsSync(sddPreflightDiskPath(cwd)), false);
+	} finally {
+		await rm(cwd, { recursive: true, force: true });
+	}
+});
+
+test("an interactive parent still resolves preflight for a matching prompt", async () => {
+	const input = inputHook();
+	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-parent-input-"));
+	const agentHome = await mkdtemp(join(tmpdir(), "gentle-pi-parent-agent-home-"));
+	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
+	process.env.GENTLE_PI_AGENT_HOME = agentHome;
+	try {
+		const result = await input(
+			{ text: DELEGATED_SDD_TASK },
+			ctx({
+				cwd,
+				hasUI: false,
+				sessionManager: { getSessionId: () => "sdd-preflight-interactive-parent" },
+			}),
+		);
+		assert.deepEqual(result, { action: "continue" });
+		assert.equal(
+			existsSync(sddPreflightDiskPath(cwd)),
+			true,
+			"the parent remains the only actor that resolves and persists preflight",
+		);
+	} finally {
+		if (previousAgentHome === undefined) delete process.env.GENTLE_PI_AGENT_HOME;
+		else process.env.GENTLE_PI_AGENT_HOME = previousAgentHome;
+		await rm(cwd, { recursive: true, force: true });
+		await rm(agentHome, { recursive: true, force: true });
+	}
+});

package/tests/sdd-preflight.test.ts

@@ -496,7 +496,7 @@ test("a persisted canonical 'hybrid' artifact store loads unchanged", async () =
 test("the shared shipped SDD inventory includes every executor, including remediation", () => {
 	assert.deepEqual(SHIPPED_SDD_AGENT_NAMES, [
 		"sdd-init", "sdd-onboard", "sdd-explore", "sdd-research", "sdd-proposal", "sdd-spec", "sdd-design",
-		"sdd-tasks", "sdd-status", "sdd-apply", "sdd-verify", "sdd-sync", "sdd-archive", "sdd-remediate",
+		"sdd-tasks", "sdd-status", "sdd-apply", "sdd-verify", "sdd-archive", "sdd-remediate",
 	]);
 });