@selesai/code 0.5.20 → 0.5.21

package/dist/extensions/pi-subagents/test/integration/async-execution.test.ts

@@ -15,12 +15,21 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { createEventBus, createMockPi, createTempDir, events, makeAgent, makeMinimalCtx, removeTempDir, tryImport } from "../support/helpers.ts";
 import type { MockPi } from "../support/helpers.ts";
-import { deliverInterruptRequest } from "../../src/runs/background/control-channel.ts";
+import { deliverInterruptRequest, deliverStopRequest, deliverTimeoutRequest } from "../../src/runs/background/control-channel.ts";
+import { waitForSubagents } from "../../src/runs/background/subagent-wait.ts";
+import { writeAtomicJson } from "../../src/shared/atomic-json.ts";
+import { CHILD_WATCHDOG_STATUS_EVENT } from "../../src/watchdog/child-status.ts";
+import { MAX_CHILD_PENDING_LINE_BYTES, MAX_CHILD_STDERR_BYTES } from "../../src/runs/shared/child-protocol.ts";
+import { SUBAGENT_ASYNC_STARTED_EVENT, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION } from "../../src/shared/types.ts";
+import { registerSubagentCapabilityCeiling } from "../../src/api/capability-ceiling.ts";
+import { resolveSubagentLaunchContract } from "../../src/api/preflight.ts";
+import { discoverAgents } from "../../src/agents/agents.ts";
+import { runSync } from "../../src/runs/foreground/execution.ts";
 
 interface AsyncExecutionResult {
 	content: Array<{ text?: string }>;
 	isError?: boolean;
-	details: { asyncId?: string };
+	details: { asyncId?: string; asyncDir?: string; launchContractDigest?: string };
 }
 
 interface AsyncResultPayload {
@@ -30,38 +39,49 @@ interface AsyncResultPayload {
 	exitCode?: number;
 	sessionId?: string;
 	mode?: string;
+	launchContractDigest?: string;
 	summary?: string;
 	error?: string;
 	timeoutMs?: number;
 	deadlineAt?: number;
 	timedOut?: boolean;
-	turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; exceededAtTurn?: number };
+	stopped?: boolean;
+	turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; terminationDeferredAtTurn?: number; exceededAtTurn?: number };
 	turnBudgetExceeded?: boolean;
 	wrapUpRequested?: boolean;
 	totalTokens?: { input: number; output: number; total: number };
 	totalCost?: { inputTokens: number; outputTokens: number; costUsd: number };
-	results: Array<{ output?: string; success?: boolean; error?: string; timedOut?: boolean; turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; exceededAtTurn?: number }; turnBudgetExceeded?: boolean; wrapUpRequested?: boolean; model?: string; attemptedModels?: string[]; modelAttempts?: Array<{ success?: boolean; error?: string }>; totalCost?: { inputTokens: number; outputTokens: number; costUsd: number }; structuredOutput?: unknown; intercomTarget?: string; acceptance?: { status?: string; childReport?: unknown } }>;
+	results: Array<{ agent?: string; launchContractDigest?: string; output?: string; success?: boolean; error?: string; protocolError?: { code?: string; stream?: string; limitBytes?: number; observedBytes?: number }; timedOut?: boolean; stopped?: boolean; turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; terminationDeferredAtTurn?: number; exceededAtTurn?: number }; turnBudgetExceeded?: boolean; wrapUpRequested?: boolean; model?: string; attemptedModels?: string[]; modelAttempts?: Array<{ success?: boolean; error?: string }>; totalCost?: { inputTokens: number; outputTokens: number; costUsd: number }; structuredOutput?: unknown; agentContract?: { version: 1 }; execution?: { status?: string; success?: boolean; exitCode?: number }; effects?: { fileMutation?: { status?: string; expected?: boolean; attempted?: boolean } }; intercomTarget?: string; acceptance?: { status?: string; effectiveAcceptance?: { level?: string }; childReport?: unknown; runtimeChecks?: Array<{ id?: string; status?: string; message?: string }> }; artifactPaths?: { outputPath?: string; inputPath?: string; metadataPath?: string }; capabilityCeiling?: { version?: number; allowedTools?: string[]; denyExtensions?: boolean; sources?: string[] }; capabilityAudit?: { effectiveTools?: string[]; removedTools?: string[]; extensionsDenied?: boolean } }>;
 	outputs?: Record<string, { text?: string; structured?: unknown }>;
-	workflowGraph?: { nodes?: Array<{ kind?: string; label?: string; phase?: string; status?: string; error?: string; outputName?: string; structured?: boolean; children?: Array<{ label?: string; outputName?: string; itemKey?: string; status?: string; error?: string }> }> };
+	workflowGraph?: { nodes?: Array<{ kind?: string; label?: string; phase?: string; status?: string; acceptanceStatus?: string; error?: string; outputName?: string; structured?: boolean; children?: Array<{ label?: string; outputName?: string; itemKey?: string; status?: string; acceptanceStatus?: string; error?: string }> }> };
+	parallelHandoff?: { version?: number; path?: string; groupCount?: number; childCount?: number; changedPatches?: number; cleanupState?: string };
+	capabilityCeiling?: { version?: number; allowedTools?: string[]; denyExtensions?: boolean; sources?: string[] };
+	capabilityAudit?: { effectiveTools?: string[]; removedTools?: string[]; extensionsDenied?: boolean };
 }
 
 interface AsyncStatusPayload {
 	lifecycleArtifactVersion?: number;
 	sessionId?: string;
+	pid?: number;
 	activityState?: string;
 	currentTool?: string;
 	currentPath?: string;
 	state?: string;
+	launchContractDigest?: string;
 	error?: string;
 	timeoutMs?: number;
 	deadlineAt?: number;
 	timedOut?: boolean;
-	turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; exceededAtTurn?: number };
+	stopped?: boolean;
+	turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; terminationDeferredAtTurn?: number; exceededAtTurn?: number };
 	turnBudgetExceeded?: boolean;
 	wrapUpRequested?: boolean;
 	totalTokens?: { total: number };
 	totalCost?: { inputTokens: number; outputTokens: number; costUsd: number };
 	parallelGroups?: Array<{ start: number; count: number; stepIndex: number }>;
+	parallelHandoff?: { version?: number; path?: string; groupCount?: number; childCount?: number; changedPatches?: number; cleanupState?: string };
+	capabilityCeiling?: { version?: number; allowedTools?: string[]; denyExtensions?: boolean; sources?: string[] };
+	capabilityAudit?: { effectiveTools?: string[]; removedTools?: string[]; extensionsDenied?: boolean };
 	steps?: Array<{
 		label?: string;
 		phase?: string;
@@ -78,10 +98,16 @@ interface AsyncStatusPayload {
 		thinking?: string;
 		tokens?: { total: number };
 		totalCost?: { inputTokens: number; outputTokens: number; costUsd: number };
+		agentContract?: { version: 1 };
+		launchContractDigest?: string;
+		execution?: { status?: string; success?: boolean; exitCode?: number };
+		effects?: { fileMutation?: { status?: string; expected?: boolean; attempted?: boolean } };
 		acceptance?: { status?: string };
-		turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; exceededAtTurn?: number };
+		turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; terminationDeferredAtTurn?: number; exceededAtTurn?: number };
 		turnBudgetExceeded?: boolean;
 		wrapUpRequested?: boolean;
+		capabilityCeiling?: { version?: number; allowedTools?: string[]; denyExtensions?: boolean; sources?: string[] };
+		capabilityAudit?: { effectiveTools?: string[]; removedTools?: string[]; extensionsDenied?: boolean };
 	}>;
 }
 
@@ -90,6 +116,56 @@ interface MockPiCallRecord {
 	systemPrompts?: Array<{ mode?: string; path?: string; text?: string; error?: string }>;
 }
 
