@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/unit/subagent-prompt-runtime.test.ts

@@ -2,34 +2,18 @@ import assert from "node:assert/strict";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { afterEach, describe, it } from "node:test";
-import { consumeSteerAcks, writeSteerRequestToDir } from "../../src/runs/background/control-channel.ts";
-import {
-	SUBAGENT_CHILD_AGENT_ENV,
-	SUBAGENT_CHILD_INDEX_ENV,
-	SUBAGENT_FANOUT_CHILD_ENV,
-	SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV,
-	SUBAGENT_ORCHESTRATOR_TARGET_ENV,
-	SUBAGENT_RUN_ID_ENV,
-	SUBAGENT_STEER_ACK_DIR_ENV,
-	SUBAGENT_STEER_CAPABILITY_ENV,
-	SUBAGENT_STEER_INBOX_ENV,
-	SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV,
-} from "../../src/runs/shared/pi-args.ts";
-import { RUNTIME_EXTENSION_ACK_EVENT, RUNTIME_EXTENSION_ACK_PATH_ENV } from "../../src/runs/shared/runtime-acknowledged-extensions.ts";
-import { clearStructuredOutputCaptures, STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV, STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED_ENV, STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV } from "../../src/runs/shared/structured-output.ts";
-import { TOOL_BUDGET_ENV } from "../../src/runs/shared/tool-budget.ts";
+import { describe, it } from "node:test";
+import { RUNTIME_EXTENSION_ACK_EVENT } from "../../src/runs/shared/runtime-acknowledged-extensions.ts";
+import { clearStructuredOutputCaptures } from "../../src/runs/shared/structured-output.ts";
 import { getAgentDir } from "../../src/shared/utils.ts";