+function writeWatchdogSettings(projectDir: string, tailMs = 120_000): void {
+	const settingsPath = path.join(projectDir, ".selesai", "settings.json");
+	fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+	fs.writeFileSync(settingsPath, JSON.stringify({
+		subagents: {
+			watchdog: {
+				enabled: true,
+				children: {
+					enabled: true,
+					watchdogTailTimeoutMs: tailMs,
+				},
+			},
+		},
+	}, null, 2), "utf-8");
+}
+
+async function withIsolatedWatchdogSettings<T>(projectDir: string, run: () => Promise<T>): Promise<T> {
+	const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+	const previousHome = process.env.HOME;
+	const previousUserProfile = process.env.USERPROFILE;
+	const isolatedHome = path.join(projectDir, "isolated-home");
+	process.env.SELESAI_CODING_AGENT_DIR = path.join(isolatedHome, ".selesai", "agent");
+	process.env.HOME = isolatedHome;
+	process.env.USERPROFILE = isolatedHome;
+	try {
+		return await run();
+	} finally {
+		if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+		if (previousHome === undefined) delete process.env.HOME;
+		else process.env.HOME = previousHome;
+		if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = previousUserProfile;
+	}
+}
+
+function childWatchdogStatus(runId: string, phase: "idle" | "reviewing" | "autofollow" | "settling" | "stale" | "failed", seq: number, followUpPending = false) {
+	return {
+		type: CHILD_WATCHDOG_STATUS_EVENT,
+		runId,
+		agent: "worker",
+		childIndex: 0,
+		stepIndex: 0,
+		seq,
+		phase,
+		ts: Date.now() + seq,
+		followUpPending,
+	};
+}
+
 function mockAssistantMessage(text: string, stopReason: "stop" | "tool_use" = "stop") {
 	return {
 		type: "message_end",
@@ -186,16 +262,54 @@ function writePackageSkill(packageRoot: string, skillName: string): void {
 	);
 }
 
+function readIfExists(filePath: string): string | undefined {
+	try {
+		const text = fs.readFileSync(filePath, "utf-8").trim();
+		return text || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 async function waitForAsyncResultFile(id: string, timeoutMs = 15_000): Promise<string> {
 	const resultPath = path.join(RESULTS_DIR, `${id}.json`);
 	const deadline = Date.now() + timeoutMs;
 	while (!fs.existsSync(resultPath)) {
-		if (Date.now() > deadline) assert.fail(`Timed out waiting for async result file: ${resultPath}`);
+		if (Date.now() > deadline) {
+			const asyncDir = path.join(ASYNC_DIR, id);
+			const status = readIfExists(path.join(asyncDir, "status.json"));
+			const stdout = readIfExists(path.join(asyncDir, "runner.stdout.log"));
+			const stderr = readIfExists(path.join(asyncDir, "runner.stderr.log"));
+			assert.fail([
+				`Timed out waiting for async result file: ${resultPath}`,
+				status ? `status.json: ${status}` : undefined,
+				stdout ? `runner stdout: ${stdout}` : undefined,
+				stderr ? `runner stderr: ${stderr}` : undefined,
+			].filter(Boolean).join("\n"));
+		}
 		await new Promise((resolve) => setTimeout(resolve, 100));
 	}
 	return resultPath;
 }
 
+async function waitForDeferredTurnBudget(id: string, timeoutMs = 10_000): Promise<AsyncStatusPayload> {
+	const statusPath = path.join(ASYNC_DIR, id, "status.json");
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() <= deadline) {
+		if (fs.existsSync(statusPath)) {
+			const status = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as AsyncStatusPayload;
+			if (status.state === "running"
+				&& status.turnBudget?.outcome === "termination-deferred"
+				&& status.steps?.[0]?.turnBudget?.outcome === "termination-deferred"
+				&& status.steps[0].currentTool === "bash") {
+				return status;
+			}
+		}
+		await new Promise((resolve) => setTimeout(resolve, 50));
+	}
+	assert.fail(`Timed out waiting for deferred turn-budget status: ${statusPath}`);
+}
+
 async function waitForMockPiCall(mockPi: MockPi, index: number, timeoutMs = 30_000): Promise<{ args: string[]; systemPrompts: NonNullable<MockPiCallRecord["systemPrompts"]> }> {
 	const deadline = Date.now() + timeoutMs;
 	for (;;) {
@@ -272,11 +386,289 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 	afterEach(() => {
 		removeTempDir(tempDir);
 	});
+
+	function makeAsyncExecutor(agents: ReturnType<typeof makeAgent>[], config: Record<string, unknown> = {}) {
+		return createSubagentExecutor!({
+			pi: { events: createEventBus(), getSessionName: () => undefined },
+			state: { baseCwd: tempDir, currentSessionId: null, asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null },
+			config,
+			asyncByDefault: false,
+			tempArtifactsDir: tempDir,
+			getSubagentSessionRoot: () => tempDir,
+			expandTilde: (p: string) => p,
+			discoverAgents: () => ({ agents }),
+		});
+	}
+
+	async function readAsyncPayload(id: string): Promise<AsyncResultPayload> {
+		const resultPath = await waitForAsyncResultFile(id, 10_000);
+		return JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+	}
+
+	function launchProtocolTest(id: string): void {
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Exercise child protocol",
+			agentConfig: makeAgent("worker", { completionGuard: false }),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			sessionRoot: path.join(tempDir, "sessions"),
+			maxSubagentDepth: 2,
+			acceptance: false,
+		});
+	}
+
 	it("reports jiti availability as boolean", () => {
 		const result = isAsyncAvailable();
 		assert.equal(typeof result, "boolean");
 	});
 
+	it("background parses split UTF-8 JSON and a final unterminated protocol line", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		const line = Buffer.from(JSON.stringify(events.assistantMessage("你好 from fragmented async JSON")));
+		const unicodeStart = line.indexOf(Buffer.from("你"));
+		mockPi.onCall({ stdoutBase64Chunks: [line.subarray(0, unicodeStart + 1).toString("base64"), line.subarray(unicodeStart + 1).toString("base64")] });
+		const id = `async-protocol-utf8-${Date.now().toString(36)}`;
+		launchProtocolTest(id);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, true);
+		assert.equal(payload.results[0]?.output, "你好 from fragmented async JSON");
+	});
+
+	it("matches preflight launch digest in equivalent foreground and async execution", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		const agentName = `contract-worker-${Date.now().toString(36)}`;
+		const task = "Compare the resolved launch inputs.";
+		const turnBudget = { maxTurns: 2, graceTurns: 1 } as const;
+		const agentPath = path.join(tempDir, ".selesai", "agents", `${agentName}.md`);
+		fs.mkdirSync(path.dirname(agentPath), { recursive: true });
+		fs.writeFileSync(agentPath, `---\nname: ${agentName}\ndescription: Contract comparison worker\n---\n`, "utf-8");
+		const discovered = discoverAgents(tempDir).agents.find((agent) => agent.name === agentName);
+		assert.ok(discovered, "expected temporary agent definition to be discovered");
+		const preflight = await resolveSubagentLaunchContract({ agent: agentName, cwd: tempDir, task, turnBudget, runId: "contract-preflight" });
+		assert.equal(preflight.ok, true);
+
+		mockPi.onCall({ output: "foreground contract comparison" });
+		const foreground = await runSync(tempDir, [discovered], agentName, task, { runId: "contract-foreground", acceptance: false, turnBudget });
+		assert.equal(foreground.exitCode, 0);
+		assert.equal(foreground.launchContractDigest, preflight.contract.launchContractDigest);
+
+		mockPi.onCall({ output: "async contract comparison" });
+		const asyncId = `async-contract-equivalence-${Date.now().toString(36)}`;
+		const launch = executeAsyncSingle(asyncId, {
+			agent: agentName,
+			task,
+			agentConfig: discovered,
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			sessionRoot: path.join(tempDir, "sessions"),
+			maxSubagentDepth: 2,
+			acceptance: false,
+			turnBudget,
+		});
+		const payload = await readAsyncPayload(asyncId);
+		assert.equal(launch.details.launchContractDigest, preflight.contract.launchContractDigest);
+		assert.equal(payload.launchContractDigest, preflight.contract.launchContractDigest);
+		assert.equal(payload.results[0]?.launchContractDigest, preflight.contract.launchContractDigest);
+	});
+
+	it("persists the actual launch digest in async status and result metadata", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "digest-bound async done" });
+		const id = `async-launch-digest-${Date.now().toString(36)}`;
+		const launch = executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Exercise launch digest reporting",
+			agentConfig: makeAgent("worker", { completionGuard: false }),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			sessionRoot: path.join(tempDir, "sessions"),
+			maxSubagentDepth: 2,
+			acceptance: false,
+		});
+		assert.match(launch.details.launchContractDigest ?? "", /^[a-f0-9]{64}$/);
+		const payload = await readAsyncPayload(id);
+		const status = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf-8")) as AsyncStatusPayload;
+		assert.equal(payload.launchContractDigest, launch.details.launchContractDigest);
+		assert.equal(payload.results[0]?.launchContractDigest, launch.details.launchContractDigest);
+		assert.equal(status.launchContractDigest, launch.details.launchContractDigest);
+		assert.equal(status.steps?.[0]?.launchContractDigest, launch.details.launchContractDigest);
+	});
+
+	it("background fails with protocol_output_limit for an oversized stdout line", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ stdoutRaw: "x".repeat(MAX_CHILD_PENDING_LINE_BYTES + 1) });
+		const id = `async-protocol-limit-${Date.now().toString(36)}`;
+		launchProtocolTest(id);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, false);
+		assert.equal(payload.results[0]?.protocolError?.code, "protocol_output_limit");
+		assert.equal(payload.results[0]?.protocolError?.stream, "stdout");
+		assert.match(payload.results[0]?.error ?? "", /protocol_output_limit/);
+	});
+
+	it("routes async artifacts to the configured session directory", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		mockPi.onCall({ output: "async session artifact" });
+		const sessionFile = path.join(tempDir, "sessions", "parent-session", "session.jsonl");
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionFile = () => sessionFile;
+		const executor = makeAsyncExecutor([makeAgent("worker", { completionGuard: false })], { artifactDir: "session" });
+
+		const launch = await executor.execute(
+			"async-session-artifact-dir",
+			{ agent: "worker", task: "Write async session artifacts", async: true, runId: "async-session-artifacts", acceptance: false },
+			new AbortController().signal,
+			undefined,
+			ctx,
+		) as AsyncExecutionResult;
+
+		const expectedDir = path.join(path.dirname(sessionFile), "subagent-artifacts");
+		assert.equal(launch.isError, undefined);
+		assert.ok(launch.details.asyncId);
+		const descriptor = JSON.parse(fs.readFileSync(path.join(launch.details.asyncDir!, "recovery-descriptor.json"), "utf-8"));
+		assert.equal(descriptor.artifactsDir, expectedDir);
+		assert.equal(descriptor.artifactConfig.dir, "session");
+
+		const payload = await readAsyncPayload(launch.details.asyncId);
+		const outputPath = payload.results[0]?.artifactPaths?.outputPath;
+		assert.ok(outputPath?.startsWith(`${expectedDir}${path.sep}`));
+		assert.equal(fs.readFileSync(outputPath, "utf-8"), "async session artifact");
+		assert.equal(fs.existsSync(path.join(tempDir, ".pi-subagents", "artifacts")), false);
+	});
+
+	it("persists async capability ceiling audit to status, results, events, and metadata", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		mockPi.onCall({ output: "restricted async done" });
+		const sessionId = `session-capability-${Date.now().toString(36)}`;
+		const handle = registerSubagentCapabilityCeiling({ sessionId, ceiling: { allowedTools: ["read"], denyExtensions: true }, source: "test" });
+		try {
+			const executor = makeAsyncExecutor([makeAgent("worker", { tools: ["read", "write"], completionGuard: false })]);
+			const id = `async-capability-${Date.now().toString(36)}`;
+			const ctx = makeMinimalCtx(tempDir);
+			ctx.sessionManager.getSessionId = () => sessionId;
+			const launch = await executor.execute(
+				id,
+				{ agent: "worker", task: "Run with a restricted capability ceiling", async: true, runId: id, acceptance: false, artifacts: true },
+				new AbortController().signal,
+				undefined,
+				ctx,
+			) as AsyncExecutionResult;
+			assert.equal(launch.isError, undefined);
+			const asyncId = launch.details.asyncId;
+			assert.ok(asyncId);
+			const resultPath = await waitForAsyncResultFile(asyncId, 10_000);
+			const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+			const status = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, asyncId, "status.json"), "utf-8")) as AsyncStatusPayload;
+			assert.deepEqual(payload.capabilityCeiling, { version: 1, allowedTools: ["read"], denyExtensions: true, sources: ["test"] });
+			assert.deepEqual(payload.results[0]?.capabilityCeiling, payload.capabilityCeiling);
+			assert.deepEqual(status.capabilityCeiling, payload.capabilityCeiling);
+			assert.deepEqual(status.steps?.[0]?.capabilityCeiling, payload.capabilityCeiling);
+			assert.deepEqual(payload.capabilityAudit?.effectiveTools, ["read"]);
+			assert.deepEqual(payload.capabilityAudit?.removedTools, ["write", "intercom", "contact_supervisor"]);
+			assert.equal(payload.capabilityAudit?.extensionsDenied, true);
+			const events = fs.readFileSync(path.join(ASYNC_DIR, asyncId, "events.jsonl"), "utf-8").trim().split("\n").map((line) => JSON.parse(line));
+			assert.ok(events.some((event) => event.type === "subagent.capability-ceiling.applied" && event.stepIndex === 0 && event.capabilityAudit?.removedTools?.includes("write")));
+			const metadataPath = payload.results[0]?.artifactPaths?.metadataPath;
+			assert.ok(metadataPath);
+			const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf-8")) as { launchContractDigest?: string; capabilityCeiling?: unknown; capabilityAudit?: { removedTools?: string[] } };
+			assert.equal(metadata.launchContractDigest, payload.results[0]?.launchContractDigest);
+			assert.deepEqual(metadata.capabilityCeiling, payload.capabilityCeiling);
+			assert.deepEqual(metadata.capabilityAudit?.removedTools, ["write", "intercom", "contact_supervisor"]);
+		} finally {
+			handle.dispose();
+		}
+	});
+
+	it("background writes a failure stub to output artifacts when no output was produced", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "", stderr: "model unavailable", exitCode: 1 });
+		const id = `async-empty-failure-artifact-${Date.now().toString(36)}`;
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Fail before output",
+			agentConfig: makeAgent("worker", { completionGuard: false }),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: true, includeInput: true, includeOutput: true, includeJsonl: false, includeMetadata: true, cleanupDays: 7 },
+			artifactsDir: path.join(tempDir, ".pi-subagents", "artifacts"),
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+			acceptance: false,
+		});
+
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, false);
+		const outputPath = payload.results[0]?.artifactPaths?.outputPath;
+		assert.ok(outputPath, "should expose an output artifact path");
+		const artifact = fs.readFileSync(outputPath, "utf-8");
+		assert.match(artifact, /Subagent run failed before producing output\./);
+		assert.match(artifact, /Error:\nmodel unavailable/);
+		assert.match(artifact, /Transcript:/);
+		assert.match(artifact, /Metadata:/);
+	});
+
+	it("background keeps only a bounded UTF-8 stderr tail", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "failed", stderr: `${"x".repeat(MAX_CHILD_STDERR_BYTES + 1024)}终`, exitCode: 1 });
+		const id = `async-stderr-tail-${Date.now().toString(36)}`;
+		launchProtocolTest(id);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, false);
+		assert.ok(Buffer.byteLength(payload.results[0]?.error ?? "") <= MAX_CHILD_STDERR_BYTES);
+		assert.match(payload.results[0]?.error ?? "", /终$/);
+	});
+
+	it("background cancels final drain while agent_end reports a retry and waits for agent_settled", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ steps: [
+			{ jsonl: [events.assistantMessage("retrying async response"), { type: "agent_end", willRetry: true }] },
+			{ delay: 1400, jsonl: [events.assistantMessage("settled async response"), { type: "agent_end", willRetry: false }, { type: "agent_settled" }] },
+		] });
+		const id = `async-lifecycle-retry-${Date.now().toString(36)}`;
+		const startedAt = Date.now();
+		launchProtocolTest(id);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, true);
+		assert.equal(payload.results[0]?.output, "settled async response");
+		assert.ok(Date.now() - startedAt >= 1200, "background runner must not terminate during the retry delay");
+	});
+
+	it("background treats agent_settled as a clean terminal watermark", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ jsonl: [mockAssistantMessage("settled async without a terminal assistant stop", "tool_use"), { type: "agent_settled" }], keepAliveAfterFinalMessageMs: 5000 });
+		const id = `async-lifecycle-settled-${Date.now().toString(36)}`;
+		const startedAt = Date.now();
+		launchProtocolTest(id);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, true);
+		assert.equal(payload.results[0]?.error, undefined);
+		assert.equal(payload.results[0]?.output, "settled async without a terminal assistant stop");
+		assert.ok(Date.now() - startedAt < 4000, "agent_settled should trigger bounded child cleanup");
+	});
+
+	it("keeps named output references literal in async single tasks", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		const task = "Reply with OK. You may reference {outputs.name} if it helps.";
+		mockPi.onCall({ output: "OK" });
+		const id = `async-single-literal-output-ref-${Date.now().toString(36)}`;
+		const result = executeAsyncSingle(id, {
+			agent: "worker",
+			task,
+			agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: {
+				enabled: false,
+				includeInput: false,
+				includeOutput: false,
+				includeJsonl: false,
+				includeMetadata: false,
+				cleanupDays: 7,
+			},
+			shareEnabled: false,
+			sessionRoot: path.join(tempDir, "sessions"),
+			maxSubagentDepth: 2,
+		});
+
+		assert.equal(result.isError, undefined);
+		const call = await waitForMockPiCall(mockPi, 0, 10_000);
+		assert.match(call.args.at(-1) ?? "", /\{outputs\.name\}/);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, true);
+		assert.equal(payload.results[0]?.output, "OK");
+	});
+
 	it("spawns the async runner with node when process.execPath is not node", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		const originalExecPath = process.execPath;
 		process.execPath = path.join(tempDir, process.platform === "win32" ? "pi.exe" : "pi");
@@ -302,7 +694,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			});
 
 			assert.equal(result.isError, undefined);
-			const resultPath = await waitForAsyncResultFile(id, 10_000);
+			const resultPath = await waitForAsyncResultFile(id, 30_000);
 			const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
 			assert.equal(payload.success, true);
 			assert.equal(payload.results[0]?.output, "non-node exec async done");
@@ -469,7 +861,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 	it("hard-kills async children that ignore timeout SIGTERM", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({ delay: 60_000, ignoreSigterm: true, output: "too late" });
 		const id = `async-timeout-hard-kill-${Date.now().toString(36)}`;
-		const timeoutMs = 1_500;
+		const timeoutMs = process.platform === "win32" ? 5_000 : 1_500;
 		const startedAt = Date.now();
 		executeAsyncSingle(id, {
 			agent: "stubborn",
@@ -490,7 +882,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		});
 
 		await waitForMockPiCall(mockPi, 0, 10_000);
-		const resultPath = await waitForAsyncResultFile(id, 8_000);
+		const resultPath = await waitForAsyncResultFile(id, 10_000);
 		const elapsedMs = Date.now() - startedAt;
 		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
 		const status = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf-8")) as AsyncStatusPayload;
@@ -500,13 +892,14 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(payload.results[0]?.error, `Subagent timed out after ${timeoutMs}ms.`);
 		assert.equal(status.timedOut, true);
 		assert.equal(status.steps?.[0]?.timedOut, true);
-		assert.ok(elapsedMs < 7_000, `timeout result should settle after hard kill, elapsed ${elapsedMs}ms`);
+		assert.ok(elapsedMs < timeoutMs + 4_000, `timeout result should settle after hard kill, elapsed ${elapsedMs}ms`);
 		assert.equal(mockPi.callCount(), 1);
 	});
 
 	it("cancels async acceptance verification when the run times out", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({ output: "implementation complete" });
 		const id = `async-timeout-acceptance-${Date.now().toString(36)}`;
+		const timeoutMs = 1_000;
 		const startedAt = Date.now();
 		executeAsyncSingle(id, {
 			agent: "worker",
@@ -514,19 +907,20 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			agentConfig: makeAgent("worker"),
 			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
 			artifactConfig: {
-				enabled: false,
+				enabled: true,
 				includeInput: false,
 				includeOutput: false,
 				includeJsonl: false,
-				includeMetadata: false,
+				includeMetadata: true,
 				cleanupDays: 7,
 			},
+			artifactsDir: path.join(tempDir, ".pi-subagents", "artifacts"),
 			shareEnabled: false,
 			maxSubagentDepth: 2,
-			timeoutMs: 1_000,
+			timeoutMs,
 			acceptance: {
 				level: "verified",
-				verify: [{ id: "slow", command: `${process.execPath} -e "setTimeout(()=>process.exit(0), 5000)"`, timeoutMs: 10_000 }],
+				verify: [{ id: "slow", command: `${process.execPath} -e "setTimeout(()=>process.exit(0), 30000)"`, timeoutMs: 60_000 }],
 			},
 		});
 
@@ -537,9 +931,15 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(payload.state, "failed");
 		assert.equal(payload.timedOut, true);
 		assert.equal(payload.results[0]?.timedOut, true);
-		assert.equal(payload.results[0]?.acceptance, undefined);
+		assert.equal(payload.results[0]?.acceptance?.status, "rejected");
+		assert.equal(payload.results[0]?.acceptance?.runtimeChecks?.[0]?.id, "timeout");
 		assert.equal(status.steps?.[0]?.timedOut, true);
-		assert.ok(elapsedMs < 3_000, `timeout should cancel acceptance verification promptly, elapsed ${elapsedMs}ms`);
+		const metadataPath = payload.results[0]?.artifactPaths?.metadataPath;
+		assert.ok(metadataPath);
+		const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf-8")) as { acceptance?: { status?: string; runtimeChecks?: Array<{ id?: string }> } };
+		assert.equal(metadata.acceptance?.status, "rejected");
+		assert.equal(metadata.acceptance?.runtimeChecks?.[0]?.id, "timeout");
+		assert.ok(elapsedMs < timeoutMs + 4_000, `timeout should cancel acceptance verification well before the verify command completes, elapsed ${elapsedMs}ms`);
 	});
 
 	it("async turn budget allows a terminal final grace turn", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
@@ -580,11 +980,12 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(status.steps?.[0]?.turnBudget?.turnCount, 2);
 	});
 
-	it("async turn budget hard-aborts a non-terminal final grace turn", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+	it("async turn budget hard-aborts beyond the final grace turn at a safe assistant boundary", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({
 			jsonl: [
 				mockAssistantMessage("working before wrap-up", "tool_use"),
-				mockAssistantMessage("still starting more tool work", "tool_use"),
+				mockAssistantMessage("starting final grace tool work", "tool_use"),
+				mockAssistantMessage("safe assistant boundary after tool work", "stop"),
 			],
 		});
 		const id = `async-turn-budget-hard-${Date.now().toString(36)}`;
@@ -608,17 +1009,153 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(payload.turnBudgetExceeded, true);
 		assert.equal(payload.wrapUpRequested, true);
 		assert.equal(payload.turnBudget?.outcome, "exceeded");
-		assert.equal(payload.turnBudget?.turnCount, 2);
-		assert.equal(payload.turnBudget?.exceededAtTurn, 2);
+		assert.equal(payload.turnBudget?.turnCount, 3);
+		assert.equal(payload.turnBudget?.exceededAtTurn, 3);
 		assert.equal(payload.results[0]?.turnBudgetExceeded, true);
 		assert.match(payload.results[0]?.output ?? "", /Partial output before turn-budget abort:/);
-		assert.match(payload.results[0]?.output ?? "", /still starting more tool work/);
+		assert.match(payload.results[0]?.output ?? "", /safe assistant boundary after tool work/);
 		assert.equal(status.state, "failed");
 		assert.equal(status.turnBudgetExceeded, true);
 		assert.equal(status.steps?.[0]?.turnBudgetExceeded, true);
 		assert.equal(status.steps?.[0]?.turnBudget?.outcome, "exceeded");
 	});
 
+	it("defers an async hard turn limit through active tool work and aborts at the next assistant boundary", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({
+			steps: [
+				{
+					jsonl: [
+						mockAssistantMessage("starting required tool work", "tool_use"),
+						events.toolStart("bash", { command: "node build.mjs" }),
+					],
+				},
+				{
+					delay: 750,
+					jsonl: [
+						events.toolResult("bash", "build completed"),
+						events.toolEnd("bash"),
+						mockAssistantMessage("safe assistant boundary reached", "stop"),
+					],
+				},
+			],
+		});
+		const id = `async-turn-budget-deferred-${Date.now().toString(36)}`;
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Finish active tool work before enforcing the hard limit.",
+			agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+			turnBudget: { maxTurns: 1, graceTurns: 0 },
+		});
+
+		const pending = await waitForDeferredTurnBudget(id);
+		assert.equal(pending.error, undefined);
+		assert.equal(pending.turnBudgetExceeded, undefined);
+		assert.equal(pending.turnBudget?.terminationDeferredAtTurn, 1);
+		assert.equal(pending.steps?.[0]?.status, "running");
+		assert.equal(pending.steps?.[0]?.turnBudgetExceeded, undefined);
+
+		const resultPath = await waitForAsyncResultFile(id, 10_000);
+		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+		const status = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf-8")) as AsyncStatusPayload;
+		assert.equal(payload.state, "failed");
+		assert.equal(payload.turnBudgetExceeded, true);
+		assert.equal(payload.turnBudget?.outcome, "exceeded");
+		assert.equal(payload.turnBudget?.turnCount, 2);
+		assert.equal(payload.results[0]?.turnBudgetExceeded, true);
+		assert.match(payload.results[0]?.output ?? "", /safe assistant boundary reached/);
+		assert.equal(status.state, "failed");
+		assert.equal(status.turnBudgetExceeded, true);
+		assert.equal(status.steps?.[0]?.turnBudget?.outcome, "exceeded");
+	});
+
+	it("lets timeout delivery preempt deferred turn-budget termination", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({
+			steps: [
+				{
+					jsonl: [
+						mockAssistantMessage("starting long tool work", "tool_use"),
+						events.toolStart("bash", { command: "node build.mjs" }),
+					],
+				},
+				{ delay: 5_000, jsonl: [events.toolEnd("bash")] },
+			],
+		});
+		const id = `async-turn-budget-timeout-${Date.now().toString(36)}`;
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Timeout while hard termination is deferred.",
+			agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+			turnBudget: { maxTurns: 1, graceTurns: 0 },
+			timeoutMs: 30_000,
+		});
+
+		const pending = await waitForDeferredTurnBudget(id);
+		const asyncDir = path.join(ASYNC_DIR, id);
+		deliverTimeoutRequest({ asyncDir, pid: pending.pid, source: "test" });
+		const resultPath = await waitForAsyncResultFile(id, 10_000);
+		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+		const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatusPayload;
+		assert.equal(payload.state, "failed");
+		assert.equal(payload.timedOut, true);
+		assert.equal(payload.turnBudgetExceeded, undefined);
+		assert.match(payload.error ?? payload.summary ?? "", /timed out after 30000ms/);
+		assert.equal(payload.results[0]?.timedOut, true);
+		assert.equal(payload.results[0]?.turnBudgetExceeded, undefined);
+		assert.equal(status.timedOut, true);
+		assert.equal(status.turnBudgetExceeded, undefined);
+		assert.equal(status.steps?.[0]?.timedOut, true);
+	});
+
+	it("lets explicit stop preempt deferred turn-budget termination", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({
+			steps: [
+				{
+					jsonl: [
+						mockAssistantMessage("starting long tool work", "tool_use"),
+						events.toolStart("bash", { command: "node build.mjs" }),
+					],
+				},
+				{ delay: 5_000, jsonl: [events.toolEnd("bash")] },
+			],
+		});
+		const id = `async-turn-budget-stop-${Date.now().toString(36)}`;
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Stop while hard termination is deferred.",
+			agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+			turnBudget: { maxTurns: 1, graceTurns: 0 },
+		});
+
+		const pending = await waitForDeferredTurnBudget(id);
+		const asyncDir = path.join(ASYNC_DIR, id);
+		deliverStopRequest({ asyncDir, pid: pending.pid, source: "test" });
+		const resultPath = await waitForAsyncResultFile(id, 10_000);
+		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+		const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatusPayload;
+		assert.equal(payload.state, "stopped");
+		assert.equal(payload.stopped, true);
+		assert.equal(payload.turnBudgetExceeded, undefined);
+		assert.match(payload.error ?? payload.summary ?? "", /stopped by user/i);
+		assert.equal(payload.results[0]?.stopped, true);
+		assert.equal(payload.results[0]?.turnBudgetExceeded, undefined);
+		assert.equal(status.state, "stopped");
+		assert.equal(status.stopped, true);
+		assert.equal(status.turnBudgetExceeded, undefined);
+		assert.equal(status.steps?.[0]?.status, "stopped");
+	});
+
 	it("async launch messages tell the parent not to sleep-poll", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		const artifactConfig = {
 			enabled: false,
@@ -628,26 +1165,56 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			includeMetadata: false,
 			cleanupDays: 7,
 		};
+		const emitted: Array<{ channel: string; data: unknown }> = [];
 		const commonParams = {
-			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			ctx: {
+				pi: { events: { emit(channel: string, data: unknown) { emitted.push({ channel, data }); } } },
+				cwd: tempDir,
+				currentSessionId: "session-1",
+			},
 			artifactConfig,
 			shareEnabled: false,
 			maxSubagentDepth: 2,
 		};
+		const startedEvent = (id: string): { task?: string; goal?: string } => {
+			const event = emitted.find((entry) => entry.channel === SUBAGENT_ASYNC_STARTED_EVENT && (entry.data as { id?: string }).id === id);
+			assert.ok(event, `missing async-started event for ${id}`);
+			return event.data as { task?: string; goal?: string };
+		};
 		mockPi.onCall({ output: "single done" });
 		const singleId = `async-handoff-single-${Date.now().toString(36)}`;
+		const wrappedTask = `Fork preamble: ${"execution ".repeat(20)}`;
+		const rawGoal = `Caller-facing goal: ${"raw ".repeat(40)}`;
 		const singleResult = executeAsyncSingle(singleId, {
 			agent: "worker",
-			task: "Do work",
+			task: wrappedTask,
+			goal: rawGoal,
 			agentConfig: makeAgent("worker"),
 			...commonParams,
 		});
 		assert.match(singleResult.content[0]?.text ?? "", /Async: worker \[/);
 		assert.match(singleResult.content[0]?.text ?? "", /Do not run sleep timers or polling loops/);
-		assert.match(singleResult.content[0]?.text ?? "", /call wait\(\)/);
-		assert.match(singleResult.content[0]?.text ?? "", /there is no next turn, so use wait\(\)/);
+		assert.match(singleResult.content[0]?.text ?? "", /call subagent_wait\(\)/i);
+		assert.match(singleResult.content[0]?.text ?? "", /non-interactive run: Pi auto-drains current-session background work at agent_end/);
+		assert.equal(startedEvent(singleId).task, wrappedTask.slice(0, 50));
+		assert.equal(startedEvent(singleId).goal, rawGoal.slice(0, 120));
 		await waitForAsyncResultFile(singleId, 30_000);
 
+		mockPi.onCall({ output: "interactive done" });
+		const interactiveId = `async-handoff-interactive-${Date.now().toString(36)}`;
+		const interactiveResult = executeAsyncSingle(interactiveId, {
+			agent: "worker",
+			task: "Interactive handoff",
+			agentConfig: makeAgent("worker"),
+			...commonParams,
+			ctx: { ...commonParams.ctx, interactive: true },
+		});
+		assert.match(interactiveResult.content[0]?.text ?? "", /interactive session/);
+		assert.match(interactiveResult.content[0]?.text ?? "", /return control to the user/);
+		assert.match(interactiveResult.content[0]?.text ?? "", /Do NOT call subagent_wait\(\) merely to wait/);
+		assert.doesNotMatch(interactiveResult.content[0]?.text ?? "", /auto-drain/);
+		await waitForAsyncResultFile(interactiveId, 30_000);
+
 		mockPi.onCall({ output: "parallel one done" });
 		mockPi.onCall({ output: "parallel two done" });
 		const parallelId = `async-handoff-parallel-${Date.now().toString(36)}`;
@@ -659,7 +1226,8 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		});
 		assert.match(parallelResult.content[0]?.text ?? "", /Async parallel:/);
 		assert.match(parallelResult.content[0]?.text ?? "", /Do not run sleep timers or polling loops/);