-import { PERMISSION_POLICY_ENV } from "../../src/runs/shared/permissions.ts";
-import { CHILD_TOOL_DIAGNOSTIC_PATH_ENV, formatChildToolDiagnostic, MCP_DIRECT_CHILD_TOOLS_ENV, readChildToolDiagnostic, REQUIRED_CHILD_TOOLS_ENV } from "../../src/runs/shared/tool-availability.ts";
-import { CHILD_WATCHDOG_CONFIG_ENV } from "../../src/watchdog/child-status.ts";
+import { formatChildToolDiagnostic, type ChildToolDiagnostic } from "../../src/runs/shared/tool-availability.ts";
+import type { ChildRuntimeConfig } from "../../src/runs/shared/child-runtime-config.ts";
+import type { ChildWatchdogConfig } from "../../src/watchdog/child-status.ts";
 import { SUBAGENT_WATCHDOG_WARNING_TYPE } from "../../src/watchdog/types.ts";
 import registerSubagentPromptRuntime, {
 	CHILD_FANOUT_BOUNDARY_INSTRUCTIONS,
 	CHILD_SUBAGENT_BOUNDARY_INSTRUCTIONS,
-	SUBAGENT_INTERCOM_SESSION_NAME_ENV,
 	registerPermissionGate,
-	registerSteeringInbox,
 	rewriteSubagentPrompt,
 	stripGlobalContext,
 	stripInheritedSkills,
@@ -38,34 +22,34 @@ import registerSubagentPromptRuntime, {
 	stripSubagentOrchestrationSkill,
 } from "../../src/runs/shared/subagent-prompt-runtime.ts";
 
-const envSnapshot = {
-	SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT: process.env.SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT,
-	SELESAI_SUBAGENT_INHERIT_GLOBAL_CONTEXT: process.env.SELESAI_SUBAGENT_INHERIT_GLOBAL_CONTEXT,
-	SELESAI_SUBAGENT_INHERIT_SKILLS: process.env.SELESAI_SUBAGENT_INHERIT_SKILLS,
-	SELESAI_SUBAGENT_INTERCOM_SESSION_NAME: process.env.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME,
-	SELESAI_SUBAGENT_FANOUT_CHILD: process.env.SELESAI_SUBAGENT_FANOUT_CHILD,
-	SELESAI_SUBAGENT_STEER_INBOX: process.env.SELESAI_SUBAGENT_STEER_INBOX,
-	SELESAI_SUBAGENT_STEER_CAPABILITY: process.env.SELESAI_SUBAGENT_STEER_CAPABILITY,
-	SELESAI_SUBAGENT_STEER_ACK_DIR: process.env.SELESAI_SUBAGENT_STEER_ACK_DIR,
-	SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE: process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE,
-	SELESAI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA: process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA,
-	SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE: process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE,
-	SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED: process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED,
-	SELESAI_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS: process.env.SELESAI_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS,
-	SELESAI_SUBAGENT_TOOL_BUDGET: process.env.SELESAI_SUBAGENT_TOOL_BUDGET,
-	SELESAI_SUBAGENT_PERMISSION_POLICY: process.env.SELESAI_SUBAGENT_PERMISSION_POLICY,
-	SELESAI_SUBAGENT_REQUIRED_TOOLS: process.env.SELESAI_SUBAGENT_REQUIRED_TOOLS,
-	SELESAI_SUBAGENT_MCP_DIRECT_TOOLS: process.env.SELESAI_SUBAGENT_MCP_DIRECT_TOOLS,
-	SELESAI_SUBAGENT_TOOL_DIAGNOSTIC_PATH: process.env.SELESAI_SUBAGENT_TOOL_DIAGNOSTIC_PATH,
-	SELESAI_SUBAGENT_ORCHESTRATOR_TARGET: process.env.SELESAI_SUBAGENT_ORCHESTRATOR_TARGET,
-	SELESAI_SUBAGENT_ORCHESTRATOR_SESSION_ID: process.env.SELESAI_SUBAGENT_ORCHESTRATOR_SESSION_ID,
-	SELESAI_SUBAGENT_SUPERVISOR_CHANNEL_DIR: process.env.SELESAI_SUBAGENT_SUPERVISOR_CHANNEL_DIR,
-	SELESAI_SUBAGENT_RUN_ID: process.env.SELESAI_SUBAGENT_RUN_ID,
-	SELESAI_SUBAGENT_CHILD_AGENT: process.env.SELESAI_SUBAGENT_CHILD_AGENT,
-	SELESAI_SUBAGENT_CHILD_INDEX: process.env.SELESAI_SUBAGENT_CHILD_INDEX,
-	SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG: process.env.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG,
-
-};
+function childConfig(overrides: Partial<ChildRuntimeConfig> = {}): ChildRuntimeConfig {
+	return { fanoutChild: false, depth: 1, waitTool: { enabled: true }, fast: false, ...overrides };
+}
+
+function supervisorConfig(overrides: Partial<ChildRuntimeConfig> = {}): ChildRuntimeConfig {
+	return childConfig({
+		orchestratorTarget: "subagent-chat-parent",
+		orchestratorSessionId: "session-parent",
+		supervisorChannelDir: path.join(os.tmpdir(), "subagent-supervisor-runtime-test"),
+		runId: "run-123",
+		agent: "worker",
+		childIndex: 0,
+		...overrides,
+	});
+}
+
+const watchdogConfig: ChildWatchdogConfig = {
+	enabled: true,
+	runId: "run-1",
+	agent: "worker",
+	childIndex: 0,
+	watchdogTailTimeoutMs: 1000,
+	agentEndTimeoutMs: 500,
+	maxWarnings: null,
+	lsp: { enabled: false, timeoutMs: 3000, maxFiles: 20, maxDiagnostics: 50 },
+	stalemateRepeats: 2,
+	cadence: { everyNTools: null },
+} as ChildWatchdogConfig;
 
 const SKILLS_SECTION = "\n\nThe following skills provide specialized instructions for specific tasks.\nUse the read tool to load a skill's file when the task matches its description.\nWhen a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.\n\n<available_skills>\n  <skill>\n    <name>safe-bash</name>\n    <description>desc</description>\n    <location>/tmp/SKILL.md</location>\n  </skill>\n  <skill>\n    <name>pi-subagents</name>\n    <description>delegate to subagents</description>\n    <location>/tmp/pi-subagents/SKILL.md</location>\n  </skill>\n</available_skills>";
 
@@ -86,79 +70,18 @@ const PROMPT_WITH_EXPLICIT_SKILL = [
 
 const CONFIGURED_SKILLS_SECTION = "\n\nThe following configured skills are available to this subagent.\nUse the read tool to load a skill's file when the task matches its description.\nWhen a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.\n\n<available_skills>\n  <skill>\n    <name>configured-skill</name>\n    <description>explicit agent skill</description>\n    <location>/tmp/configured-skill/SKILL.md</location>\n  </skill>\n</available_skills>";
 
-afterEach(() => {
-	if (envSnapshot.SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT === undefined) delete process.env.SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT;
-	else process.env.SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT = envSnapshot.SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT;
-	if (envSnapshot.SELESAI_SUBAGENT_INHERIT_GLOBAL_CONTEXT === undefined) delete process.env.SELESAI_SUBAGENT_INHERIT_GLOBAL_CONTEXT;
-	else process.env.SELESAI_SUBAGENT_INHERIT_GLOBAL_CONTEXT = envSnapshot.SELESAI_SUBAGENT_INHERIT_GLOBAL_CONTEXT;
-	if (envSnapshot.SELESAI_SUBAGENT_INHERIT_SKILLS === undefined) delete process.env.SELESAI_SUBAGENT_INHERIT_SKILLS;
-	else process.env.SELESAI_SUBAGENT_INHERIT_SKILLS = envSnapshot.SELESAI_SUBAGENT_INHERIT_SKILLS;
-	if (envSnapshot.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME === undefined) delete process.env.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME;
-	else process.env.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME = envSnapshot.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME;
-	if (envSnapshot.SELESAI_SUBAGENT_FANOUT_CHILD === undefined) delete process.env.SELESAI_SUBAGENT_FANOUT_CHILD;
-	else process.env.SELESAI_SUBAGENT_FANOUT_CHILD = envSnapshot.SELESAI_SUBAGENT_FANOUT_CHILD;
-	if (envSnapshot.SELESAI_SUBAGENT_STEER_INBOX === undefined) delete process.env[SUBAGENT_STEER_INBOX_ENV];
-	else process.env[SUBAGENT_STEER_INBOX_ENV] = envSnapshot.SELESAI_SUBAGENT_STEER_INBOX;
-	if (envSnapshot.SELESAI_SUBAGENT_STEER_CAPABILITY === undefined) delete process.env[SUBAGENT_STEER_CAPABILITY_ENV];
-	else process.env[SUBAGENT_STEER_CAPABILITY_ENV] = envSnapshot.SELESAI_SUBAGENT_STEER_CAPABILITY;
-	if (envSnapshot.SELESAI_SUBAGENT_STEER_ACK_DIR === undefined) delete process.env[SUBAGENT_STEER_ACK_DIR_ENV];
-	else process.env[SUBAGENT_STEER_ACK_DIR_ENV] = envSnapshot.SELESAI_SUBAGENT_STEER_ACK_DIR;
-	if (envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE === undefined) delete process.env[STRUCTURED_OUTPUT_CAPTURE_ENV];
-	else process.env[STRUCTURED_OUTPUT_CAPTURE_ENV] = envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE;
-	if (envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA === undefined) delete process.env[STRUCTURED_OUTPUT_SCHEMA_ENV];
-	else process.env[STRUCTURED_OUTPUT_SCHEMA_ENV] = envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA;
-	if (envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE === undefined) delete process.env[STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV];
-	else process.env[STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV] = envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE;
-	if (envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED === undefined) delete process.env[STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED_ENV];
-	else process.env[STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED_ENV] = envSnapshot.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED;
-	if (envSnapshot.SELESAI_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS === undefined) delete process.env[RUNTIME_EXTENSION_ACK_PATH_ENV];
-	else process.env[RUNTIME_EXTENSION_ACK_PATH_ENV] = envSnapshot.SELESAI_SUBAGENT_RUNTIME_ACKNOWLEDGED_EXTENSIONS;
-	if (envSnapshot.SELESAI_SUBAGENT_TOOL_BUDGET === undefined) delete process.env[TOOL_BUDGET_ENV];
-	else process.env[TOOL_BUDGET_ENV] = envSnapshot.SELESAI_SUBAGENT_TOOL_BUDGET;
-	if (envSnapshot.SELESAI_SUBAGENT_PERMISSION_POLICY === undefined) delete process.env[PERMISSION_POLICY_ENV];
-	else process.env[PERMISSION_POLICY_ENV] = envSnapshot.SELESAI_SUBAGENT_PERMISSION_POLICY;
-	if (envSnapshot.SELESAI_SUBAGENT_REQUIRED_TOOLS === undefined) delete process.env[REQUIRED_CHILD_TOOLS_ENV];
-	else process.env[REQUIRED_CHILD_TOOLS_ENV] = envSnapshot.SELESAI_SUBAGENT_REQUIRED_TOOLS;
-	if (envSnapshot.SELESAI_SUBAGENT_MCP_DIRECT_TOOLS === undefined) delete process.env[MCP_DIRECT_CHILD_TOOLS_ENV];
-	else process.env[MCP_DIRECT_CHILD_TOOLS_ENV] = envSnapshot.SELESAI_SUBAGENT_MCP_DIRECT_TOOLS;
-	if (envSnapshot.SELESAI_SUBAGENT_TOOL_DIAGNOSTIC_PATH === undefined) delete process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV];
-	else process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = envSnapshot.SELESAI_SUBAGENT_TOOL_DIAGNOSTIC_PATH;
-	if (envSnapshot.SELESAI_SUBAGENT_ORCHESTRATOR_TARGET === undefined) delete process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV];
-	else process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV] = envSnapshot.SELESAI_SUBAGENT_ORCHESTRATOR_TARGET;
-	if (envSnapshot.SELESAI_SUBAGENT_ORCHESTRATOR_SESSION_ID === undefined) delete process.env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV];
-	else process.env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV] = envSnapshot.SELESAI_SUBAGENT_ORCHESTRATOR_SESSION_ID;
-	if (envSnapshot.SELESAI_SUBAGENT_SUPERVISOR_CHANNEL_DIR === undefined) delete process.env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV];
-	else process.env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV] = envSnapshot.SELESAI_SUBAGENT_SUPERVISOR_CHANNEL_DIR;
-	if (envSnapshot.SELESAI_SUBAGENT_RUN_ID === undefined) delete process.env[SUBAGENT_RUN_ID_ENV];
-	else process.env[SUBAGENT_RUN_ID_ENV] = envSnapshot.SELESAI_SUBAGENT_RUN_ID;
-	if (envSnapshot.SELESAI_SUBAGENT_CHILD_AGENT === undefined) delete process.env[SUBAGENT_CHILD_AGENT_ENV];
-	else process.env[SUBAGENT_CHILD_AGENT_ENV] = envSnapshot.SELESAI_SUBAGENT_CHILD_AGENT;
-	if (envSnapshot.SELESAI_SUBAGENT_CHILD_INDEX === undefined) delete process.env[SUBAGENT_CHILD_INDEX_ENV];
-	else process.env[SUBAGENT_CHILD_INDEX_ENV] = envSnapshot.SELESAI_SUBAGENT_CHILD_INDEX;
-	if (envSnapshot.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG === undefined) delete process.env[CHILD_WATCHDOG_CONFIG_ENV];
-	else process.env[CHILD_WATCHDOG_CONFIG_ENV] = envSnapshot.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG;
-
-});
-
-function setSupervisorEnv(): void {
-	process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV] = "subagent-chat-parent";
-	process.env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV] = "session-parent";
-	process.env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV] = path.join(os.tmpdir(), "subagent-supervisor-runtime-test");
-	process.env[SUBAGENT_RUN_ID_ENV] = "run-123";
-	process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
-	process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
-}
-
 describe("subagent prompt runtime", () => {
+	it("ignores an unconfigured path-based load", () => {
+		assert.doesNotThrow(() => registerSubagentPromptRuntime({} as never));
+	});
+
 	it("registers no permission hook by default and routes ask only to the watchdog arbiter", async () => {
 		const handlers: Array<(event: { toolName?: string; input?: unknown }, ctx?: unknown) => unknown> = [];
 		const pi = { on(event: string, handler: (event: { toolName?: string; input?: unknown }, ctx?: unknown) => unknown) { if (event === "tool_call") handlers.push(handler); } };
-		delete process.env[PERMISSION_POLICY_ENV];
-		registerPermissionGate(pi as never);
+		registerPermissionGate(pi as never, undefined, undefined);
 		assert.equal(handlers.length, 0);
 
-		process.env[PERMISSION_POLICY_ENV] = JSON.stringify({ write: "deny" });
-		registerPermissionGate(pi as never);
+		registerPermissionGate(pi as never, { rules: { write: "deny" } }, undefined);
 		assert.equal(handlers.length, 1);
 		assert.equal(await handlers[0]!({ toolName: "bash", input: { command: "rm -rf /" } }), undefined);
 		assert.equal(await handlers[0]!({ toolName: "contact_supervisor", input: {} }), undefined);
@@ -167,10 +90,9 @@ describe("subagent prompt runtime", () => {
 			reason: "Blocked by pi-subagents permission rule: 'write' is denied.",
 		});
 
-		process.env[PERMISSION_POLICY_ENV] = JSON.stringify({ write: "ask" });
 		const askHandlers: Array<(event: { toolName?: string; input?: unknown }, ctx: unknown) => unknown> = [];
 		const requests: Array<{ toolName: string; args: unknown }> = [];
-		registerPermissionGate({ on(event: string, handler: (event: { toolName?: string; input?: unknown }, ctx: unknown) => unknown) { if (event === "tool_call") askHandlers.push(handler); } } as never, async (request) => {
+		registerPermissionGate({ on(event: string, handler: (event: { toolName?: string; input?: unknown }, ctx: unknown) => unknown) { if (event === "tool_call") askHandlers.push(handler); } } as never, { rules: { write: "ask" } }, undefined, async (request) => {
 			requests.push({ toolName: request.toolName, args: request.args });
 			return { approved: true, reason: "approved by watchdog", source: "watchdog" };
 		});
@@ -179,19 +101,10 @@ describe("subagent prompt runtime", () => {
 	});
 
 	it("fails closed when an ask permission decision stalls", async () => {
-		try {
-			process.env[PERMISSION_POLICY_ENV] = JSON.stringify({ write: "ask" });
-			process.env[CHILD_WATCHDOG_CONFIG_ENV] = JSON.stringify({
-				enabled: true,
-				watchdogTailTimeoutMs: 1_000,
-				agentEndTimeoutMs: 5,
-				maxWarnings: null,
-				lsp: { enabled: false, timeoutMs: 100, maxFiles: 1, maxDiagnostics: 1 },
-				stalemateRepeats: 2,
-				cadence: { everyNTools: null },
-			});
+		{
+			const stallingWatchdog = { ...watchdogConfig, agentEndTimeoutMs: 5, lsp: { enabled: false, timeoutMs: 100, maxFiles: 1, maxDiagnostics: 1 } } as ChildWatchdogConfig;
 			const handlers: Array<(event: { toolName?: string; input?: unknown }, ctx: { signal?: AbortSignal }) => unknown> = [];
-			registerPermissionGate({ on(event: string, handler: (event: { toolName?: string; input?: unknown }, ctx: { signal?: AbortSignal }) => unknown) { if (event === "tool_call") handlers.push(handler); } } as never, async () => new Promise(() => undefined));
+			registerPermissionGate({ on(event: string, handler: (event: { toolName?: string; input?: unknown }, ctx: { signal?: AbortSignal }) => unknown) { if (event === "tool_call") handlers.push(handler); } } as never, { rules: { write: "ask" } }, stallingWatchdog, async () => new Promise(() => undefined));
 
 			const result = await Promise.race([
 				handlers[0]!({ toolName: "write", input: { path: "out.txt" } }, { signal: undefined }),
@@ -203,18 +116,11 @@ describe("subagent prompt runtime", () => {
 				block: true,
 				reason: "Blocked by pi-subagents permission rule: Watchdog permission arbiter failed closed: Watchdog permission decision timed out after 5ms.",
 			});
-		} finally {
-			if (envSnapshot.SELESAI_SUBAGENT_PERMISSION_POLICY === undefined) delete process.env[PERMISSION_POLICY_ENV];
-			else process.env[PERMISSION_POLICY_ENV] = envSnapshot.SELESAI_SUBAGENT_PERMISSION_POLICY;
-			if (envSnapshot.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG === undefined) delete process.env[CHILD_WATCHDOG_CONFIG_ENV];
-			else process.env[CHILD_WATCHDOG_CONFIG_ENV] = envSnapshot.SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG;
 		}
 	});
 	it("collects runtime extension acknowledgements until terminal serialization", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-runtime-ack-"));
-		try {
-			const outputPath = path.join(dir, "acks.json");
-			process.env[RUNTIME_EXTENSION_ACK_PATH_ENV] = outputPath;
+		{
+			const acknowledged: string[][] = [];
 			const runtimeHandlers = new Map<string, Array<(payload?: unknown) => unknown>>();
 			const extensionHandlers = new Map<string, Array<(payload?: unknown) => unknown>>();
 			const pushHandler = (target: Map<string, Array<(payload?: unknown) => unknown>>, event: string, handler: (payload?: unknown) => unknown): void => {
@@ -227,7 +133,7 @@ describe("subagent prompt runtime", () => {
 			registerSubagentPromptRuntime({
 				events: { on(event: string, handler: (payload?: unknown) => unknown) { pushHandler(extensionHandlers, event, handler); } },
 				on(event: string, handler: (payload?: unknown) => unknown) { pushHandler(runtimeHandlers, event, handler); },
-			} as never);
+			} as never, childConfig({ runtimeAcknowledgements: (ids) => acknowledged.push(ids) }));
 
 			emitAll(extensionHandlers, RUNTIME_EXTENSION_ACK_EVENT, { id: "ext.one" });
 			emitAll(extensionHandlers, RUNTIME_EXTENSION_ACK_EVENT, { id: "ext.one" });
@@ -235,21 +141,13 @@ describe("subagent prompt runtime", () => {
 			runtimeHandlers.get("agent_end")?.[0]?.({});
 			emitAll(extensionHandlers, RUNTIME_EXTENSION_ACK_EVENT, { id: "late" });
 
-			assert.deepEqual(JSON.parse(fs.readFileSync(outputPath, "utf-8")), {
-				version: 1,
-				source: "child-runtime",
-				ids: ["ext.one"],
-				omitted: 0,
-			});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
+			assert.deepEqual(acknowledged, [["ext.one", "ext.one"]]);
 		}
 	});
 
 	it("nudges after the tool budget soft limit and blocks configured tools after hard", () => {
 		const handlers = new Map<string, (payload: { toolName?: string }) => unknown>();
 		const sent: string[] = [];
-		process.env[TOOL_BUDGET_ENV] = JSON.stringify({ soft: 2, hard: 2, block: ["read"] });
 
 		registerSubagentPromptRuntime({
 			on(event: string, handler: (payload: { toolName?: string }) => unknown) {
@@ -258,7 +156,7 @@ describe("subagent prompt runtime", () => {
 			sendUserMessage(content: string) {
 				sent.push(content);
 			},
-		} as { on(event: string, handler: (payload: { toolName?: string }) => unknown): void; sendUserMessage(content: string): void });
+		} as { on(event: string, handler: (payload: { toolName?: string }) => unknown): void; sendUserMessage(content: string): void }, childConfig({ toolBudget: { soft: 2, hard: 2, block: ["read"] } }));
 
 		const toolCall = handlers.get("tool_call");
 		assert.ok(toolCall, "tool_call handler should be registered");
@@ -273,436 +171,15 @@ describe("subagent prompt runtime", () => {
 		assert.equal(toolCall({ toolName: "write" }), undefined);
 	});
 
-	it("registers the native canonical steering inbox path", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-watch-runtime-"));
-		try {
-			const inbox = path.join(dir, "steer");
-			const nativeInbox = path.join(dir, "native-steer");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			let watchedDir: fs.PathLike | undefined;
-			const intervalDelays: number[] = [];
-			const fakeWatcher = { on() { return fakeWatcher; }, close() {} } as fs.FSWatcher;
-
-			registerSteeringInbox({
-				on(event: string, handler: (payload?: unknown) => unknown) {
-					handlers.set(event, handler);
-				},
-				sendUserMessage() {},
-			} as { on(event: string, handler: (payload?: unknown) => unknown): void; sendUserMessage(): void }, {
-				platform: "linux",
-				nativeRealpath(target) {
-					assert.equal(target, inbox);
-					return nativeInbox;
-				},
-				watch: ((target: fs.PathLike) => {
-					watchedDir = target;
-					return fakeWatcher;
-				}) as typeof fs.watch,
-				timers: {
-					setInterval: ((_handler: Parameters<typeof setInterval>[0], delay?: number) => {
-						intervalDelays.push(delay ?? 0);
-						return { unref() {} };
-					}) as typeof setInterval,
-					clearInterval: (() => {}) as typeof clearInterval,
-				},
-			});
-
-			handlers.get("session_start")?.({});
-			assert.equal(watchedDir, nativeInbox);
-			assert.deepEqual(intervalDelays, [5000]);
-			handlers.get("session_shutdown")?.({});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("uses polling without native steering watchers on Darwin", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-darwin-runtime-"));
-		try {
-			const inbox = path.join(dir, "steer");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			const intervalDelays: number[] = [];
-			let watchCalls = 0;
-
-			registerSteeringInbox({
-				on(event: string, handler: (payload?: unknown) => unknown) {
-					handlers.set(event, handler);
-				},
-				sendUserMessage() {},
-			} as { on(event: string, handler: (payload?: unknown) => unknown): void; sendUserMessage(): void }, {
-				platform: "darwin",
-				watch: (() => { watchCalls += 1; throw new Error("Darwin must not use fs.watch."); }) as typeof fs.watch,
-				timers: {
-					setInterval: ((_handler: Parameters<typeof setInterval>[0], delay?: number) => {
-						intervalDelays.push(delay ?? 0);
-						return { unref() {} };
-					}) as typeof setInterval,
-					clearInterval: (() => {}) as typeof clearInterval,
-				},
-			});
-
-			handlers.get("session_start")?.({});
-			assert.equal(watchCalls, 0);
-			assert.deepEqual(intervalDelays, [250]);
-			handlers.get("session_shutdown")?.({});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("delivers steering inbox requests as mid-run user messages", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-runtime-"));
-		try {
-			const inbox = path.join(dir, "steer");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			const sent: Array<{ content: string; options: { deliverAs: string } }> = [];
-
-			registerSubagentPromptRuntime({
-				on(event: string, handler: (payload?: unknown) => unknown) {
-					handlers.set(event, handler);
-				},
-				sendUserMessage(content: string, options: { deliverAs: string }) {
-					sent.push({ content, options });
-				},
-			} as { on(event: string, handler: (payload?: unknown) => unknown): void; sendUserMessage(content: string, options: { deliverAs: string }): void });
-
-			writeSteerRequestToDir(inbox, { type: "steer", id: "steer-1", ts: 1, message: "Focus on tests." });
-			handlers.get("message_start")?.({});
-			handlers.get("session_shutdown")?.({});
-
-			assert.equal(sent.length, 1);
-			assert.equal(sent[0]?.options.deliverAs, "steer");
-			assert.match(sent[0]?.content ?? "", /Mid-run steering/);
-			assert.match(sent[0]?.content ?? "", /Focus on tests\./);
-			assert.deepEqual(fs.readdirSync(inbox).filter((entry) => entry.endsWith(".json")), []);
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("queues follow-ups and acknowledges delivery at the next turn boundary", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-follow-up-runtime-"));
-		try {
-			const inbox = path.join(dir, "inbox");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			process.env[SUBAGENT_STEER_CAPABILITY_ENV] = path.join(dir, "capability.json");
-			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
-			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			const sent: Array<{ content: string; deliverAs?: string }> = [];
-			registerSteeringInbox({
-				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
-				sendUserMessage(content: string, options?: { deliverAs?: string }) { sent.push({ content, deliverAs: options?.deliverAs }); },
-			} as never);
-			handlers.get("session_start")?.({});
-			handlers.get("agent_start")?.({});
-			handlers.get("turn_start")?.({});
-			writeSteerRequestToDir(inbox, { type: "steer", id: "follow", ts: 1, message: "Check docs.", mode: "follow_up" });
-			handlers.get("message_start")?.({});
-			assert.equal(sent[0]?.deliverAs, "followUp");
-			handlers.get("input")?.({ source: "extension", streamingBehavior: "followUp", text: sent[0]?.content });
-			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
-			handlers.get("turn_end")?.({});
-			handlers.get("turn_start")?.({});
-			const delivered = consumeSteerAcks(dir)[0];
-			assert.equal(delivered?.state, "delivered");
-			assert.equal(delivered?.deliveryStatus, "delivered");
-
-			writeSteerRequestToDir(inbox, { type: "steer", id: "auto-mid", ts: 2, message: "Mid-turn auto.", mode: "auto" });
-			handlers.get("message_start")?.({});
-			assert.equal(sent[1]?.deliverAs, "followUp");
-			handlers.get("input")?.({ source: "extension", streamingBehavior: "followUp", text: sent[1]?.content });
-			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
-			handlers.get("turn_end")?.({});
-			handlers.get("turn_start")?.({});
-			assert.equal(consumeSteerAcks(dir)[0]?.state, "delivered");
-
-			handlers.get("turn_end")?.({});
-			writeSteerRequestToDir(inbox, { type: "steer", id: "auto-idle", ts: 3, message: "Between-turn auto.", mode: "auto" });
-			handlers.get("message_start")?.({});
-			assert.equal(sent[2]?.deliverAs, "steer");
-			handlers.get("input")?.({ source: "extension", streamingBehavior: "steer", text: sent[2]?.content });
-			assert.equal(consumeSteerAcks(dir)[0]?.deliveryStatus, "delivered");
-
-			writeSteerRequestToDir(inbox, { type: "steer", id: "undelivered", ts: 4, message: "Never reached.", mode: "follow_up" });
-			handlers.get("message_start")?.({});
-			handlers.get("input")?.({ source: "extension", streamingBehavior: "followUp", text: sent[3]?.content });
-			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
-			handlers.get("session_shutdown")?.({});
-			const failed = consumeSteerAcks(dir)[0];
-			assert.equal(failed?.state, "failed");
-			assert.match(failed?.message ?? "", /ended before queued follow-up/);
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("queues auto steering after agent_end until agent_settled", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-settled-steering-runtime-"));
-		try {
-			const inbox = path.join(dir, "inbox");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
-			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			const sent: Array<{ content: string; deliverAs?: string }> = [];
-			registerSteeringInbox({
-				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
-				sendUserMessage(content: string, options?: { deliverAs?: string }) { sent.push({ content, deliverAs: options?.deliverAs }); },
-			} as never);
-			handlers.get("session_start")?.({});
-			handlers.get("agent_start")?.({});
-			handlers.get("turn_start")?.({});
-			handlers.get("turn_end")?.({});
-			handlers.get("agent_end")?.({ willRetry: false });
-
-			writeSteerRequestToDir(inbox, { type: "steer", id: "settling-auto", ts: 1, message: "Wait for settled.", mode: "auto" });
-			handlers.get("message_start")?.({});
-			assert.equal(sent[0]?.deliverAs, "followUp");
-			handlers.get("input")?.({ source: "extension", streamingBehavior: "followUp", text: sent[0]?.content });
-			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
-
-			handlers.get("agent_settled")?.({});
-			writeSteerRequestToDir(inbox, { type: "steer", id: "settled-auto", ts: 2, message: "Now idle.", mode: "auto" });
-			handlers.get("message_start")?.({});
-			assert.equal(sent[1]?.deliverAs, undefined);
-			handlers.get("input")?.({ source: "extension", text: sent[1]?.content });
-			assert.equal(consumeSteerAcks(dir)[0]?.deliveryStatus, "delivered");
-			handlers.get("session_shutdown")?.({});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("keeps auto steering queued while agent_end will retry", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-retry-steering-runtime-"));
-		try {
-			const inbox = path.join(dir, "inbox");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
-			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			const sent: Array<{ content: string; deliverAs?: string }> = [];
-			registerSteeringInbox({
-				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
-				sendUserMessage(content: string, options?: { deliverAs?: string }) { sent.push({ content, deliverAs: options?.deliverAs }); },
-			} as never);
-			handlers.get("session_start")?.({});
-			handlers.get("agent_start")?.({});
-			handlers.get("turn_start")?.({});
-			handlers.get("turn_end")?.({});
-			handlers.get("agent_end")?.({ willRetry: true });
-
-			writeSteerRequestToDir(inbox, { type: "steer", id: "retry-auto", ts: 1, message: "Keep this guidance.", mode: "auto" });
-			handlers.get("message_start")?.({});
-			assert.equal(sent[0]?.deliverAs, "followUp");
-			handlers.get("input")?.({ source: "extension", streamingBehavior: "followUp", text: sent[0]?.content });
-			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
-
-			handlers.get("turn_start")?.({});
-			const delivered = consumeSteerAcks(dir)[0];
-			assert.equal(delivered?.requestId, "retry-auto");
-			assert.equal(delivered?.deliveryStatus, "delivered");
-			handlers.get("session_shutdown")?.({});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("falls back to idle delivery for runtimes without agent_settled", async () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-legacy-steering-runtime-"));
-		try {
-			const inbox = path.join(dir, "inbox");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			const sent: Array<{ content: string; deliverAs?: string }> = [];
-			registerSteeringInbox({
-				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
-				sendUserMessage(content: string, options?: { deliverAs?: string }) { sent.push({ content, deliverAs: options?.deliverAs }); },
-			} as never, { legacySettleFallbackMs: 5 });
-			handlers.get("session_start")?.({});
-			handlers.get("agent_start")?.({});
-			handlers.get("turn_start")?.({});
-			handlers.get("turn_end")?.({});
-			handlers.get("agent_end")?.({ willRetry: false });
-			await new Promise((resolve) => setTimeout(resolve, 20));
-
-			writeSteerRequestToDir(inbox, { type: "steer", id: "legacy-auto", ts: 1, message: "Legacy idle.", mode: "auto" });
-			handlers.get("message_start")?.({});
-			assert.equal(sent[0]?.deliverAs, undefined);
-			handlers.get("session_shutdown")?.({});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("does not acknowledge sendUserMessage until the correlated Pi input event arrives", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-ack-runtime-"));
-		try {
-			const inbox = path.join(dir, "inbox");
-			const capability = path.join(dir, "capability.json");
-			const ackDir = path.join(dir, "control", "steer-acks", "0");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			process.env[SUBAGENT_STEER_CAPABILITY_ENV] = capability;
-			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = ackDir;
-			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			const sent: string[] = [];
-			registerSteeringInbox({
-				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
-				sendUserMessage(content: string) { sent.push(content); },
-			} as never);
-			handlers.get("session_start")?.({});
-			writeSteerRequestToDir(inbox, { type: "steer", id: "first", ts: 1, message: "Focus on tests." });
-			handlers.get("message_start")?.({});
-			assert.equal(sent.length, 1);
-			assert.deepEqual(fs.existsSync(ackDir) ? fs.readdirSync(ackDir) : [], []);
-			handlers.get("input")?.({ source: "extension", streamingBehavior: "steer", text: sent[0] });
-			const acks = consumeSteerAcks(dir);
-			assert.equal(acks.length, 1);
-			assert.equal(acks[0]?.requestId, "first");
-			assert.equal(acks[0]?.state, "delivered");
-			assert.equal(acks[0]?.message, "Pi accepted the correlated steering input.");
-			handlers.get("session_shutdown")?.({});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("retries pending correlation once as a follow-up after compaction", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-compaction-runtime-"));
-		try {
-			const inbox = path.join(dir, "inbox");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			process.env[SUBAGENT_STEER_CAPABILITY_ENV] = path.join(dir, "capability.json");
-			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
-			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			const sent: Array<{ content: string; deliverAs?: string }> = [];
-			registerSteeringInbox({
-				on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); },
-				sendUserMessage(content: string, options?: { deliverAs?: string }) { sent.push({ content, deliverAs: options?.deliverAs }); },
-			} as never);
-			handlers.get("session_start")?.({});
-			writeSteerRequestToDir(inbox, { type: "steer", id: "compact", ts: 1, message: "Keep this guidance." });
-			handlers.get("message_start")?.({});
-			assert.equal(sent.length, 1);
-			assert.deepEqual(consumeSteerAcks(dir), []);
-
-			handlers.get("session_compact")?.({ reason: "manual" });
-			assert.equal(sent.length, 2);
-			assert.equal(sent[1]?.deliverAs, "followUp");
-			handlers.get("input")?.({ source: "extension", text: sent[1]?.content });
-			assert.equal(consumeSteerAcks(dir)[0]?.state, "queued");
-			handlers.get("turn_start")?.({});
-			assert.equal(consumeSteerAcks(dir)[0]?.state, "delivered");
-			handlers.get("session_compact")?.({ reason: "manual" });
-			assert.equal(sent.length, 2);
-			handlers.get("session_shutdown")?.({});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("fails pending correlation when the session shuts down", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-pending-shutdown-runtime-"));
-		try {
-			const inbox = path.join(dir, "inbox");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			process.env[SUBAGENT_STEER_CAPABILITY_ENV] = path.join(dir, "capability.json");
-			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
-			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			registerSteeringInbox({ on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); }, sendUserMessage() {} } as never);
-			handlers.get("session_start")?.({});
-			writeSteerRequestToDir(inbox, { type: "steer", id: "pending", ts: 1, message: "Unconfirmed guidance." });
-			handlers.get("message_start")?.({});
-			handlers.get("session_shutdown")?.({});
-			const ack = consumeSteerAcks(dir)[0];
-			assert.equal(ack?.requestId, "pending");
-			assert.equal(ack?.state, "failed");
-			assert.match(ack?.message ?? "", /before Pi confirmed steering input delivery/);
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("correlates duplicate guidance FIFO without a visible marker", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-fifo-runtime-"));
-		try {
-			const inbox = path.join(dir, "inbox");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			process.env[SUBAGENT_STEER_CAPABILITY_ENV] = path.join(dir, "capability.json");
-			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
-			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			const sent: string[] = [];
-			registerSteeringInbox({ on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); }, sendUserMessage(content: string) { sent.push(content); } } as never);
-			handlers.get("session_start")?.({});
-			writeSteerRequestToDir(inbox, { type: "steer", id: "one", ts: 1, message: "same guidance" });
-			writeSteerRequestToDir(inbox, { type: "steer", id: "two", ts: 2, message: "same guidance" });
-			handlers.get("message_start")?.({});
-			handlers.get("input")?.({ source: "extension", streamingBehavior: "steer", text: sent[0] });
-			handlers.get("input")?.({ source: "extension", streamingBehavior: "steer", text: sent[1] });
-			assert.deepEqual(consumeSteerAcks(dir).map((ack) => ack.requestId), ["one", "two"]);
-			handlers.get("session_shutdown")?.({});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("publishes an unsupported capability and failed acknowledgments without sendUserMessage", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-steering-unsupported-runtime-"));
-		try {
-			const inbox = path.join(dir, "inbox");
-			process.env[SUBAGENT_STEER_INBOX_ENV] = inbox;
-			process.env[SUBAGENT_STEER_CAPABILITY_ENV] = path.join(dir, "capability.json");
-			process.env[SUBAGENT_STEER_ACK_DIR_ENV] = path.join(dir, "control", "steer-acks", "0");
-			process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			registerSteeringInbox({ on(event: string, handler: (payload?: unknown) => unknown) { handlers.set(event, handler); } } as never);
-			handlers.get("session_start")?.({});
-			assert.equal(JSON.parse(fs.readFileSync(path.join(dir, "capability.json"), "utf-8")).supported, false);
-			writeSteerRequestToDir(inbox, { type: "steer", id: "unsupported", ts: 1, message: "guidance" });
-			handlers.get("message_start")?.({});
-			assert.equal(consumeSteerAcks(dir)[0]?.state, "failed");
-			handlers.get("session_shutdown")?.({});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("registers child watchdog lifecycle handlers only when enabled by env", () => {
-		delete process.env[CHILD_WATCHDOG_CONFIG_ENV];
-		// Clear the ack capture env explicitly: when this test suite itself runs inside a
-		// pi-subagents child, the runner sets it and an extra agent_end handler registers.
-		delete process.env[RUNTIME_EXTENSION_ACK_PATH_ENV];
-		delete process.env[SUBAGENT_STEER_INBOX_ENV];
-		delete process.env[SUBAGENT_STEER_CAPABILITY_ENV];
-		delete process.env[SUBAGENT_STEER_ACK_DIR_ENV];
+	it("registers child watchdog lifecycle handlers only when the config enables them", () => {
 		const handlersWithout = new Map<string, unknown[]>();
 		registerSubagentPromptRuntime({
 			on(event: string, handler: unknown) {
 				handlersWithout.set(event, [...(handlersWithout.get(event) ?? []), handler]);
 			},
-		} as { on(event: string, handler: unknown): void });
+		} as { on(event: string, handler: unknown): void }, childConfig());
 		assert.equal(handlersWithout.get("agent_end")?.length ?? 0, 1, "headless auto-drain is always registered");
 
-		process.env[CHILD_WATCHDOG_CONFIG_ENV] = JSON.stringify({
-			enabled: true,
-			runId: "run-1",
-			agent: "worker",
-			childIndex: 0,
-			watchdogTailTimeoutMs: 1000,
-			agentEndTimeoutMs: 500,
-			maxWarnings: null,
-			lsp: { enabled: false, timeoutMs: 3000, maxFiles: 20, maxDiagnostics: 50 },
-			stalemateRepeats: 2,
-			cadence: { everyNTools: null },
-		});
 		const handlersWith = new Map<string, unknown[]>();
 		registerSubagentPromptRuntime({
 			on(event: string, handler: unknown) {
@@ -712,21 +189,16 @@ describe("subagent prompt runtime", () => {
 				return "off";
 			},
 			sendMessage() {},
-		} as { on(event: string, handler: unknown): void; getThinkingLevel(): string; sendMessage(): void });
+		} as { on(event: string, handler: unknown): void; getThinkingLevel(): string; sendMessage(): void }, childConfig({ childWatchdog: watchdogConfig, watchdogStatus: () => {} }));
 
 		assert.ok((handlersWith.get("before_agent_start")?.length ?? 0) >= 2);
 		assert.ok((handlersWith.get("turn_end")?.length ?? 0) >= 1);
 		assert.ok((handlersWith.get("agent_end")?.length ?? 0) >= 2, "watchdog and auto-drain both observe agent_end");
 	});
 
-	it("registered structured_output tool accepts valid schema output and writes the capture file", async () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-structured-runtime-"));
-		try {
-			const schemaPath = path.join(dir, "schema.json");
-			const outputPath = path.join(dir, "output.json");
-			fs.writeFileSync(schemaPath, JSON.stringify({ type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } }), "utf-8");
-			process.env[STRUCTURED_OUTPUT_SCHEMA_ENV] = schemaPath;
-			process.env[STRUCTURED_OUTPUT_CAPTURE_ENV] = outputPath;
+	it("registered structured_output tool accepts valid schema output and captures it", async () => {
+		{
+			const captured: unknown[] = [];
 			let execute: ((_id: string, params: { value: unknown }) => Promise<{ terminate?: boolean }>) | undefined;
 			let parameters: unknown;
 
@@ -738,7 +210,9 @@ describe("subagent prompt runtime", () => {
 					}
 				},
 				on() {},
-			} as { registerTool(tool: { name: string; parameters: unknown; execute: (_id: string, params: { value: unknown }) => Promise<{ terminate?: boolean }> }): void; on(): void });
+			} as { registerTool(tool: { name: string; parameters: unknown; execute: (_id: string, params: { value: unknown }) => Promise<{ terminate?: boolean }> }): void; on(): void }, childConfig({
+				structuredOutput: { schema: { type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } }, capture: (value) => captured.push(value) },
+			}));
 
 			assert.ok(execute, "structured_output tool should be registered");
 			assert.deepEqual(parameters, {
@@ -749,23 +223,13 @@ describe("subagent prompt runtime", () => {
 			});
 			const result = await execute("tool-1", { value: { ok: true } });
 			assert.equal(result.terminate, true);
-			assert.deepEqual(JSON.parse(fs.readFileSync(outputPath, "utf-8")), { ok: true });
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
+			assert.deepEqual(captured, [{ ok: true }]);
 		}
 	});
 
 	it("requires and validates acceptanceReport when structured capture is required", async () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-structured-acceptance-"));
-		try {
-			const schemaPath = path.join(dir, "schema.json");
-			const outputPath = path.join(dir, "output.json");
-			const acceptancePath = path.join(dir, "acceptance.json");
-			fs.writeFileSync(schemaPath, JSON.stringify({ type: "object" }), "utf-8");
-			process.env[STRUCTURED_OUTPUT_SCHEMA_ENV] = schemaPath;
-			process.env[STRUCTURED_OUTPUT_CAPTURE_ENV] = outputPath;
-			process.env[STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV] = acceptancePath;
-			process.env[STRUCTURED_OUTPUT_ACCEPTANCE_REQUIRED_ENV] = "1";
+		{
+			const captured: Array<{ value: unknown; acceptanceReport: unknown }> = [];
 			let execute: ((_id: string, params: { value: unknown; acceptanceReport?: unknown }) => Promise<unknown>) | undefined;
 			let parameters: { required?: string[] } | undefined;
 
@@ -777,29 +241,21 @@ describe("subagent prompt runtime", () => {
 					}
 				},
 				on() {},
-			} as { registerTool(tool: { name: string; parameters: unknown; execute: typeof execute }): void; on(): void });
+			} as { registerTool(tool: { name: string; parameters: unknown; execute: typeof execute }): void; on(): void }, childConfig({
+				structuredOutput: { schema: { type: "object" }, acceptanceReport: "required", capture: (value, acceptanceReport) => captured.push({ value, acceptanceReport }) },
+			}));
 
 			assert.deepEqual(parameters?.required, ["value", "acceptanceReport"]);
 			await assert.rejects(execute!("missing", { value: {} }), /Missing acceptanceReport/);
 			await assert.rejects(execute!("empty", { value: {}, acceptanceReport: {} }), /expected at least one acceptance report field/);
 			await execute!("valid", { value: {}, acceptanceReport: { manualNotes: "validated evidence" } });
-			assert.deepEqual(JSON.parse(fs.readFileSync(acceptancePath, "utf-8")), { manualNotes: "validated evidence" });
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
+			assert.deepEqual(captured, [{ value: {}, acceptanceReport: { manualNotes: "validated evidence" } }]);
 		}
 	});
 
-	it("clears stale optional acceptance reports when structured output omits them", async () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-structured-acceptance-stale-"));
-		try {
-			const schemaPath = path.join(dir, "schema.json");
-			const outputPath = path.join(dir, "output.json");
-			const acceptancePath = path.join(dir, "acceptance.json");
-			fs.writeFileSync(schemaPath, JSON.stringify({ type: "object" }), "utf-8");
-			fs.writeFileSync(acceptancePath, JSON.stringify({ manualNotes: "stale" }), "utf-8");
-			process.env[STRUCTURED_OUTPUT_SCHEMA_ENV] = schemaPath;
-			process.env[STRUCTURED_OUTPUT_CAPTURE_ENV] = outputPath;
-			process.env[STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE_ENV] = acceptancePath;
+	it("captures an omitted optional acceptance report as undefined", async () => {
+		{
+			const captured: Array<{ value: unknown; acceptanceReport: unknown }> = [];
 			let execute: ((_id: string, params: { value: unknown }) => Promise<unknown>) | undefined;
 
 			registerSubagentPromptRuntime({
@@ -807,13 +263,12 @@ describe("subagent prompt runtime", () => {
 					if (tool.name === "structured_output") execute = tool.execute;
 				},
 				on() {},
-			} as { registerTool(tool: { name: string; execute: typeof execute }): void; on(): void });
+			} as { registerTool(tool: { name: string; execute: typeof execute }): void; on(): void }, childConfig({
+				structuredOutput: { schema: { type: "object" }, acceptanceReport: "optional", capture: (value, acceptanceReport) => captured.push({ value, acceptanceReport }) },
+			}));
 
 			await execute!("without-report", { value: {} });
-			assert.equal(fs.existsSync(acceptancePath), false);
-			assert.deepEqual(JSON.parse(fs.readFileSync(outputPath, "utf-8")), {});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
+			assert.deepEqual(captured, [{ value: {}, acceptanceReport: undefined }]);
 		}
 	});
 
@@ -836,11 +291,8 @@ describe("subagent prompt runtime", () => {
 	});
 
 	it("scopes local structured_output schema refs under the value parameter", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-structured-refs-"));
-		try {
-			const schemaPath = path.join(dir, "schema.json");
-			const outputPath = path.join(dir, "output.json");
-			fs.writeFileSync(schemaPath, JSON.stringify({
+		{
+			const schema = {
 				$defs: { item: { type: "string" } },
 				type: "object",
 				properties: {
@@ -850,9 +302,7 @@ describe("subagent prompt runtime", () => {
 						properties: { label: { $ref: "#/$defs/item" } },
 					},
 				},
-			}), "utf-8");
-			process.env[STRUCTURED_OUTPUT_SCHEMA_ENV] = schemaPath;
-			process.env[STRUCTURED_OUTPUT_CAPTURE_ENV] = outputPath;
+			};
 			let parameters = {} as { properties?: { value?: { properties?: { name?: { $ref?: string }; nested?: { properties?: { label?: { $ref?: string } } } } } } };
 
 			registerSubagentPromptRuntime({
@@ -860,12 +310,10 @@ describe("subagent prompt runtime", () => {
 					if (tool.name === "structured_output") parameters = tool.parameters as typeof parameters;
 				},
 				on() {},
-			} as { registerTool(tool: { name: string; parameters: unknown }): void; on(): void });
+			} as { registerTool(tool: { name: string; parameters: unknown }): void; on(): void }, childConfig({ structuredOutput: { schema, capture: () => {} } }));
 
 			assert.equal(parameters.properties?.value?.properties?.name?.$ref, "#/properties/value/$defs/item");
 			assert.equal(parameters.properties?.value?.properties?.nested?.properties?.label?.$ref, "#/properties/value/$defs/item");
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
 		}
 	});
 
@@ -1187,13 +635,10 @@ describe("subagent prompt runtime", () => {
 		const subagentResult = { role: "toolResult", toolName: "subagent", content: "OK" };
 		const subagentCall = { role: "assistant", content: [{ type: "toolCall", name: "subagent", input: { agent: "delegate" } }] };
 		const instruction = { role: "custom", customType: "subagent-orchestration-instructions", content: "Subagent orchestration is enabled." };
-		process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
-
-		assert.deepEqual(stripParentOnlySubagentMessages([user, subagentCall, subagentResult, instruction]), [user, subagentCall, subagentResult]);
+		assert.deepEqual(stripParentOnlySubagentMessages([user, subagentCall, subagentResult, instruction], { preserveFanoutToolHistory: true }), [user, subagentCall, subagentResult]);
 	});
 
 	it("defers native supervisor registration until runtime events and respects installed pi-intercom tools", async () => {
-		setSupervisorEnv();
 		const handlers = new Map<string, (payload?: unknown) => unknown>();
 		const registered: string[] = [];
 
@@ -1205,7 +650,7 @@ describe("subagent prompt runtime", () => {
 			registerTool(tool: { name: string }) {
 				registered.push(tool.name);
 			},
-		} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(tool: { name: string }): void });
+		} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(tool: { name: string }): void }, supervisorConfig());
 
 		assert.deepEqual(registered, ["bg_wait", "subagent_wait"]);
 		handlers.get("session_start")?.({});
@@ -1214,15 +659,10 @@ describe("subagent prompt runtime", () => {
 	});
 
 	it("does not satisfy strict allowlists with native generic intercom", () => {
-		setSupervisorEnv();
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-intercom-diagnostic-"));
-		try {
-			const diagnosticPath = path.join(dir, "tools.json");
+		{
+			const diagnostics: Array<ChildToolDiagnostic | undefined> = [];
 			const handlers = new Map<string, (payload?: unknown) => unknown>();
 			const registered: string[] = [];
-			process.env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(["read", "grep", "find", "ls", "bash", "edit", "write", "intercom"]);
-			process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = diagnosticPath;
-			process.env[SUBAGENT_CHILD_AGENT_ENV] = "scout";
 
 			registerSubagentPromptRuntime({
 				on(event: string, handler: (payload?: unknown) => unknown) {
@@ -1232,30 +672,28 @@ describe("subagent prompt runtime", () => {
 				registerTool(tool: { name: string }) {
 					registered.push(tool.name);
 				},
-			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(tool: { name: string }): void });
+			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(tool: { name: string }): void }, supervisorConfig({
+				agent: "scout",
+				requiredTools: ["read", "grep", "find", "ls", "bash", "edit", "write", "intercom"],
+				toolDiagnostic: (diagnostic) => diagnostics.push(diagnostic),
+			}));
 
 			handlers.get("session_start")?.({});
 			assert.deepEqual(registered, ["bg_wait", "subagent_wait", "contact_supervisor"]);
 			assert.throws(() => handlers.get("agent_start")?.({}), /requested unavailable child tools: read, grep, find, ls, bash, edit, write, intercom/);
-			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
+			assert.deepEqual(diagnostics, [{
 				agent: "scout",
 				required: ["read", "grep", "find", "ls", "bash", "edit", "write", "intercom"],
 				available: ["bg_wait", "subagent_wait", "contact_supervisor"],
 				missing: ["read", "grep", "find", "ls", "bash", "edit", "write", "intercom"],
-			});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
+			}]);
 		}
 	});
 
 	it("records missing core write tools from the actual child registry", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-core-tool-diagnostic-"));
-		try {
-			const diagnosticPath = path.join(dir, "tools.json");
+		{
+			const diagnostics: Array<ChildToolDiagnostic | undefined> = [];
 			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			process.env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(["read", "grep", "find", "ls", "bash", "edit", "write"]);
-			process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = diagnosticPath;
-			process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
 
 			registerSubagentPromptRuntime({
 				on(event: string, handler: (payload?: unknown) => unknown) {
@@ -1263,22 +701,23 @@ describe("subagent prompt runtime", () => {
 				},
 				getAllTools: () => ["read", "grep", "find", "ls", "contact_supervisor"].map((name) => ({ name })),
 				registerTool() {},
-			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(): void });
+			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(): void }, childConfig({
+				agent: "worker",
+				requiredTools: ["read", "grep", "find", "ls", "bash", "edit", "write"],
+				toolDiagnostic: (diagnostic) => diagnostics.push(diagnostic),
+			}));
 
 			assert.throws(() => handlers.get("agent_start")?.({}), /requested unavailable child tools: bash, edit, write/);
-			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
+			assert.deepEqual(diagnostics, [{
 				agent: "worker",
 				required: ["read", "grep", "find", "ls", "bash", "edit", "write"],
 				available: ["read", "grep", "find", "ls", "contact_supervisor"],
 				missing: ["bash", "edit", "write"],
-			});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
+			}]);
 		}
 	});
 
 	it("keeps installed pi-intercom while filling only a missing child contact_supervisor tool", async () => {
-		setSupervisorEnv();
 		const handlers = new Map<string, (payload?: unknown) => unknown>();
 		const registered: string[] = [];
 
@@ -1290,7 +729,7 @@ describe("subagent prompt runtime", () => {
 			registerTool(tool: { name: string }) {
 				registered.push(tool.name);
 			},
-		} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(tool: { name: string }): void });
+		} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(tool: { name: string }): void }, supervisorConfig());
 
 		handlers.get("session_start")?.({});
 		await handlers.get("before_agent_start")?.({ systemPrompt: BASE_PROMPT });
@@ -1299,13 +738,10 @@ describe("subagent prompt runtime", () => {
 	});
 
 	it("registers only native supervisor tools at runtime when pi-intercom is absent", async () => {
-		setSupervisorEnv();
-		const previousRequiredTools = process.env[REQUIRED_CHILD_TOOLS_ENV];
-		delete process.env[REQUIRED_CHILD_TOOLS_ENV];
 		const handlers = new Map<string, (payload?: unknown) => unknown>();
 		const registered: string[] = [];
 
-		try {
+		{
 			registerSubagentPromptRuntime({
 				on(event: string, handler: (payload?: unknown) => unknown) {
 					handlers.set(event, handler);
@@ -1314,28 +750,21 @@ describe("subagent prompt runtime", () => {
 				registerTool(tool: { name: string }) {
 					registered.push(tool.name);
 				},
-			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(tool: { name: string }): void });
+			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(tool: { name: string }): void }, supervisorConfig());
 
 			handlers.get("session_start")?.({});
 			assert.deepEqual(registered, ["bg_wait", "subagent_wait", "contact_supervisor"]);
 
 			await handlers.get("before_agent_start")?.({ systemPrompt: BASE_PROMPT });
 			assert.deepEqual(registered, ["bg_wait", "subagent_wait", "contact_supervisor"]);
-		} finally {
-			if (previousRequiredTools === undefined) delete process.env[REQUIRED_CHILD_TOOLS_ENV];
-			else process.env[REQUIRED_CHILD_TOOLS_ENV] = previousRequiredTools;
 		}
 	});
 
 	it("records requested tools missing from the child registry after startup hooks settle", async () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-tool-diagnostic-"));
-		try {
-			const diagnosticPath = path.join(dir, "tools.json");
+		{
+			const diagnostics: Array<ChildToolDiagnostic | undefined> = [];
 			const handlers = new Map<string, (payload?: unknown) => unknown>();
 			const available = ["read"];
-			process.env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(["read", "fixture_search"]);
-			process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = diagnosticPath;
-			process.env[SUBAGENT_CHILD_AGENT_ENV] = "extension-worker";
 
 			registerSubagentPromptRuntime({
 				on(event: string, handler: (payload?: unknown) => unknown) {
@@ -1343,67 +772,34 @@ describe("subagent prompt runtime", () => {
 				},
 				getAllTools: () => available.map((name) => ({ name })),
 				registerTool() {},
-			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(): void });
+			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(): void }, childConfig({
+				agent: "extension-worker",
+				requiredTools: ["read", "fixture_search"],
+				toolDiagnostic: (diagnostic) => diagnostics.push(diagnostic),
+			}));
 
 			const promptRewrite = await handlers.get("before_agent_start")?.({ systemPrompt: BASE_PROMPT }) as { systemPrompt?: string } | undefined;
-			assert.equal(fs.existsSync(diagnosticPath), false);
+			assert.deepEqual(diagnostics, []);
 			assert.doesNotMatch(promptRewrite?.systemPrompt ?? "", /requested unavailable child tools/);
 
 			assert.throws(() => handlers.get("agent_start")?.({}), /requested unavailable child tools: fixture_search/);
-			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
+			assert.deepEqual(diagnostics, [{
 				agent: "extension-worker",
 				required: ["read", "fixture_search"],
 				available: ["read"],
 				missing: ["fixture_search"],
-			});
+			}]);
 
 			available.push("fixture_search");
 			handlers.get("agent_start")?.({});
-			assert.equal(fs.existsSync(diagnosticPath), false);
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("ignores malformed inherited MCP metadata before strict availability diagnostics", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-stale-mcp-tool-diagnostic-"));
-		try {
-			const diagnosticPath = path.join(dir, "tools.json");
-			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			process.env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(["read", "fixture_search"]);
-			process.env[MCP_DIRECT_CHILD_TOOLS_ENV] = "not-json";
-			process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = diagnosticPath;
-			process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
-
-			registerSubagentPromptRuntime({
-				on(event: string, handler: (payload?: unknown) => unknown) {
-					handlers.set(event, handler);
-				},
-				getAllTools: () => [{ name: "read" }],
-				registerTool() {},
-			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(): void });
-
-			assert.throws(() => handlers.get("agent_start")?.({}), /requested unavailable child tools: fixture_search/);
-			assert.deepEqual(readChildToolDiagnostic(diagnosticPath), {
-				agent: "worker",
-				required: ["read", "fixture_search"],
-				available: ["read"],
-				missing: ["fixture_search"],
-			});
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
+			assert.equal(diagnostics.at(-1), undefined);
 		}
 	});
 
 	it("classifies missing resolved MCP direct tools without softening strict diagnostics", () => {
-		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-mcp-tool-diagnostic-"));
-		try {
-			const diagnosticPath = path.join(dir, "tools.json");
+		{
+			const diagnostics: Array<ChildToolDiagnostic | undefined> = [];
 			const handlers = new Map<string, (payload?: unknown) => unknown>();
-			process.env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(["read", "rust_symbols_workspace_symbols", "fixture_search"]);
-			process.env[MCP_DIRECT_CHILD_TOOLS_ENV] = JSON.stringify(["rust_symbols_workspace_symbols"]);
-			process.env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = diagnosticPath;
-			process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
 
 			registerSubagentPromptRuntime({
 				on(event: string, handler: (payload?: unknown) => unknown) {
@@ -1411,10 +807,15 @@ describe("subagent prompt runtime", () => {
 				},
 				getAllTools: () => [{ name: "read" }],
 				registerTool() {},
-			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(): void });
+			} as { on(event: string, handler: (payload?: unknown) => unknown): void; getAllTools(): Array<{ name: string }>; registerTool(): void }, childConfig({
+				agent: "worker",
+				requiredTools: ["read", "rust_symbols_workspace_symbols", "fixture_search"],
+				mcpDirectTools: ["rust_symbols_workspace_symbols"],
+				toolDiagnostic: (diagnostic) => diagnostics.push(diagnostic),
+			}));
 
 			assert.throws(() => handlers.get("agent_start")?.({}), /requested unavailable child tools: rust_symbols_workspace_symbols, fixture_search/);
-			const diagnostic = readChildToolDiagnostic(diagnosticPath);
+			const diagnostic = diagnostics[0];
 			assert.deepEqual(diagnostic, {
 				agent: "worker",
 				required: ["read", "rust_symbols_workspace_symbols", "fixture_search"],
@@ -1424,16 +825,12 @@ describe("subagent prompt runtime", () => {
 			});
 			assert.match(formatChildToolDiagnostic(diagnostic!), /host\/pi-mcp-adapter registration problem/);
 			assert.match(formatChildToolDiagnostic(diagnostic!), /fixture_search/);
-			assert.equal(fs.existsSync(diagnosticPath), true);
-		} finally {
-			fs.rmSync(dir, { recursive: true, force: true });
 		}
 	});
 
-	it("sets the child intercom session name from env during agent startup", async () => {
+	it("sets the child intercom session name from the config during agent startup", async () => {
 		let sessionName: string | undefined;
 		let beforeAgentStart: ((event: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) | undefined;
-		process.env[SUBAGENT_INTERCOM_SESSION_NAME_ENV] = "subagent-worker-78f659a3";
 
 		registerSubagentPromptRuntime({
 			on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) {
@@ -1443,7 +840,7 @@ describe("subagent prompt runtime", () => {
 			setSessionName(name: string) {
 				sessionName = name;
 			},
-		} as { on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>): void; getAllTools(): Array<{ name: string }>; setSessionName(name: string): void });
+		} as { on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>): void; getAllTools(): Array<{ name: string }>; setSessionName(name: string): void }, childConfig({ intercomSessionName: "subagent-worker-78f659a3", sessionName: "worker: display name" }));
 
 		await beforeAgentStart?.({ systemPrompt: BASE_PROMPT });
 
@@ -1457,11 +854,9 @@ describe("subagent prompt runtime", () => {
 				if (event === "before_agent_start") beforeAgentStart = handler;
 			},
 			getAllTools: () => [{ name: "intercom" }, { name: "contact_supervisor" }],
-		} as { on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>): void; getAllTools(): Array<{ name: string }> });
+		} as { on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>): void; getAllTools(): Array<{ name: string }> }, childConfig({ inheritProjectContext: false, inheritGlobalContext: true, inheritSkills: false }));
 
 		assert.ok(beforeAgentStart, "expected before_agent_start handler");
-		process.env.SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT = "0";
-		process.env.SELESAI_SUBAGENT_INHERIT_SKILLS = "0";
 
 		const rewritten = await beforeAgentStart?.({ systemPrompt: BASE_PROMPT });
 		assert.ok(rewritten);
@@ -1470,18 +865,14 @@ describe("subagent prompt runtime", () => {
 		assert.ok(rewritten.systemPrompt.includes("Current date: 2026-04-16"));
 	});
 
-	it("uses the fanout boundary through before_agent_start when fanout env is set", async () => {
+	it("uses the fanout boundary through before_agent_start for a fanout child", async () => {
 		let beforeAgentStart: ((event: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) | undefined;
 		registerSubagentPromptRuntime({
 			on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>) {
 				if (event === "before_agent_start") beforeAgentStart = handler;
 			},
 			getAllTools: () => [{ name: "intercom" }, { name: "contact_supervisor" }],
-		} as { on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>): void; getAllTools(): Array<{ name: string }> });
-
-		process.env.SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT = "1";
-		process.env.SELESAI_SUBAGENT_INHERIT_SKILLS = "1";
-		process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
+		} as { on(event: string, handler: (payload: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>): void; getAllTools(): Array<{ name: string }> }, childConfig({ fanoutChild: true, inheritProjectContext: true, inheritGlobalContext: true, inheritSkills: true }));
 
 		const rewritten = await beforeAgentStart?.({ systemPrompt: BASE_PROMPT });
 		assert.ok(rewritten);
@@ -1494,7 +885,7 @@ describe("subagent prompt runtime", () => {
 			on(event: string, handler: (payload: { messages: unknown[] }) => { messages: unknown[] } | undefined) {
 				if (event === "context") contextHandler = handler;
 			},
-		} as { on(event: string, handler: (payload: { messages: unknown[] }) => { messages: unknown[] } | undefined): void });
+		} as { on(event: string, handler: (payload: { messages: unknown[] }) => { messages: unknown[] } | undefined): void }, childConfig());
 
 		const priorParentTurn = { role: "user", content: "Earlier we said planner → worker → reviewers → worker." };
 		const currentTask = { role: "user", content: "Now implement only the assigned fix." };
@@ -1517,7 +908,7 @@ describe("subagent prompt runtime", () => {
 			on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) {
 				if (event === "context") contextHandler = handler;
 			},
-		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void });
+		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void }, childConfig());
 
 		const toolCallId = "call_N7iYNRPXLl9czpXh3bDyMpIL|fc_0e76718634eca88f016a76fdc89aec81919763fa7858f67a0d";
 		const messages = [
@@ -1542,7 +933,7 @@ describe("subagent prompt runtime", () => {
 			on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) {
 				if (event === "context") contextHandler = handler;
 			},
-		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void });
+		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void }, childConfig());
 
 		const toolCallId = "call_7XJjvAJfk07117JO8LgBCZjY|fc_0e92b09b28010bac016a756e9e79cc8197b01825a5dc3d9eaa";
 		const messages = [
@@ -1560,7 +951,7 @@ describe("subagent prompt runtime", () => {
 			on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) {
 				if (event === "context") contextHandler = handler;
 			},
-		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void });
+		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void }, childConfig());
 
 		const toolCallId = "call_7XJjvAJfk07117JO8LgBCZjY\nfc_0e92b09b28010bac016a756e9e79cc8197b01825a5dc3d9eaa";
 		const messages = [
@@ -1580,7 +971,7 @@ describe("subagent prompt runtime", () => {
 			on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined) {
 				if (event === "context") contextHandler = handler;
 			},
-		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void });
+		} as { on(event: string, handler: (payload: { messages: unknown[] }, ctx: { model?: { api: string } }) => { messages: unknown[] } | undefined): void }, childConfig());
 
 		const messages = [
 			{ role: "user", content: "Task" },
@@ -1590,4 +981,4 @@ describe("subagent prompt runtime", () => {
 
 		assert.equal(contextHandler?.({ messages }, {}), undefined);
 	});
-});
+});