-		assert.match(parallelResult.content[0]?.text ?? "", /call wait\(\)/);
+		assert.match(parallelResult.content[0]?.text ?? "", /call subagent_wait\(\)/i);
+		assert.equal(startedEvent(parallelId).goal, "Do one");
 		const parallelResultPath = await waitForAsyncResultFile(parallelId, 10_000);
 		const parallelPayload = JSON.parse(fs.readFileSync(parallelResultPath, "utf-8")) as { agent?: string; mode?: string };
 		assert.equal(parallelPayload.mode, "parallel");
@@ -667,16 +1235,110 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 
 		mockPi.onCall({ output: "chain done" });
 		const chainId = `async-handoff-chain-${Date.now().toString(36)}`;
+		const chainGoal = `Coordinate the complete workflow ${"goal ".repeat(30)}`;
+		const chainChildTask = `Do chained work ${"child ".repeat(15)}`;
 		const chainResult = executeAsyncChain(chainId, {
-			chain: [{ agent: "worker", task: "Do chained work" }],
+			task: chainGoal,
+			chain: [{ agent: "worker", task: chainChildTask }],
 			agents: [makeAgent("worker")],
 			...commonParams,
 		});
 		assert.match(chainResult.content[0]?.text ?? "", /Async chain:/);
 		assert.match(chainResult.content[0]?.text ?? "", /Do not run sleep timers or polling loops/);
+		const chainEvent = startedEvent(chainId);
+		assert.equal(chainEvent.task, chainChildTask.slice(0, 50));
+		assert.equal(chainEvent.goal, chainGoal.slice(0, 120));
 		await waitForAsyncResultFile(chainId, 10_000);
 	});
 
+	it("fails background chains when requested extension tools are unavailable", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "Model incorrectly claimed success", missingTools: ["fixture_search"] });
+		const id = `async-missing-extension-tool-${Date.now().toString(36)}`;
+
+		executeAsyncChain(id, {
+			chain: [{ agent: "extension-worker", task: "Use fixture search" }],
+			agents: [makeAgent("extension-worker", { tools: ["read", "fixture_search"] })],
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		const resultPath = await waitForAsyncResultFile(id, 10_000);
+		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+		assert.equal(payload.success, false);
+		assert.equal(payload.state, "failed");
+		assert.match(payload.results[0]?.error ?? "", /requested unavailable child tools: fixture_search/);
+		assert.match(payload.results[0]?.error ?? "", /subagentOnlyExtensions/);
+	});
+
+	it("applies agent acceptance roles to inferred async acceptance", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		mockPi.onCall({ output: "exploration complete" });
+		const executor = makeAsyncExecutor([makeAgent("worker", { acceptanceRole: "read-only" })]);
+
+		const result = await executor.execute(
+			"async-agent-acceptance-role",
+			{ agent: "worker", task: "Explore the authentication flow", async: true, clarify: false },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		const asyncId = result.details?.asyncId;
+		assert.ok(asyncId, "expected asyncId");
+		const payload = await readAsyncPayload(asyncId);
+		assert.equal(payload.results[0]?.acceptance?.effectiveAcceptance.level, "attested");
+	});
+
+	it("applies agent acceptance roles to inferred async parallel acceptance", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		mockPi.onCall({ output: "parallel exploration complete" });
+		const executor = makeAsyncExecutor([makeAgent("worker", { acceptanceRole: "read-only" })]);
+
+		const result = await executor.execute(
+			"async-parallel-agent-acceptance-role",
+			{ tasks: [{ agent: "worker", task: "Explore the authentication flow" }], async: true, clarify: false },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		const asyncId = result.details?.asyncId;
+		assert.ok(asyncId, "expected asyncId");
+		const payload = await readAsyncPayload(asyncId);
+		assert.equal(payload.results[0]?.acceptance?.effectiveAcceptance.level, "attested");
+	});
+
+	it("infers async chain acceptance after expanding top-level task templates", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "patched" });
+		mockPi.onCall({ output: "reviewed" });
+
+		const patchId = `async-role-task-template-patch-${Date.now().toString(36)}`;
+		executeAsyncChain(patchId, {
+			task: "Patch src/auth.ts",
+			chain: [{ agent: "explorer", task: "{task}" }],
+			agents: [makeAgent("explorer", { acceptanceRole: "read-only" })],
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-role-task-patch" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+		const patchPayload = await readAsyncPayload(patchId);
+		assert.equal(patchPayload.results[0]?.acceptance?.effectiveAcceptance?.level, "checked");
+
+		const reviewId = `async-role-task-template-review-${Date.now().toString(36)}`;
+		executeAsyncChain(reviewId, {
+			task: "Review only; do not edit files",
+			chain: [{ agent: "implementer", task: "{task}" }],
+			agents: [makeAgent("implementer", { acceptanceRole: "writer" })],
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-role-task-review" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+		const reviewPayload = await readAsyncPayload(reviewId);
+		assert.equal(reviewPayload.results[0]?.acceptance?.effectiveAcceptance?.level, "attested");
+	});
+
 	it("top-level async parallel conversion preserves output, reads, and progress", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
 		mockPi.onCall({ output: "Async top-level report" });
 		const executor = createSubagentExecutor!({
@@ -714,11 +1376,13 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 
 		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
 		const status = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as AsyncStatusPayload;
-			assert.equal(payload.mode, "parallel");
-			assert.equal(payload.sessionId, "session-123");
-			assert.equal(payload.results[0]?.acceptance?.status, "checked");
-			assert.equal(status.sessionId, "session-123");
-			assert.equal(status.steps?.[0]?.acceptance?.status, "checked");
+		assert.equal(payload.mode, "parallel");
+		assert.equal(payload.sessionId, "session-123");
+		assert.equal(payload.results[0]?.acceptance?.status, "review-required");
+		assert.equal(payload.results[0]?.acceptance?.evidenceStatus, "checked");
+		assert.equal(status.sessionId, "session-123");
+		assert.equal(status.steps?.[0]?.acceptance?.status, "review-required");
+		assert.equal(status.steps?.[0]?.acceptance?.evidenceStatus, "checked");
 		const outputPath = path.join(tempDir, ".pi-subagents", "artifacts", "outputs", asyncId, "async-top-output.md");
 		const outputDeadline = Date.now() + 5_000;
 		while (!fs.existsSync(outputPath)) {
@@ -740,7 +1404,141 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(fs.existsSync(path.join(tempDir, "progress.md")), false);
 	});
 
-	it("async single rejects explicit reviewed acceptance without a reviewer result", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+	for (const outputOverride of [undefined, true] as const) {
+		it(`async top-level parallel isolates inherited output (${outputOverride === true ? "output:true" : "omitted output"})`, { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+			mockPi.onCall({ matchArgIncludes: "Write the first report", output: "first async report" });
+			mockPi.onCall({ matchArgIncludes: "Write the second report", output: "second async report" });
+			const agent = makeAgent("worker", { output: "context.md", tools: ["read", "grep", "find", "ls"] });
+			const executor = makeAsyncExecutor([agent]);
+			const tasks = [
+				{ agent: "worker", task: "Write the first report", ...(outputOverride !== undefined ? { output: outputOverride } : {}) },
+				{ agent: "worker", task: "Write the second report", ...(outputOverride !== undefined ? { output: outputOverride } : {}) },
+			];
+			const launch = await executor.execute(
+				`async-inherited-output-${outputOverride === true ? "true" : "omitted"}`,
+				{ tasks, async: true, clarify: false },
+				new AbortController().signal,
+				undefined,
+				makeMinimalCtx(tempDir),
+			);
+
+			assert.equal(launch.isError, undefined);
+			const payload = await readAsyncPayload(launch.details?.asyncId as string);
+			assert.equal(payload.success, true);
+			assert.equal(payload.results[0]?.output?.split("\n\nOutput saved to:")[0], "first async report");
+			assert.equal(payload.results[1]?.output?.split("\n\nOutput saved to:")[0], "second async report");
+			const outputDir = path.join(tempDir, ".pi-subagents", "artifacts", "outputs", launch.details?.asyncId as string);
+			const authoritativePaths = [
+				path.join(outputDir, "parallel-0", "0-worker", "context.md"),
+				path.join(outputDir, "parallel-0", "1-worker", "context.md"),
+			];
+			assert.equal(fs.readFileSync(authoritativePaths[0]!, "utf-8"), "first async report");
+			assert.equal(fs.readFileSync(authoritativePaths[1]!, "utf-8"), "second async report");
+			const artifactPaths = payload.results.map((result) => result.artifactPaths?.outputPath);
+			assert.ok(artifactPaths[0] && artifactPaths[1]);
+			assert.notEqual(artifactPaths[0], artifactPaths[1]);
+			assert.equal(fs.readFileSync(artifactPaths[0], "utf-8"), "first async report");
+			assert.equal(fs.readFileSync(artifactPaths[1], "utf-8"), "second async report");
+			const calls = fs.readdirSync(mockPi.dir).filter((name) => name.startsWith("call-")).sort();
+			const taskArgs = calls.map((name) => (JSON.parse(fs.readFileSync(path.join(mockPi.dir, name), "utf-8")) as MockPiCallRecord).args?.at(-1) ?? "");
+			const firstTask = taskArgs.find((task) => task.includes("Write the first report")) ?? "";
+			const secondTask = taskArgs.find((task) => task.includes("Write the second report")) ?? "";
+			assert.ok(firstTask.includes(path.join("parallel-0", "0-worker", "context.md")));
+			assert.ok(secondTask.includes(path.join("parallel-0", "1-worker", "context.md")));
+			for (const taskArg of [firstTask, secondTask]) {
+				assert.match(taskArg, /Return the complete artifact in your final response\./);
+				assert.match(taskArg, /Do not call contact_supervisor merely because no write-capable tool is available\./);
+				assert.doesNotMatch(taskArg, /Write your findings to exactly this path/);
+			}
+		});
+	}
+
+	it("async top-level parallel rejects duplicate explicit output paths before spawning", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		const executor = makeAsyncExecutor([makeAgent("worker")]);
+		const result = await executor.execute(
+			"async-duplicate-output",
+			{
+				tasks: [
+					{ agent: "worker", task: "Write A", output: "same.md" },
+					{ agent: "worker", task: "Write B", output: "same.md" },
+				],
+				async: true,
+				clarify: false,
+			},
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /Parallel tasks 1 \(worker\) and 2 \(worker\).*same\.md/);
+		assert.equal(mockPi.callCount(), 0);
+	});
+
+	it("async top-level parallel preserves distinct explicit output destinations", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		mockPi.onCall({ matchArgIncludes: "first.md", output: "first explicit report" });
+		mockPi.onCall({ matchArgIncludes: "second.md", output: "second explicit report" });
+		const executor = makeAsyncExecutor([makeAgent("worker", { output: "context.md" })]);
+		const launch = await executor.execute(
+			"async-distinct-explicit-output",
+			{
+				tasks: [
+					{ agent: "worker", task: "Write A", output: "first.md" },
+					{ agent: "worker", task: "Write B", output: "second.md" },
+				],
+				async: true,
+				clarify: false,
+			},
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		const payload = await readAsyncPayload(launch.details?.asyncId as string);
+		assert.equal(payload.success, true);
+		const outputDir = path.join(tempDir, ".pi-subagents", "artifacts", "outputs", launch.details?.asyncId as string);
+		assert.equal(fs.readFileSync(path.join(outputDir, "first.md"), "utf-8"), "first explicit report");
+		assert.equal(fs.readFileSync(path.join(outputDir, "second.md"), "utf-8"), "second explicit report");
+		assert.ok(payload.results[0]?.artifactPaths?.outputPath?.endsWith("_worker_0_output.md"));
+		assert.ok(payload.results[1]?.artifactPaths?.outputPath?.endsWith("_worker_1_output.md"));
+	});
+
+	it("async chain static parallel namespaces inherited default outputs", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ matchArgIncludes: "Write first", output: "chain first report" });
+		mockPi.onCall({ matchArgIncludes: "Write second", output: "chain second report" });
+		const id = `async-chain-parallel-output-${Date.now().toString(36)}`;
+		const launch = executeAsyncChain(id, {
+			chain: [{ parallel: [{ agent: "worker", task: "Write first" }, { agent: "worker", task: "Write second" }] }],
+			agents: [makeAgent("worker", { output: "context.md" })],
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-chain-output" },
+			artifactConfig: { enabled: true, includeInput: false, includeOutput: true, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			artifactsDir: path.join(tempDir, ".pi-subagents", "artifacts"),
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		assert.equal(launch.isError, undefined);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, true);
+		const outputDir = path.join(tempDir, ".pi-subagents", "artifacts", "outputs", id);
+		const authoritativePaths = [
+			path.join(outputDir, "parallel-0", "0-worker", "context.md"),
+			path.join(outputDir, "parallel-0", "1-worker", "context.md"),
+		];
+		assert.equal(fs.readFileSync(authoritativePaths[0]!, "utf-8"), "chain first report");
+		assert.equal(fs.readFileSync(authoritativePaths[1]!, "utf-8"), "chain second report");
+		const artifactPaths = payload.results.map((result) => result.artifactPaths?.outputPath);
+		assert.ok(artifactPaths[0] && artifactPaths[1]);
+		assert.notEqual(artifactPaths[0], artifactPaths[1]);
+		assert.equal(fs.readFileSync(artifactPaths[0], "utf-8"), "chain first report");
+		assert.equal(fs.readFileSync(artifactPaths[1], "utf-8"), "chain second report");
+		const calls = fs.readdirSync(mockPi.dir).filter((name) => name.startsWith("call-")).sort();
+		const taskArgs = calls.map((name) => (JSON.parse(fs.readFileSync(path.join(mockPi.dir, name), "utf-8")) as MockPiCallRecord).args?.at(-1) ?? "");
+		assert.ok(taskArgs.find((task) => task.includes("Write first"))?.includes(path.join("parallel-0", "0-worker", "context.md")));
+		assert.ok(taskArgs.find((task) => task.includes("Write second"))?.includes(path.join("parallel-0", "1-worker", "context.md")));
+	});
+
+	it("async single preserves checked evidence while independent review is pending", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({
 			output: [
 				"implemented",
@@ -775,17 +1573,18 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			artifactConfig,
 			shareEnabled: false,
 			maxSubagentDepth: 2,
-			acceptance: { level: "reviewed", criteria: ["Patch bug"], review: false },
+			acceptance: { level: "checked", criteria: ["Patch bug"], review: { agent: "reviewer", required: true } },
 		});
 		const resultPath = await waitForAsyncResultFile(id, 10_000);
 		const result = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
 		const status = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf-8")) as AsyncStatusPayload;
 
-		assert.equal(result.success, false);
-		assert.equal(result.results[0]?.acceptance?.status, "rejected");
+		assert.equal(result.success, true);
+		assert.equal(result.results[0]?.acceptance?.status, "review-required");
+		assert.equal(result.results[0]?.acceptance?.evidenceStatus, "checked");
 		assert.ok(result.results[0]?.acceptance?.childReport);
-		assert.equal(result.results[0]?.acceptance?.reviewResult?.status, "needs-parent-decision");
-		assert.equal(status.steps?.[0]?.acceptance?.status, "rejected");
+		assert.equal(result.results[0]?.acceptance?.reviewResult?.status, "review-required");
+		assert.equal(status.steps?.[0]?.acceptance?.status, "review-required");
 	});
 
 	it("top-level async chain suppresses progress for {task} review-only tasks", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
@@ -1002,8 +1801,8 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 
 	it("async chains expand dynamic fanout and persist collected output", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({ output: "targets", structuredOutput: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] } });
-		mockPi.onCall({ output: "review-a", structuredOutput: { ok: "a" } });
-		mockPi.onCall({ output: "review-b", structuredOutput: { ok: "b" } });
+		mockPi.onCall({ matchArgIncludes: "Review src/a.ts", output: "review-a", structuredOutput: { ok: "a" } });
+		mockPi.onCall({ matchArgIncludes: "Review src/b.ts", output: "review-b", structuredOutput: { ok: "b" } });
 		mockPi.onCall({ output: "used reviews" });
 		const id = `async-dynamic-chain-${Date.now().toString(36)}`;
 		const result = executeAsyncChain(id, {
@@ -1022,9 +1821,10 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 				},
 				{ agent: "consumer", task: "Use {outputs.reviews}" },
 			],
-			agents: [makeAgent("producer"), makeAgent("reviewer"), makeAgent("consumer")],
+			agents: [makeAgent("producer"), makeAgent("reviewer", { output: "context.md" }), makeAgent("consumer")],
 			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-dynamic" },
-			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			artifactConfig: { enabled: true, includeInput: false, includeOutput: true, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			artifactsDir: path.join(tempDir, ".pi-subagents", "artifacts"),
 			shareEnabled: false,
 			maxSubagentDepth: 2,
 		});
@@ -1041,6 +1841,20 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		const collected = payload.outputs?.reviews?.structured as Array<{ key: string; structured: unknown }>;
 		assert.deepEqual(collected.map((item) => item.key), ["src/a.ts", "src/b.ts"]);
 		assert.deepEqual(collected.map((item) => item.structured), [{ ok: "a" }, { ok: "b" }]);
+		const outputDir = path.join(tempDir, ".pi-subagents", "artifacts", "outputs", id);
+		const dynamicOutputPaths = [
+			path.join(outputDir, "dynamic-1", "0-reviewer", "context.md"),
+			path.join(outputDir, "dynamic-1", "1-reviewer", "context.md"),
+		];
+		assert.equal(fs.readFileSync(dynamicOutputPaths[0]!, "utf-8"), "review-a");
+		assert.equal(fs.readFileSync(dynamicOutputPaths[1]!, "utf-8"), "review-b");
+		const reviewerArtifacts = payload.results.slice(1, 3).map((result) => result.artifactPaths?.outputPath);
+		assert.ok(reviewerArtifacts[0] && reviewerArtifacts[1]);
+		assert.notEqual(reviewerArtifacts[0], reviewerArtifacts[1]);
+		assert.equal(fs.readFileSync(reviewerArtifacts[0], "utf-8"), "review-a");
+		assert.equal(fs.readFileSync(reviewerArtifacts[1], "utf-8"), "review-b");
+		assert.match(readMockPiArgs(mockPi, 1).at(-1) ?? "", new RegExp(dynamicOutputPaths[0]!.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+		assert.match(readMockPiArgs(mockPi, 2).at(-1) ?? "", new RegExp(dynamicOutputPaths[1]!.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
 		assert.equal(status.steps?.length, 4);
 		assert.deepEqual(status.parallelGroups, [{ start: 1, count: 2, stepIndex: 1 }]);
 		assert.equal(payload.workflowGraph?.nodes?.[1]?.kind, "dynamic-parallel-group");
@@ -1048,6 +1862,35 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(payload.workflowGraph?.nodes?.[2]?.flatIndex, 3);
 	});
 
+	it("rejects a shared explicit output before dynamic fanout children start", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ matchArgIncludes: "Produce targets", output: "targets", structuredOutput: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] } });
+		const id = `async-dynamic-explicit-output-${Date.now().toString(36)}`;
+		const launch = executeAsyncChain(id, {
+			chain: [
+				{ agent: "producer", task: "Produce targets", as: "targets", outputSchema: { type: "object" } },
+				{
+					expand: { from: { output: "targets", path: "/items" }, item: "target", maxItems: 2 },
+					parallel: { agent: "reviewer", task: "Review {target.path}", output: "shared.md" },
+					collect: { as: "reviews" },
+					concurrency: 2,
+				},
+			],
+			agents: [makeAgent("producer"), makeAgent("reviewer")],
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-dynamic-explicit-output" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		assert.equal(launch.isError, undefined);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, false);
+		const error = payload.results.find((result) => result.error)?.error ?? "";
+		assert.match(error, /materialized 2 items that resolve output to the same path/);
+		assert.match(error, /shared\.md/);
+		assert.equal(mockPi.callCount(), 1);
+	});
+
 	it("async dynamic fanout applies fork session files and thinking overrides to materialized children", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({ output: "targets", structuredOutput: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] } });
 		mockPi.onCall({ output: "review-a", structuredOutput: { ok: "a" } });
@@ -1094,6 +1937,97 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.deepEqual(status.steps?.slice(1).map((step) => step.thinking), ["off", "off"]);
 	});
 
+	it("applies read-only acceptance roles to async dynamic children and their aggregate group", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "targets", structuredOutput: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] } });
+		const readOnlyReport = [
+			"done",
+			"```acceptance-report",
+			JSON.stringify({
+				criteriaSatisfied: [{ id: "criterion-1", status: "satisfied", evidence: "inspection complete" }],
+				changedFiles: [],
+				testsAddedOrUpdated: [],
+				commandsRun: [],
+				validationOutput: [],
+				reviewFindings: ["No blocking findings"],
+				residualRisks: [],
+				noStagedFiles: true,
+			}),
+			"```",
+		].join("\n");
+		mockPi.onCall({ output: readOnlyReport, structuredOutput: { ok: "a" } });
+		mockPi.onCall({ output: readOnlyReport, structuredOutput: { ok: "b" } });
+		const id = `async-dynamic-acceptance-role-${Date.now().toString(36)}`;
+		const result = executeAsyncChain(id, {
+			chain: [
+				{ agent: "producer", task: "Produce targets", as: "targets", outputSchema: { type: "object" } },
+				{
+					expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 2 },
+					parallel: { agent: "explorer", task: "Explore {target.path}", outputSchema: { type: "object" } },
+					collect: { as: "reviews" },
+					concurrency: 1,
+				},
+			],
+			agents: [makeAgent("producer"), makeAgent("explorer", { acceptanceRole: "read-only" })],
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-dynamic-role" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		assert.ok(!result.isError);
+		const payload = await readAsyncPayload(id);
+		const explorerResults = payload.results.filter((child) => child.agent === "explorer");
+		assert.deepEqual(explorerResults.map((child) => child.acceptance?.effectiveAcceptance?.level), ["attested", "attested"]);
+		const dynamicNode = payload.workflowGraph?.nodes?.[1];
+		assert.equal(dynamicNode?.acceptanceStatus, "attested");
+		assert.deepEqual(dynamicNode?.children?.map((child) => child.acceptanceStatus), ["attested", "attested"]);
+	});
+
+	it("infers async dynamic acceptance after materializing item templates", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "targets", structuredOutput: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] } });
+		const writerReport = [
+			"done",
+			"```acceptance-report",
+			JSON.stringify({
+				criteriaSatisfied: [{ id: "criterion-1", status: "satisfied", evidence: "patch complete" }],
+				changedFiles: ["src/a.ts"],
+				testsAddedOrUpdated: ["test/a.test.ts"],
+				commandsRun: [{ command: "npm test", result: "passed", summary: "passed" }],
+				validationOutput: ["tests passed"],
+				residualRisks: [],
+				noStagedFiles: true,
+			}),
+			"```",
+		].join("\n");
+		mockPi.onCall({ output: writerReport, structuredOutput: { ok: "a" } });
+		mockPi.onCall({ output: writerReport, structuredOutput: { ok: "b" } });
+		const id = `async-dynamic-role-item-template-${Date.now().toString(36)}`;
+		executeAsyncChain(id, {
+			chain: [
+				{ agent: "producer", task: "Produce targets", as: "targets", outputSchema: { type: "object" } },
+				{
+					expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 2 },
+					parallel: { agent: "explorer", task: "Patch {target.path}", outputSchema: { type: "object" } },
+					collect: { as: "reviews" },
+					concurrency: 1,
+				},
+			],
+			agents: [makeAgent("producer"), makeAgent("explorer", { acceptanceRole: "read-only" })],
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-dynamic-role-item" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		const payload = await readAsyncPayload(id);
+		const explorerResults = payload.results.filter((child) => child.agent === "explorer");
+		assert.deepEqual(explorerResults.map((child) => child.acceptance?.effectiveAcceptance?.level), ["checked", "checked"]);
+		const dynamicNode = payload.workflowGraph?.nodes?.[1];
+		assert.equal(payload.success, true);
+		assert.equal(dynamicNode?.acceptanceStatus, "rejected");
+		assert.deepEqual(dynamicNode?.children?.map((child) => child.acceptanceStatus), ["rejected", "rejected"]);
+	});
+
 	it("cancels dynamic fanout aggregate acceptance when the run times out", { skip: !isAsyncAvailable() ? "jiti not available" : process.platform === "win32" ? "timeout signal delivery intermittent on Windows CI" : undefined }, async () => {
 		mockPi.onCall({ output: "targets", structuredOutput: { items: [{ path: "src/a.ts" }] } });
 		mockPi.onCall({ output: "review-a", structuredOutput: { ok: "a" } });
@@ -1269,28 +2203,54 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			const taskArg = args.at(-1) ?? "";
 			assert.ok(taskArg.includes(`[Read from: ${path.join(worktreeCwd, "input.md")}]`));
 			assert.ok(taskArg.includes(`Write your findings to exactly this path: ${path.join(repoDir, ".pi-subagents", "artifacts", "outputs", asyncId, "report.md")}`));
-			await waitForAsyncResultFile(asyncId, 90_000);
+			const resultPath = await waitForAsyncResultFile(asyncId, 90_000);
+			const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+			const status = JSON.parse(fs.readFileSync(path.join(result.details!.asyncDir!, "status.json"), "utf-8")) as AsyncStatusPayload;
+			assert.equal(payload.parallelHandoff?.version, 1);
+			assert.equal(payload.parallelHandoff?.path, path.join(result.details!.asyncDir!, "handoff.json"));
+			assert.deepEqual(status.parallelHandoff, payload.parallelHandoff);
+			assert.equal(payload.parallelHandoff?.childCount, 1);
+			assert.equal(payload.parallelHandoff?.cleanupState, "complete");
+			assert.equal(fs.existsSync(worktreeCwd), false, "temporary worktree should be removed before handoff publication");
+			const handoff = JSON.parse(fs.readFileSync(payload.parallelHandoff!.path!, "utf-8")) as {
+				version: number;
+				groups: Array<{ children: Array<{ agent: string; status: string; patch: { path: string } }>; cleanup: { state: string } }>;
+			};
+			assert.equal(handoff.version, 1);
+			assert.equal(handoff.groups[0]!.children[0]!.agent, "worker");
+			assert.equal(handoff.groups[0]!.children[0]!.status, "completed");
+			assert.equal(handoff.groups[0]!.cleanup.state, "complete");
+			assert.equal(fs.existsSync(handoff.groups[0]!.children[0]!.patch.path), true, "patch artifact should outlive cleanup");
 		} finally {
 			removeTempDir(repoDir);
 		}
 	});
 
-	it("readStatus caches by mtime (second call uses cache)", () => {
+	it("readStatus caches unchanged files and invalidates same-mtime replacements", () => {
 		const dir = createTempDir();
 		try {
+			const statusPath = path.join(dir, "status.json");
+			const fixedTimestamp = new Date(1_700_000_000_000);
 			const statusData = {
 				runId: "cache-test",
 				state: "running",
 				mode: "single",
-				startedAt: Date.now(),
+				startedAt: fixedTimestamp.getTime(),
 			};
-			fs.writeFileSync(path.join(dir, "status.json"), JSON.stringify(statusData));
-
-			const s1 = readStatus(dir);
-			const s2 = readStatus(dir);
-			assert.ok(s1);
-			assert.ok(s2);
-			assert.equal(s1.runId, s2.runId);
+			fs.writeFileSync(statusPath, JSON.stringify(statusData));
+			fs.utimesSync(statusPath, fixedTimestamp, fixedTimestamp);
+
+			const cached = readStatus(dir);
+			assert.ok(cached);
+			assert.strictEqual(readStatus(dir), cached);
+
+			writeAtomicJson(statusPath, { ...statusData, state: "stopped" });
+			fs.utimesSync(statusPath, fixedTimestamp, fixedTimestamp);
+			assert.equal(fs.statSync(statusPath).mtimeMs, fixedTimestamp.getTime());
+			const replaced = readStatus(dir);
+			assert.ok(replaced);
+			assert.equal(replaced.state, "stopped");
+			assert.notStrictEqual(replaced, cached);
 		} finally {
 			removeTempDir(dir);
 		}
@@ -1328,6 +2288,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		const run = executeAsyncSingle(id, {
 			agent: "worker",
 			task: "Do work",
+			acceptance: { level: "none", reason: "descriptor persistence coverage" },
 			agentConfig: makeAgent("worker", {
 				model: "openai/gpt-5-mini:high",
 				fallbackModels: ["anthropic/claude-sonnet-4:low"],
@@ -1360,8 +2321,22 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			await new Promise((resolve) => setTimeout(resolve, 100));
 		}
 
+		const descriptorPath = path.join(asyncDir, "recovery-descriptor.json");
+		const descriptor = JSON.parse(fs.readFileSync(descriptorPath, "utf-8"));
+		assert.equal(descriptor.sourceRunId, id);
+		assert.equal(descriptor.agent, "worker");
+		assert.equal(descriptor.model, "openai/gpt-5-mini:high");
+		assert.deepEqual(descriptor.fallbackModels, ["anthropic/claude-sonnet-4:low"]);
+		assert.equal(descriptor.cwd, tempDir);
+		assert.equal(descriptor.sessionDir, path.join(sessionRoot, `async-${id}`));
+		assert.deepEqual(descriptor.acceptance, { level: "none", reason: "descriptor persistence coverage" });
+		assert.equal(Object.hasOwn(descriptor.acceptance, "explicit"), false);
+		assert.equal(Object.hasOwn(descriptor.acceptance, "inferredReason"), false);
+		assert.equal(Object.hasOwn(descriptor, "task"), false);
+		if (process.platform !== "win32") assert.equal(fs.statSync(descriptorPath).mode & 0o777, 0o600);
+
 		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
-		assert.equal(payload.lifecycleArtifactVersion, 1);
+		assert.equal(payload.lifecycleArtifactVersion, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION);
 		assert.equal(payload.success, true);
 		assert.equal(payload.results[0].model, "anthropic/claude-sonnet-4:low");
 		assert.deepEqual(payload.results[0].attemptedModels, ["openai/gpt-5-mini:high", "anthropic/claude-sonnet-4:low"]);
@@ -1369,7 +2344,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.deepEqual(payload.results[0].totalCost, { inputTokens: 110, outputTokens: 55, costUsd: 0.011 });
 		assert.deepEqual(payload.totalCost, { inputTokens: 110, outputTokens: 55, costUsd: 0.011 });
 		const statusPayload = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatusPayload;
-		assert.equal(statusPayload.lifecycleArtifactVersion, 1);
+		assert.equal(statusPayload.lifecycleArtifactVersion, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION);
 		assert.equal(statusPayload.steps[0]?.model, "anthropic/claude-sonnet-4:low");
 		assert.equal(statusPayload.steps[0]?.thinking, "low");
 		assert.ok(statusPayload.totalTokens!.total > 0);
@@ -1377,14 +2352,103 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.deepEqual(statusPayload.steps[0]?.totalCost, { inputTokens: 110, outputTokens: 55, costUsd: 0.011 });
 		assert.deepEqual(statusPayload.totalCost, { inputTokens: 110, outputTokens: 55, costUsd: 0.011 });
 		const events = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8").trim().split("\n").map((line) => JSON.parse(line));
-		assert.equal(events.find((event) => event.type === "subagent.run.started")?.lifecycleArtifactVersion, 1);
+		assert.equal(events.find((event) => event.type === "subagent.run.started")?.lifecycleArtifactVersion, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION);
 		const completed = events.find((event) => event.type === "subagent.run.completed");
-		assert.equal(completed?.lifecycleArtifactVersion, 1);
+		assert.equal(completed?.lifecycleArtifactVersion, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION);
 		assert.deepEqual(completed?.totalCost, { inputTokens: 110, outputTokens: 55, costUsd: 0.011 });
 		assert.match(fs.readFileSync(path.join(asyncDir, "output-0.log"), "utf-8"), /Recovered asynchronously/);
 		assert.equal(mockPi.callCount(), 2);
 	});
 
+	it("background runs retry the fallback model when the provider stream ends without finish_reason", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({
+			jsonl: [{
+				type: "message_end",
+				message: {
+					role: "assistant",
+					content: [{ type: "text", text: "stream broke mid-response" }],
+					model: "openai/gpt-5-mini",
+					errorMessage: "Stream ended without finish_reason",
+					usage: { input: 10, output: 0, cacheRead: 0, cacheWrite: 0, cost: { total: 0.001 } },
+				},
+			}],
+			exitCode: 1,
+		});
+		mockPi.onCall({ output: "Recovered after stream failure" });
+		const id = `async-fallback-stream-${Date.now().toString(36)}`;
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Do work",
+			agentConfig: makeAgent("worker", {
+				model: "openai/gpt-5-mini:high",
+				fallbackModels: ["anthropic/claude-sonnet-4:low"],
+			}),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			availableModels: [
+				{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini" },
+				{ provider: "anthropic", id: "claude-sonnet-4", fullId: "anthropic/claude-sonnet-4" },
+			],
+			artifactConfig: {
+				enabled: false,
+				includeInput: false,
+				includeOutput: false,
+				includeJsonl: false,
+				includeMetadata: false,
+				cleanupDays: 7,
+			},
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		const payload = JSON.parse(fs.readFileSync(await waitForAsyncResultFile(id), "utf-8"));
+		assert.equal(payload.success, true);
+		assert.deepEqual(payload.results[0].attemptedModels, ["openai/gpt-5-mini:high", "anthropic/claude-sonnet-4:low"]);
+		assert.match(payload.results[0].output ?? "", /Recovered after stream failure/);
+		assert.equal(mockPi.callCount(), 2);
+	});
+
+	it("background runs do not retry the fallback model for a trailing tool failure", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({
+			jsonl: [
+				mockAssistantMessage("checking connectivity", "tool_use"),
+				events.toolResult("bash", "curl: (28) Connection timed out after 5000 ms\nCommand exited with code 1", true),
+			],
+			exitCode: 0,
+		});
+		mockPi.onCall({ output: "fallback must not run" });
+		const id = `async-fallback-toolfail-${Date.now().toString(36)}`;
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Do work",
+			agentConfig: makeAgent("worker", {
+				model: "openai/gpt-5-mini:high",
+				fallbackModels: ["anthropic/claude-sonnet-4:low"],
+			}),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			availableModels: [
+				{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini" },
+				{ provider: "anthropic", id: "claude-sonnet-4", fullId: "anthropic/claude-sonnet-4" },
+			],
+			artifactConfig: {
+				enabled: false,
+				includeInput: false,
+				includeOutput: false,
+				includeJsonl: false,
+				includeMetadata: false,
+				cleanupDays: 7,
+			},
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		const payload = JSON.parse(fs.readFileSync(await waitForAsyncResultFile(id), "utf-8"));
+		assert.equal(payload.success, false);
+		assert.equal(payload.results[0].modelAttempts.length, 1);
+		assert.match(payload.results[0].error ?? "", /^bash failed \(exit 1\)/);
+		assert.match(payload.results[0].error ?? "", /timed out/i);
+		assert.equal(mockPi.callCount(), 1);
+	});
+
 	it("background single thinking override replaces primary and fallback suffixes", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({
 			jsonl: [{
@@ -1486,6 +2550,54 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(mockPi.callCount(), 2);
 	});
 
+	it("background runs prefer empty-output fallback over an earlier tool error", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({
+			jsonl: [
+				events.toolResult("read", "ENOENT: no such file or directory", true),
+				events.toolResult("read", "recovered file contents"),
+				{
+					type: "message_end",
+					message: {
+						role: "assistant",
+						content: [],
+						model: "openai/gpt-5-mini",
+						stopReason: "stop",
+						usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } },
+					},
+				},
+			],
+			exitCode: 0,
+		});
+		mockPi.onCall({ output: "Recovered asynchronously on fallback" });
+		const id = `async-empty-output-after-tool-error-${Date.now().toString(36)}`;
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Do work",
+			agentConfig: makeAgent("worker", {
+				model: "openai/gpt-5-mini",
+				fallbackModels: ["anthropic/claude-sonnet-4"],
+			}),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: {
+				enabled: false,
+				includeInput: false,
+				includeOutput: false,
+				includeJsonl: false,
+				includeMetadata: false,
+				cleanupDays: 7,
+			},
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		const resultPath = await waitForAsyncResultFile(id);
+		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+		assert.equal(payload.success, true);
+		assert.equal(payload.results[0]?.model, "anthropic/claude-sonnet-4");
+		assert.match(payload.results[0]?.modelAttempts?.[0]?.error ?? "", /no output/i);
+		assert.equal(mockPi.callCount(), 2);
+	});
+
 	it("background runs fail zero-exit provider errors when no fallback succeeds", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({
 			jsonl: [{
@@ -1635,9 +2747,9 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		const resultPath = path.join(RESULTS_DIR, `${id}.json`);
 		const outputPath = path.join(tempDir, "async-file-only.md");
 		const run = executeAsyncSingle(id, {
-			agent: "worker",
-			task: "Do work",
-			agentConfig: makeAgent("worker"),
+			agent: "analyst",
+			task: "Analyze without modifying files",
+			agentConfig: makeAgent("analyst", { tools: ["read", "grep", "find", "ls"] }),
 			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
 			artifactConfig: {
 				enabled: false,
@@ -1655,6 +2767,15 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		});
 
 		assert.equal(run.details.asyncId, id);
+		const call = await waitForMockPiCall(mockPi, 0);
+		const taskArg = call.args.at(-1) ?? "";
+		const systemPrompt = call.systemPrompts[0]?.text ?? "";
+		for (const instruction of [taskArg, systemPrompt]) {
+			assert.match(instruction, /Return the complete artifact in your final response\./);
+			assert.match(instruction, /runtime will persist it to exactly this path:/);
+			assert.match(instruction, /Do not call contact_supervisor merely because no write-capable tool is available\./);
+			assert.doesNotMatch(instruction, /Write your findings to exactly this path/);
+		}
 		const deadline = Date.now() + 10_000;
 		while (!fs.existsSync(resultPath)) {
 			if (Date.now() > deadline) assert.fail(`Timed out waiting for async result file: ${resultPath}`);
@@ -1867,6 +2988,77 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.doesNotMatch(eventsText, /Interrupt:/);
 	});
 
+	it("agent contract v1 keeps async acceptance and file-mutation effects separate from execution", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "I’ll do that now and report back after implementing.\n```acceptance-report\n{\"criteriaSatisfied\":[{\"id\":\"criterion-1\",\"status\":\"not-satisfied\",\"evidence\":\"no proof\"}]}\n```" });
+		const id = `async-v1-separate-${Date.now().toString(36)}`;
+
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Implement the approved fixes",
+			agentConfig: makeAgent("worker", { completionGuard: true }),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: {
+				enabled: false,
+				includeInput: false,
+				includeOutput: false,
+				includeJsonl: false,
+				includeMetadata: false,
+				cleanupDays: 7,
+			},
+			shareEnabled: false,
+			sessionRoot: path.join(tempDir, "sessions"),
+			maxSubagentDepth: 2,
+			agentContract: { version: 1 },
+			acceptance: { level: "checked", criteria: ["Return required proof"] },
+		});
+
+		const resultPath = await waitForAsyncResultFile(id, 10_000);
+		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+		const statusPayload = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf-8")) as AsyncStatusPayload;
+
+		assert.equal(payload.success, true);
+		assert.equal(payload.state, "complete");
+		assert.equal(payload.exitCode, 0);
+		assert.equal(payload.results[0]?.agentContract?.version, 1);
+		assert.equal(payload.results[0]?.execution?.status, "completed");
+		assert.equal(payload.results[0]?.execution?.success, true);
+		assert.equal(payload.results[0]?.acceptance?.status, "rejected");
+		assert.equal(payload.results[0]?.effects?.fileMutation?.status, "missing");
+		assert.equal(statusPayload.state, "complete");
+		assert.equal(statusPayload.steps?.[0]?.agentContract?.version, 1);
+		assert.equal(statusPayload.steps?.[0]?.execution?.status, "completed");
+		assert.equal(statusPayload.steps?.[0]?.effects?.fileMutation?.status, "missing");
+	});
+
+	it("background single runs support outputSchema", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "structured", structuredOutput: { ok: true, note: "async" } });
+		const id = `async-single-schema-${Date.now().toString(36)}`;
+
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Return structured data",
+			agentConfig: makeAgent("worker", { completionGuard: false }),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: {
+				enabled: false,
+				includeInput: false,
+				includeOutput: false,
+				includeJsonl: false,
+				includeMetadata: false,
+				cleanupDays: 7,
+			},
+			shareEnabled: false,
+			sessionRoot: path.join(tempDir, "sessions"),
+			maxSubagentDepth: 2,
+			acceptance: false,
+			structuredOutputSchema: { type: "object", required: ["ok"], properties: { ok: { type: "boolean" }, note: { type: "string" } } },
+		});
+
+		const payload = JSON.parse(fs.readFileSync(await waitForAsyncResultFile(id, 10_000), "utf-8")) as AsyncResultPayload;
+		assert.equal(payload.success, true);
+		assert.deepEqual(payload.results[0]?.structuredOutput, { ok: true, note: "async" });
+	});
+
 	it("background bash-enabled non-implementation agents can opt out of the completion guard", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({ output: "cold start test after patch" });
 
@@ -2024,6 +3216,94 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(args[args.indexOf("--model") + 1], "deepseek/deepseek-v4-flash");
 	});
 
+	it("background chains treat empty step models as parent inheritance", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "Done asynchronously" });
+
+		const id = `async-chain-empty-model-${Date.now().toString(36)}`;
+		executeAsyncChain(id, {
+			chain: [{ agent: "worker", task: "Do work", model: "" }],
+			agents: [makeAgent("worker", { model: "anthropic/claude-sonnet-4-5", thinking: "high" })],
+			ctx: {
+				pi: { events: { emit() {} } },
+				cwd: tempDir,
+				currentSessionId: "session-1",
+				currentModelProvider: "openai",
+				currentModel: { provider: "openai", id: "gpt-5-mini" },
+			},
+			availableModels: [
+				{ provider: "anthropic", id: "claude-sonnet-4-5", fullId: "anthropic/claude-sonnet-4-5", api: "anthropic-messages" },
+				{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini", api: "openai-responses" },
+			],
+			artifactConfig: {
+				enabled: false,
+				includeInput: false,
+				includeOutput: false,
+				includeJsonl: false,
+				includeMetadata: false,
+				cleanupDays: 7,
+			},
+			shareEnabled: false,
+			sessionRoot: path.join(tempDir, "sessions"),
+			maxSubagentDepth: 2,
+		});
+
+		const resultPath = await waitForAsyncResultFile(id, 10_000);
+		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+		assert.equal(payload.success, true);
+		assert.equal(payload.results[0].model, "openai/gpt-5-mini:high");
+		assert.deepEqual(payload.results[0].attemptedModels, ["openai/gpt-5-mini:high"]);
+		const args = readMockPiArgs(mockPi, 0);
+		assert.equal(args[args.indexOf("--model") + 1], "openai/gpt-5-mini:high");
+	});
+
+	it("background chains keep agent fallback models inherited for scope warnings", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "Done asynchronously" });
+		const warnings: string[] = [];
+		const originalWarn = console.warn;
+		console.warn = (message?: unknown) => warnings.push(String(message));
+		try {
+			for (const [index, requestedModel] of [undefined, "", "inherit"].entries()) {
+				const id = `async-chain-no-parent-${index}-${Date.now().toString(36)}`;
+				executeAsyncChain(id, {
+					chain: [{ agent: "worker", task: "Do work", ...(requestedModel !== undefined ? { model: requestedModel } : {}) }],
+					agents: [makeAgent("worker", { model: "openai/gpt-5-mini", thinking: "high" })],
+					ctx: {
+						pi: { events: { emit() {} } },
+						cwd: tempDir,
+						currentSessionId: "session-1",
+						modelScope: { enforce: true, allow: ["anthropic/*"] },
+					},
+					availableModels: [
+						{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini", api: "openai-responses" },
+					],
+					artifactConfig: {
+						enabled: false,
+						includeInput: false,
+						includeOutput: false,
+						includeJsonl: false,
+						includeMetadata: false,
+						cleanupDays: 7,
+					},
+					shareEnabled: false,
+					sessionRoot: path.join(tempDir, "sessions"),
+					maxSubagentDepth: 2,
+				});
+
+				const resultPath = await waitForAsyncResultFile(id, 10_000);
+				const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+				assert.equal(payload.success, true);
+				assert.equal(payload.results[0].model, "openai/gpt-5-mini:high");
+				assert.deepEqual(payload.results[0].attemptedModels, ["openai/gpt-5-mini:high"]);
+				const args = readMockPiArgs(mockPi, index);
+				assert.equal(args[args.indexOf("--model") + 1], "openai/gpt-5-mini:high");
+			}
+			assert.equal(warnings.length, 3);
+			assert.equal(warnings.every((warning) => warning.includes("outside the configured subagent model scope")), true);
+		} finally {
+			console.warn = originalWarn;
+		}
+	});
+
 	it("background runs resolve skills from the effective task cwd", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({ output: "Done asynchronously" });
 		const taskCwd = createTempDir("pi-subagent-async-task-cwd-");
@@ -2070,6 +3350,60 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		}
 	});
 
+	it("injects agent-file-relative local skills into background single child prompts", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "Done asynchronously" });
+		const id = `async-local-skill-${Date.now().toString(36)}`;
+		const agentFile = path.join(tempDir, "agents", "worker", "worker.md");
+		const skillFile = path.join(path.dirname(agentFile), "skills", "local", "SKILL.md");
+		fs.mkdirSync(path.dirname(skillFile), { recursive: true });
+		fs.writeFileSync(skillFile, "---\ndescription: async local skill\n---\nLocal skill body\n", "utf-8");
+
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Do work",
+			agentConfig: makeAgent("worker", { filePath: agentFile, skills: ["local"], skillPath: ["./skills"] }),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		await waitForAsyncResultFile(id);
+		const call = await waitForMockPiCall(mockPi, 0);
+		assert.match(call.systemPrompts.map((record) => record.text ?? "").join("\n"), /async local skill/);
+	});
+
+	it("isolates agent-local skills between background parallel chain children", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "one" });
+		mockPi.onCall({ output: "two" });
+		const id = `async-parallel-local-skills-${Date.now().toString(36)}`;
+		const agents = ["one", "two"].map((name) => {
+			const agentFile = path.join(tempDir, "agents", name, `${name}.md`);
+			const skillFile = path.join(path.dirname(agentFile), "skills", "local", "SKILL.md");
+			fs.mkdirSync(path.dirname(skillFile), { recursive: true });
+			fs.writeFileSync(skillFile, `---\ndescription: ${name} async local skill\n---\nbody\n`, "utf-8");
+			return makeAgent(name, { filePath: agentFile, skills: ["local"], skillPath: ["./skills"] });
+		});
+
+		executeAsyncChain(id, {
+			chain: [{ parallel: [{ agent: "one", task: "One" }, { agent: "two", task: "Two" }], concurrency: 2 }],
+			resultMode: "parallel",
+			agents,
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		await waitForAsyncResultFile(id);
+		const prompts = await Promise.all([0, 1].map(async (index) => {
+			const call = await waitForMockPiCall(mockPi, index);
+			return call.systemPrompts.map((record) => record.text ?? "").join("\n");
+		}));
+		assert.equal(prompts.filter((prompt) => /one async local skill/.test(prompt) && !/two async local skill/.test(prompt)).length, 1);
+		assert.equal(prompts.filter((prompt) => /two async local skill/.test(prompt) && !/one async local skill/.test(prompt)).length, 1);
+	});
+
 	it("background single runs report unavailable pi-subagents skill requests", () => {
 		const id = `async-pi-subagents-skill-${Date.now().toString(36)}`;
 		const result = executeAsyncSingle(id, {
@@ -2370,6 +3704,104 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.match(result.content[0]?.text ?? "", /async-cfg-/);
 	});
 
+	it("background ignores child watchdog status when child watchdogs are not configured", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		await withIsolatedWatchdogSettings(tempDir, async () => {
+			const id = `async-watchdog-unconfigured-${Date.now().toString(36)}`;
+			mockPi.onCall({
+				jsonl: [events.assistantMessage("async-done-without-watchdog-config"), childWatchdogStatus(id, "reviewing", 1)],
+				keepAliveAfterFinalMessageMs: 10000,
+			});
+
+			const start = Date.now();
+			executeAsyncSingle(id, {
+				agent: "worker",
+				task: "Do work",
+				agentConfig: makeAgent("worker"),
+				ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+				shareEnabled: false,
+				sessionRoot: path.join(tempDir, "sessions"),
+				maxSubagentDepth: 2,
+			});
+
+			const resultPath = await waitForAsyncResultFile(id, 10_000);
+			const elapsed = Date.now() - start;
+			const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+			assert.ok(elapsed < 6000, `unconfigured watchdog status should not delay async final drain, took ${elapsed}ms`);
+			assert.equal(payload.success, true);
+			assert.equal(payload.results[0]?.output, "async-done-without-watchdog-config");
+			assert.equal((payload.results[0] as { watchdog?: unknown }).watchdog, undefined);
+		});
+	});
+
+	it("background final-drain waits for child watchdog settlement", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		await withIsolatedWatchdogSettings(tempDir, async () => {
+			writeWatchdogSettings(tempDir);
+			const id = `async-watchdog-drain-${Date.now().toString(36)}`;
+			mockPi.onCall({
+				steps: [
+					{ jsonl: [events.assistantMessage("async-done-before-watchdog"), childWatchdogStatus(id, "reviewing", 1)] },
+					{ delay: 1400, jsonl: [childWatchdogStatus(id, "idle", 2)] },
+				],
+				keepAliveAfterFinalMessageMs: 10000,
+			});
+
+			const start = Date.now();
+			executeAsyncSingle(id, {
+				agent: "worker",
+				task: "Do work",
+				agentConfig: makeAgent("worker"),
+				ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+				shareEnabled: false,
+				sessionRoot: path.join(tempDir, "sessions"),
+				maxSubagentDepth: 2,
+			});
+
+			const resultPath = await waitForAsyncResultFile(id, 10_000);
+			const elapsed = Date.now() - start;
+			const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+			assert.ok(elapsed >= 1200, `watchdog settlement should delay async final drain, took ${elapsed}ms`);
+			assert.ok(elapsed < 9000, `settled watchdog should still allow async cleanup, took ${elapsed}ms`);
+			assert.equal(payload.success, true);
+			assert.equal(payload.results[0]?.output, "async-done-before-watchdog");
+			assert.equal((payload.results[0] as { watchdog?: { phase?: string } }).watchdog?.phase, "idle");
+		});
+	});
+
+	it("background child watchdog tail timeout still finalizes successful output", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		await withIsolatedWatchdogSettings(tempDir, async () => {
+			writeWatchdogSettings(tempDir, 150);
+			const id = `async-watchdog-timeout-${Date.now().toString(36)}`;
+			mockPi.onCall({
+				jsonl: [events.assistantMessage("async-done-before-watchdog-timeout"), childWatchdogStatus(id, "reviewing", 1)],
+				keepAliveAfterFinalMessageMs: 10000,
+			});
+
+			const start = Date.now();
+			executeAsyncSingle(id, {
+				agent: "worker",
+				task: "Do work",
+				agentConfig: makeAgent("worker"),
+				ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+				shareEnabled: false,
+				sessionRoot: path.join(tempDir, "sessions"),
+				maxSubagentDepth: 2,
+			});
+
+			const resultPath = await waitForAsyncResultFile(id, 10_000);
+			const elapsed = Date.now() - start;
+			const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+			assert.ok(elapsed < 6000, `watchdog tail fallback should not hang async final drain, took ${elapsed}ms`);
+			assert.equal(payload.success, true);
+			assert.equal(payload.results[0]?.output, "async-done-before-watchdog-timeout");
+			const watchdog = (payload.results[0] as { watchdog?: { phase?: string; timedOut?: boolean } }).watchdog;
+			assert.equal(watchdog?.phase, "stale");
+			assert.equal(watchdog?.timedOut, true);
+		});
+	});
+
 	it("background forced drain after final assistant output is cleanup success", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({
 			jsonl: [events.assistantMessage("async-done-before-drain")],
@@ -2564,6 +3996,145 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		}
 	});
 
+	it("does not flag a delayed active tool as idle attention", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [events.toolStart("bash", { command: "sleep 2" })] },
+				{ delay: 2_500, jsonl: [events.toolEnd("bash"), events.toolResult("bash", "done")] },
+				{ jsonl: [events.assistantMessage("Done")] },
+			],
+		});
+
+		const id = `async-delayed-tool-attention-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, id);
+		const eventsPath = path.join(asyncDir, "events.jsonl");
+		const resultPath = path.join(RESULTS_DIR, `${id}.json`);
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Run the command",
+			agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			sessionRoot: path.join(tempDir, "sessions"),
+			maxSubagentDepth: 2,
+			controlConfig: {
+				enabled: true,
+				needsAttentionAfterMs: 200,
+				activeNoticeAfterMs: 999_999,
+				failedToolAttemptsBeforeAttention: 3,
+				notifyOn: ["active_long_running", "needs_attention"],
+				notifyChannels: ["event", "async", "intercom"],
+			},
+		});
+
+		const deadline = Date.now() + 10_000;
+		let statusDuringTool: AsyncStatusPayload | undefined;
+		while (Date.now() < deadline && !fs.existsSync(resultPath)) {
+			if (fs.existsSync(asyncDir) && fs.existsSync(path.join(asyncDir, "status.json"))) {
+				const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatusPayload;
+				const toolStartedAt = status.steps?.[0]?.currentToolStartedAt;
+				if (status.currentTool === "bash" && status.steps?.[0]?.currentTool === "bash" && toolStartedAt && Date.now() - toolStartedAt >= 1_500) {
+					statusDuringTool = status;
+					break;
+				}
+			}
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+		assert.ok(statusDuringTool, "expected status.json to expose the active tool");
+		assert.equal(statusDuringTool?.activityState, undefined);
+		assert.equal(statusDuringTool?.steps?.[0]?.activityState, undefined);
+		const eventText = fs.existsSync(eventsPath) ? fs.readFileSync(eventsPath, "utf-8") : "";
+		assert.doesNotMatch(eventText, /"type":"needs_attention"/);
+		await waitForAsyncResultFile(id);
+		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
+		assert.equal(payload.success, true);
+	});
+
+	it("subagent_wait wakes when an async child is waiting on contact_supervisor", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [events.toolStart("contact_supervisor", { reason: "need_decision", message: "Need a decision" })] },
+				{ delay: 5_000, jsonl: [events.toolEnd("contact_supervisor"), events.toolResult("contact_supervisor", "**Reply from supervisor:**\nProceed")] },
+				{ delay: 2_500, jsonl: [events.assistantMessage("Done")] },
+			],
+		});
+
+		const id = `async-supervisor-attention-${Date.now().toString(36)}`;
+		const asyncDir = path.join(ASYNC_DIR, id);
+		const eventsPath = path.join(asyncDir, "events.jsonl");
+		const resultPath = path.join(RESULTS_DIR, `${id}.json`);
+		const statusPath = path.join(asyncDir, "status.json");
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: "Ask the supervisor for a blocking decision",
+			agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			sessionRoot: path.join(tempDir, "sessions"),
+			maxSubagentDepth: 2,
+			controlConfig: {
+				enabled: true,
+				needsAttentionAfterMs: 999_999,
+				activeNoticeAfterMs: 999_999,
+				failedToolAttemptsBeforeAttention: 3,
+				notifyOn: ["active_long_running", "needs_attention"],
+				notifyChannels: ["event", "async", "intercom"],
+			},
+		});
+
+		const attentionDeadline = Date.now() + 10_000;
+		let statusDuringAttention: AsyncStatusPayload | undefined;
+		while (Date.now() < attentionDeadline && !fs.existsSync(resultPath)) {
+			if (fs.existsSync(statusPath)) {
+				const nextStatus = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as AsyncStatusPayload;
+				if (nextStatus.currentTool === "contact_supervisor" && nextStatus.activityState === "needs_attention") {
+					statusDuringAttention = nextStatus;
+					break;
+				}
+			}
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+		assert.ok(statusDuringAttention, "expected status.json to expose the blocking supervisor request");
+
+		const waitResult = await waitForSubagents({ id, timeoutMs: 3_500 }, undefined, {
+			state: { currentSessionId: "session-1", foregroundRuns: new Map(), asyncJobs: new Map(), cleanupTimers: new Map(), resultFileCoalescer: new Map() },
+			pollIntervalMs: 100,
+			events: createEventBus(),
+		});
+		const waitText = waitResult.content[0]?.text ?? "";
+		assert.equal(waitResult.isError, undefined);
+		assert.match(waitText, /attention required/i);
+		assert.match(waitText, new RegExp(id));
+		assert.match(waitText, /intercom\(\{ action: "pending" \}\)/);
+		assert.equal(fs.existsSync(resultPath), false, "wait should return before the child completes");
+
+		const eventText = fs.existsSync(eventsPath) ? fs.readFileSync(eventsPath, "utf-8") : "";
+		assert.match(eventText, /"type":"needs_attention"/);
+		assert.match(eventText, /"reason":"supervisor_request"/);
+		assert.equal(statusDuringAttention.activityState, "needs_attention");
+		assert.equal(statusDuringAttention.steps?.[0]?.activityState, "needs_attention");
+		assert.equal(statusDuringAttention.currentTool, "contact_supervisor");
+		assert.equal(statusDuringAttention.steps?.[0]?.currentTool, "contact_supervisor");
+
+		const clearDeadline = Date.now() + 10_000;
+		let statusAfterReply: AsyncStatusPayload | undefined;
+		while (Date.now() < clearDeadline && !fs.existsSync(resultPath)) {
+			const nextStatus = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as AsyncStatusPayload;
+			if (nextStatus.state === "running" && !nextStatus.currentTool && !nextStatus.steps?.[0]?.currentTool) {
+				statusAfterReply = nextStatus;
+				break;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+		assert.ok(statusAfterReply, "expected the child to keep running after the supervisor reply");
+		assert.equal(statusAfterReply.activityState, undefined);
+		assert.equal(statusAfterReply.steps?.[0]?.activityState, undefined);
+
+		await waitForAsyncResultFile(id);
+	});
+
 	it("background runs escalate repeated mutating tool failures", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({
 			steps: [