@selesai/code 0.5.28 → 0.6.1

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

@@ -15,7 +15,7 @@ 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, deliverStopRequest, deliverTimeoutRequest } from "../../src/runs/background/control-channel.ts";
+import { deliverCheckpointDecisionRequest, 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";
@@ -26,10 +26,35 @@ import { resolveSubagentLaunchContract } from "../../src/api/preflight.ts";
 import { discoverAgents } from "../../src/agents/agents.ts";
 import { runSync } from "../../src/runs/foreground/execution.ts";
 
+interface LaunchResolvedExtensions {
+	version?: number;
+	source?: string;
+	disableAmbientExtensions?: boolean;
+	runtime?: string[];
+	configured?: string[];
+	effective?: string[];
+}
+
+interface RuntimeAcknowledgedExtensions {
+	version?: number;
+	source?: string;
+	ids?: string[];
+	omitted?: number;
+}
+
+interface UsageBudgetState {
+	version?: number;
+	source?: string;
+	exhausted?: boolean;
+	reason?: string;
+	tokens?: { used?: number; hard?: number; exhausted?: boolean };
+	costUsd?: { used?: number; hard?: number; exhausted?: boolean };
+}
+
 interface AsyncExecutionResult {
 	content: Array<{ text?: string }>;
 	isError?: boolean;
-	details: { asyncId?: string; asyncDir?: string; launchContractDigest?: string };
+	details: { asyncId?: string; asyncDir?: string; launchContractDigest?: string; launchResolvedExtensions?: LaunchResolvedExtensions; runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions; usageBudget?: UsageBudgetState; checkpoint?: { name?: string; status?: string } };
 }
 
 interface AsyncResultPayload {
@@ -40,6 +65,8 @@ interface AsyncResultPayload {
 	sessionId?: string;
 	mode?: string;
 	launchContractDigest?: string;
+	launchResolvedExtensions?: LaunchResolvedExtensions;
+	runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions;
 	summary?: string;
 	error?: string;
 	timeoutMs?: number;
@@ -51,7 +78,9 @@ interface AsyncResultPayload {
 	wrapUpRequested?: boolean;
 	totalTokens?: { input: number; output: number; total: number };
 	totalCost?: { inputTokens: number; outputTokens: number; costUsd: number };
-	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 } }>;
+	usageBudget?: UsageBudgetState;
+	checkpoint?: { name?: string; status?: string };
+	results: Array<{ agent?: string; launchContractDigest?: string; launchResolvedExtensions?: LaunchResolvedExtensions; runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions; output?: string; outputPath?: string; outputState?: "present" | "absent" | "unknown"; 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; 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 };
@@ -68,6 +97,8 @@ interface AsyncStatusPayload {
 	currentPath?: string;
 	state?: string;
 	launchContractDigest?: string;
+	launchResolvedExtensions?: LaunchResolvedExtensions;
+	runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions;
 	error?: string;
 	timeoutMs?: number;
 	deadlineAt?: number;
@@ -78,6 +109,8 @@ interface AsyncStatusPayload {
 	wrapUpRequested?: boolean;
 	totalTokens?: { total: number };
 	totalCost?: { inputTokens: number; outputTokens: number; costUsd: number };
+	usageBudget?: UsageBudgetState;
+	checkpoint?: { name?: string; status?: string; message?: string };
 	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[] };
@@ -100,6 +133,8 @@ interface AsyncStatusPayload {
 		totalCost?: { inputTokens: number; outputTokens: number; costUsd: number };
 		agentContract?: { version: 1 };
 		launchContractDigest?: string;
+		launchResolvedExtensions?: LaunchResolvedExtensions;
+		runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions;
 		execution?: { status?: string; success?: boolean; exitCode?: number };
 		effects?: { fileMutation?: { status?: string; expected?: boolean; attempted?: boolean } };
 		acceptance?: { status?: string };
@@ -292,6 +327,19 @@ async function waitForAsyncResultFile(id: string, timeoutMs = 15_000): Promise<s
 	return resultPath;
 }
 
+async function waitForAsyncState(id: string, predicate: (status: AsyncStatusPayload) => boolean, 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 (predicate(status)) return status;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 50));
+	}
+	assert.fail(`Timed out waiting for async status: ${statusPath}`);
+}
+
 async function waitForDeferredTurnBudget(id: string, timeoutMs = 10_000): Promise<AsyncStatusPayload> {
 	const statusPath = path.join(ASYNC_DIR, id, "status.json");
 	const deadline = Date.now() + timeoutMs;
@@ -405,6 +453,18 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		return JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
 	}
 
+	/**
+	 * Reference-first async child assertion: the result payload carries the
+	 * saved-output reference; the full text is read from the durable output path.
+	 */
+	function assertAsyncChildOutput(payload: AsyncResultPayload, index: number, expected: string): void {
+		const child = payload.results[index];
+		assert.ok(child, `expected async child ${index}`);
+		assert.match(child.output ?? "", /Output saved to: /);
+		assert.ok(child.outputPath, `expected a durable output path for child ${index}`);
+		assert.equal(fs.readFileSync(child.outputPath, "utf-8"), expected);
+	}
+
 	function launchProtocolTest(id: string): void {
 		executeAsyncSingle(id, {
 			agent: "worker",
@@ -432,7 +492,27 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		launchProtocolTest(id);
 		const payload = await readAsyncPayload(id);
 		assert.equal(payload.success, true);
-		assert.equal(payload.results[0]?.output, "你好 from fragmented async JSON");
+		assertAsyncChildOutput(payload, 0, "你好 from fragmented async JSON");
+	});
+
+	it("persists absent output provenance when async lifecycle text is synthetic", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ jsonl: [mockAssistantMessage("", "tool_use")], stderr: "mock child failure", exitCode: 1 });
+		const id = `async-output-absent-${Date.now().toString(36)}`;
+		launchProtocolTest(id);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, false);
+		assert.equal(payload.results[0]?.outputState, "absent");
+		assert.match(payload.results[0]?.error ?? "", /mock child failure/);
+	});
+
+	it("persists present output provenance when async failure follows partial output", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "usable partial answer", stderr: "mock post-output failure", exitCode: 1 });
+		const id = `async-output-present-${Date.now().toString(36)}`;
+		launchProtocolTest(id);
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, false);
+		assert.equal(payload.results[0]?.outputState, "present");
+		assertAsyncChildOutput(payload, 0, "usable partial answer");
 	});
 
 	it("matches preflight launch digest in equivalent foreground and async execution", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
@@ -444,11 +524,14 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		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" });
+		// Stable explicit output keeps the preflight launch contract equivalent to
+		// both execution paths (generated per-run paths would differ by design).
+		const contractOutputPath = path.join(tempDir, "contract-output.md");
+		const preflight = await resolveSubagentLaunchContract({ agent: agentName, cwd: tempDir, task, turnBudget, runId: "contract-preflight", output: contractOutputPath });
 		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 });
+		const foreground = await runSync(tempDir, [discovered], agentName, task, { runId: "contract-foreground", acceptance: false, turnBudget, outputPath: contractOutputPath });
 		assert.equal(foreground.exitCode, 0);
 		assert.equal(foreground.launchContractDigest, preflight.contract.launchContractDigest);
 
@@ -457,6 +540,8 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		const launch = executeAsyncSingle(asyncId, {
 			agent: agentName,
 			task,
+			output: contractOutputPath,
+			outputMode: "inline",
 			agentConfig: discovered,
 			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
 			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
@@ -473,12 +558,16 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 	});
 
 	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" });
+		mockPi.onCall({
+			output: "digest-bound async done",
+			runtimeAcknowledgedExtensions: { version: 1, source: "child-runtime", ids: ["ext.async"], omitted: 0 },
+		});
 		const id = `async-launch-digest-${Date.now().toString(36)}`;
+		const privateExtension = path.join(tempDir, "extensions", "private-extension.ts");
 		const launch = executeAsyncSingle(id, {
 			agent: "worker",
 			task: "Exercise launch digest reporting",
-			agentConfig: makeAgent("worker", { completionGuard: false }),
+			agentConfig: makeAgent("worker", { completionGuard: false, extensions: [privateExtension] }),
 			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
 			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
 			shareEnabled: false,
@@ -493,6 +582,140 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		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);
+		assert.equal(launch.details.launchResolvedExtensions?.source, "launch-resolved");
+		assert.equal(launch.details.launchResolvedExtensions?.disableAmbientExtensions, true);
+		assert.deepEqual(payload.launchResolvedExtensions, launch.details.launchResolvedExtensions);
+		assert.deepEqual(payload.results[0]?.launchResolvedExtensions, launch.details.launchResolvedExtensions);
+		assert.deepEqual(status.launchResolvedExtensions, launch.details.launchResolvedExtensions);
+		assert.deepEqual(status.steps?.[0]?.launchResolvedExtensions, launch.details.launchResolvedExtensions);
+		const runtimeAck = { version: 1, source: "child-runtime", ids: ["ext.async"], omitted: 0 };
+		assert.deepEqual(payload.runtimeAcknowledgedExtensions, runtimeAck);
+		assert.deepEqual(payload.results[0]?.runtimeAcknowledgedExtensions, runtimeAck);
+		assert.deepEqual(status.runtimeAcknowledgedExtensions, runtimeAck);
+		assert.deepEqual(status.steps?.[0]?.runtimeAcknowledgedExtensions, runtimeAck);
+		assert.ok(!JSON.stringify(launch.details.launchResolvedExtensions).includes(tempDir), "projection should not expose raw extension paths");
+	});
+
+	it("async chain checkpoints pause before the next child until approved", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "analysis done" });
+		mockPi.onCall({ output: "implementation done" });
+		const id = `async-checkpoint-approve-${Date.now().toString(36)}`;
+		const launch = executeAsyncChain(id, {
+			chain: [
+				{ agent: "analyst", task: "Analyze" },
+				{ checkpoint: "review", message: "Approve implementation?" },
+				{ agent: "reporter", task: "Summarize {previous}" },
+			],
+			agents: [makeAgent("analyst"), makeAgent("reporter")],
+			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 paused = await waitForAsyncState(id, (status) => status.state === "paused" && status.checkpoint?.name === "review");
+		assert.equal(launch.isError, undefined);
+		assert.equal(paused.steps?.[1]?.status, "paused");
+		assert.equal(mockPi.callCount(), 1);
+
+		deliverCheckpointDecisionRequest({ asyncDir: path.join(ASYNC_DIR, id), decision: "approved" });
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, true);
+		assert.equal(payload.state, "complete");
+		assert.equal(payload.checkpoint?.status, "approved");
+		assert.equal(payload.results.length, 2);
+		assert.equal(mockPi.callCount(), 2);
+	});
+
+	it("foreground checkpoint decisions use current-session control actions", { skip: !createSubagentExecutor ? "executor not available" : undefined }, async () => {
+		mockPi.onCall({ output: "analysis done" });
+		const executor = makeAsyncExecutor([makeAgent("analyst"), makeAgent("worker")]);
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionId = () => "session-foreground-checkpoint";
+		const id = `foreground-checkpoint-${Date.now().toString(36)}`;
+
+		const paused = await executor.execute(id, {
+			chain: [
+				{ agent: "analyst", task: "Analyze" },
+				{ checkpoint: "review", message: "Approve implementation?" },
+				{ agent: "worker", task: "Implement" },
+			],
+		}, new AbortController().signal, undefined, ctx) as AsyncExecutionResult;
+
+		assert.equal(paused.isError, undefined);
+		assert.equal(paused.details.checkpoint?.status, "pending");
+		assert.equal(mockPi.callCount(), 1);
+		const runId = (paused.details as AsyncExecutionResult["details"] & { runId?: string }).runId;
+		assert.ok(runId);
+
+		const approved = await executor.execute(`${id}-approve`, { action: "approve-checkpoint", id: runId }, new AbortController().signal, undefined, ctx) as AsyncExecutionResult;
+		assert.equal(approved.isError, undefined);
+		assert.equal(approved.details.checkpoint?.name, "review");
+		assert.equal(approved.details.checkpoint?.status, "approved");
+		assert.equal(mockPi.callCount(), 1);
+	});
+
+	it("async chain checkpoint rejection is an explicit terminal state", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "analysis done" });
+		mockPi.onCall({ output: "should not run" });
+		const id = `async-checkpoint-reject-${Date.now().toString(36)}`;
+		executeAsyncChain(id, {
+			chain: [
+				{ agent: "analyst", task: "Analyze" },
+				{ checkpoint: "review" },
+				{ agent: "worker", task: "Implement" },
+			],
+			agents: [makeAgent("analyst"), 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,
+		});
+
+		await waitForAsyncState(id, (status) => status.state === "paused" && status.checkpoint?.name === "review");
+		deliverCheckpointDecisionRequest({ asyncDir: path.join(ASYNC_DIR, id), decision: "rejected" });
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, false);
+		assert.equal(payload.state, "rejected");
+		assert.equal(payload.checkpoint?.status, "rejected");
+		assert.equal(mockPi.callCount(), 1);
+	});
+
+	it("background parallel groups report usage budget state and block queued children", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "first async result" });
+		const id = `async-usage-budget-${Date.now().toString(36)}`;
+		const launch = executeAsyncChain(id, {
+			chain: [{
+				parallel: [
+					{ agent: "first", task: "First task" },
+					{ agent: "second", task: "Second task" },
+				],
+				concurrency: 1,
+			}],
+			resultMode: "parallel",
+			usageBudget: { tokens: { hard: 10 } },
+			agents: [makeAgent("first"), makeAgent("second")],
+			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,
+		});
+
+		assert.equal(launch.details.usageBudget?.exhausted, false);
+		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.success, false);
+		assert.equal(payload.state, "failed");
+		assert.match(payload.error ?? payload.summary ?? "", /Usage budget exhausted/);
+		assert.equal(payload.results.length, 2);
+		assert.equal(payload.results[1]?.skipped, true);
+		assert.match(payload.results[1]?.error ?? "", /Usage budget exhausted/);
+		assert.equal(mockPi.callCount(), 1);
+		assert.equal(payload.usageBudget?.exhausted, true);
+		assert.equal(payload.usageBudget?.reason, "tokens");
+		assert.equal(status.usageBudget?.exhausted, true);
+		assert.equal(status.steps?.[0]?.status, "complete");
+		assert.equal(status.steps?.[1]?.status, "failed");
 	});
 
 	it("background fails with protocol_output_limit for an oversized stdout line", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
@@ -515,7 +738,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 
 		const launch = await executor.execute(
 			"async-session-artifact-dir",
-			{ agent: "worker", task: "Write async session artifacts", async: true, runId: "async-session-artifacts", acceptance: false },
+			{ agent: "worker", task: "Write async session artifacts", async: true, runId: "async-session-artifacts", acceptance: false, artifacts: true },
 			new AbortController().signal,
 			undefined,
 			ctx,
@@ -623,7 +846,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		launchProtocolTest(id);
 		const payload = await readAsyncPayload(id);
 		assert.equal(payload.success, true);
-		assert.equal(payload.results[0]?.output, "settled async response");
+		assertAsyncChildOutput(payload, 0, "settled async response");
 		assert.ok(Date.now() - startedAt >= 1200, "background runner must not terminate during the retry delay");
 	});
 
@@ -635,7 +858,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		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");
+		assertAsyncChildOutput(payload, 0, "settled async without a terminal assistant stop");
 		assert.ok(Date.now() - startedAt < 4000, "agent_settled should trigger bounded child cleanup");
 	});
 
@@ -666,7 +889,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		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");
+		assertAsyncChildOutput(payload, 0, "OK");
 	});
 
 	it("spawns the async runner with node when process.execPath is not node", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
@@ -697,7 +920,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			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");
+			assertAsyncChildOutput(payload, 0, "non-node exec async done");
 		} finally {
 			process.execPath = originalExecPath;
 		}
@@ -731,7 +954,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			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]?.output, "stale node exec async done");
+			assertAsyncChildOutput(payload, 0, "stale node exec async done");
 		} finally {
 			process.execPath = originalExecPath;
 		}
@@ -972,8 +1195,11 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(payload.turnBudget?.turnCount, 2);
 		assert.equal(payload.results[0]?.wrapUpRequested, true);
 		assert.equal(payload.results[0]?.turnBudget?.turnCount, 2);
-		assert.match(payload.results[0]?.output ?? "", /Turn budget wrap-up was requested after 1 assistant turn/);
-		assert.match(payload.results[0]?.output ?? "", /final wrapped output/);
+		// Reference-first delivery: the saved-output reference replaces inline prose;
+		// the wrap-up note and raw output stay visible through status/result fields
+		// and the persisted result file.
+		assert.match(payload.results[0]?.output ?? "", /Output saved to: /);
+		assertAsyncChildOutput(payload, 0, "final wrapped output");
 		assert.equal(status.wrapUpRequested, true);
 		assert.equal(status.turnBudgetExceeded, undefined);
 		assert.equal(status.steps?.[0]?.wrapUpRequested, true);
@@ -1012,8 +1238,9 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		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 ?? "", /safe assistant boundary after tool work/);
+		assert.match(payload.error ?? "", /Subagent exceeded turn budget|turn budget/i);
+		assert.match(payload.results[0]?.output ?? "", /Output saved to: /);
+		assertAsyncChildOutput(payload, 0, "safe assistant boundary after tool work");
 		assert.equal(status.state, "failed");
 		assert.equal(status.turnBudgetExceeded, true);
 		assert.equal(status.steps?.[0]?.turnBudgetExceeded, true);
@@ -1066,7 +1293,8 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		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.match(payload.results[0]?.output ?? "", /Output saved to: /);
+		assertAsyncChildOutput(payload, 0, "safe assistant boundary reached");
 		assert.equal(status.state, "failed");
 		assert.equal(status.turnBudgetExceeded, true);
 		assert.equal(status.steps?.[0]?.turnBudget?.outcome, "exceeded");
@@ -1349,15 +1577,16 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			tempArtifactsDir: tempDir,
 			getSubagentSessionRoot: () => tempDir,
 			expandTilde: (p: string) => p,
-			discoverAgents: () => ({ agents: [makeAgent("worker", { defaultProgress: true })] }),
+			discoverAgents: () => ({ agents: [makeAgent("builder", { defaultProgress: true })] }),
 		});
 
 		const result = await executor.execute(
 			"async-parallel-fields",
 			{
-				tasks: [{ agent: "worker", task: "Do async work", output: "async-top-output.md", reads: ["input.md"] }],
+				tasks: [{ agent: "builder", task: "Do async work", output: "async-top-output.md", reads: ["input.md"] }],
 				async: true,
 				clarify: false,
+				artifacts: true,
 			},
 			new AbortController().signal,
 			undefined,
@@ -1416,7 +1645,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			];
 			const launch = await executor.execute(
 				`async-inherited-output-${outputOverride === true ? "true" : "omitted"}`,
-				{ tasks, async: true, clarify: false },
+				{ tasks, async: true, clarify: false, artifacts: true },
 				new AbortController().signal,
 				undefined,
 				makeMinimalCtx(tempDir),
@@ -1425,8 +1654,8 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			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");
+			assertAsyncChildOutput(payload, 0, "first async report");
+			assertAsyncChildOutput(payload, 1, "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"),
@@ -1488,6 +1717,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 				],
 				async: true,
 				clarify: false,
+				artifacts: true,
 			},
 			new AbortController().signal,
 			undefined,
@@ -1726,13 +1956,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(path.join(ASYNC_DIR, id, "status.json"), "utf-8")) as AsyncStatusPayload;
 		assert.equal(payload.success, true);
-		assert.deepEqual(payload.results.map((entry) => entry.output), [
-			"Scout A async findings",
-			"Scout B async findings",
-			"Async funnel synthesis",
-			"Async reviewer A done",
-			"Async reviewer B done",
-		]);
+		// Reference-first chain delivery: every child result carries the saved-output
+		// reference; full text is read from each durable output path.
+		assertAsyncChildOutput(payload, 0, "Scout A async findings");
+		assertAsyncChildOutput(payload, 1, "Scout B async findings");
+		assertAsyncChildOutput(payload, 2, "Async funnel synthesis");
+		assertAsyncChildOutput(payload, 3, "Async reviewer A done");
+		assertAsyncChildOutput(payload, 4, "Async reviewer B done");
 		assert.deepEqual(status.steps?.map((step) => step.status), ["complete", "complete", "complete", "complete", "complete"]);
 		assert.deepEqual(status.parallelGroups, [
 			{ start: 0, count: 2, stepIndex: 0 },
@@ -1740,11 +1970,14 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		]);
 		const funnelTask = readMockPiArgsMatching(mockPi, "Synthesize:").at(-1) ?? "";
 		assert.match(funnelTask, /=== Parallel Task 1 \(scout-a\) ===/);
-		assert.match(funnelTask, /Scout A async findings/);
 		assert.match(funnelTask, /=== Parallel Task 2 \(scout-b\) ===/);
-		assert.match(funnelTask, /Scout B async findings/);
-		assert.match(readMockPiArgsMatching(mockPi, "Review funnel A:").at(-1) ?? "", /Review funnel A:\nAsync funnel synthesis/);
-		assert.match(readMockPiArgsMatching(mockPi, "Review funnel B:").at(-1) ?? "", /Review funnel B:\nAsync funnel synthesis/);
+		// Chain handoff stays reference-first: the funnel consumes the saved-output
+		// references and reads the named paths instead of re-inlined child prose.
+		assert.match(funnelTask, /Output saved to: /);
+		assert.doesNotMatch(funnelTask, /Scout A async findings/);
+		assert.doesNotMatch(funnelTask, /Scout B async findings/);
+		assert.match(readMockPiArgsMatching(mockPi, "Review funnel A:").at(-1) ?? "", /Review funnel A:\nOutput saved to: /);
+		assert.match(readMockPiArgsMatching(mockPi, "Review funnel B:").at(-1) ?? "", /Review funnel B:\nOutput saved to: /);
 		assert.equal(payload.workflowGraph?.nodes?.[0]?.kind, "parallel-group");
 		assert.equal(payload.workflowGraph?.nodes?.[0]?.status, "completed");
 		assert.equal(payload.workflowGraph?.nodes?.[1]?.kind, "step");
@@ -1862,6 +2095,39 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(payload.workflowGraph?.nodes?.[2]?.flatIndex, 3);
 	});
 
+	it("async dynamic fanout blocks queued children when hard reported usage is exhausted", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "targets", structuredOutput: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] } });
+		mockPi.onCall({ matchArgIncludes: "Review src/a.ts", output: "review-a", structuredOutput: { ok: "a" } });
+		const id = `async-dynamic-usage-budget-${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: 4 },
+					parallel: { agent: "reviewer", task: "Review {target.path}", outputSchema: { type: "object" } },
+					collect: { as: "reviews" },
+					concurrency: 1,
+				},
+			],
+			usageBudget: { tokens: { hard: 200 } },
+			agents: [makeAgent("producer"), makeAgent("reviewer")],
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-dynamic-budget" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+		});
+
+		const payload = await readAsyncPayload(id);
+		const status = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf-8")) as AsyncStatusPayload;
+		assert.equal(mockPi.callCount(), 2);
+		assert.equal(payload.success, false);
+		assert.equal(payload.usageBudget?.exhausted, true);
+		assert.equal(status.steps?.[1]?.status, "complete");
+		assert.equal(status.steps?.[2]?.status, "failed");
+		assert.match(status.steps?.[2]?.error ?? "", /Usage budget exhausted/);
+		assert.equal(payload.results.find((result) => result.agent === "reviewer" && result.skipped)?.skipped, true);
+	});
+
 	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)}`;
@@ -2102,7 +2368,10 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		const expectedConsumerTarget = `subagent-consumer-${id}-4`;
 		assert.equal(payload.success, true);
 		assert.equal(payload.results[3]?.intercomTarget, expectedConsumerTarget);
-		assert.deepEqual(JSON.parse(payload.results[3]?.output ?? "{}"), { SELESAI_SUBAGENT_INTERCOM_SESSION_NAME: expectedConsumerTarget });
+		const consumerChild = payload.results[3];
+		assert.ok(consumerChild?.outputPath, "expected a durable output path for the consumer child");
+		assert.match(consumerChild.output ?? "", /Output saved to: /);
+		assert.deepEqual(JSON.parse(fs.readFileSync(consumerChild.outputPath, "utf-8")), { SELESAI_SUBAGENT_INTERCOM_SESSION_NAME: expectedConsumerTarget });
 	});
 
 	it("async dynamic pre-spawn failures persist failed graph status and error", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
@@ -2189,6 +2458,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 					async: true,
 					clarify: false,
 					worktree: true,
+					artifacts: true,
 				},
 				new AbortController().signal,
 				undefined,
@@ -2360,6 +2630,43 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(mockPi.callCount(), 2);
 	});
 
+	it("background runs retry a zero-activity startup exit on the same model", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ exitCode: 1 });
+		mockPi.onCall({ output: "Recovered asynchronously after startup race" });
+		const id = `async-startup-retry-${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")) 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"]);
+		assert.deepEqual(payload.results[0]?.modelAttempts?.map((attempt) => attempt.success), [false, true]);
+		assertAsyncChildOutput(payload, 0, "Recovered asynchronously after startup race");
+		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: [{
@@ -2403,7 +2710,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		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/);
+		assertAsyncChildOutput(payload, 0, "Recovered after stream failure");
 		assert.equal(mockPi.callCount(), 2);
 	});
 
@@ -2544,7 +2851,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		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]?.output ?? "", /Recovered asynchronously from empty output/);
+		assertAsyncChildOutput(payload, 0, "Recovered asynchronously from empty output");
 		assert.match(payload.results[0]?.modelAttempts?.[0]?.error ?? "", /no output/i);
 		assert.deepEqual(payload.results[0]?.modelAttempts?.map((attempt) => attempt.success), [false, true]);
 		assert.equal(mockPi.callCount(), 2);
@@ -2684,7 +2991,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(payload.exitCode, 0);
 		assert.equal(payload.results[0]?.success, true);
 		assert.equal(payload.results[0]?.error, undefined);
-		assert.equal(payload.results[0]?.output, "Recovered asynchronously");
+		assertAsyncChildOutput(payload, 0, "Recovered asynchronously");
 		const statusPayload = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatusPayload;
 		assert.equal(statusPayload.state, "complete");
 		assert.equal(statusPayload.steps?.[0]?.status, "complete");
@@ -3088,7 +3395,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(payload.success, true);
 		assert.equal(payload.exitCode, 0);
 		assert.equal(payload.results[0].success, true);
-		assert.equal(payload.results[0].output, "cold start test after patch");
+		assertAsyncChildOutput(payload, 0, "cold start test after patch");
 
 		const eventsPath = path.join(ASYNC_DIR, id, "events.jsonl");
 		const eventsText = fs.readFileSync(eventsPath, "utf-8");
@@ -3143,6 +3450,71 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.deepEqual(payload.results[0].attemptedModels, ["github-copilot/gpt-5-mini"]);
 	});
 
+	it("async executor keeps the last parent session model after continuation drops ctx.model", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		mockPi.onCall({ output: "Done asynchronously" });
+		const state = {
+			baseCwd: tempDir,
+			currentSessionId: null,
+			asyncJobs: new Map(),
+			foregroundControls: new Map(),
+			lastForegroundControlId: null,
+		};
+		const executor = createSubagentExecutor!({
+			pi: { events: createEventBus(), getSessionName: () => undefined },
+			state,
+			config: {},
+			asyncByDefault: false,
+			tempArtifactsDir: tempDir,
+			getSubagentSessionRoot: () => path.join(tempDir, "sessions"),
+			expandTilde: (p: string) => p,
+			discoverAgents: () => ({ agents: [makeAgent("worker")] }),
+		});
+		const initialCtx = makeMinimalCtx(tempDir);
+		initialCtx.sessionManager.getSessionId = () => "session-continued";
+		initialCtx.model = { provider: "deepseek", id: "deepseek-v4-flash" };
+		await executor.execute("prime-parent-model", { action: "list" }, new AbortController().signal, undefined, initialCtx);
+
+		const continuedCtx = makeMinimalCtx(tempDir);
+		continuedCtx.sessionManager.getSessionId = () => "session-continued";
+		const launch = await executor.execute(
+			"continued-async-child",
+			{ agent: "worker", task: "Do work", async: true, acceptance: false },
+			new AbortController().signal,
+			undefined,
+			continuedCtx,
+		) as AsyncExecutionResult;
+		assert.equal(launch.isError, undefined);
+		assert.ok(launch.details.asyncId);
+
+		const payload = await readAsyncPayload(launch.details.asyncId);
+		assert.equal(payload.success, true);
+		assert.equal(payload.results[0]?.model, "deepseek/deepseek-v4-flash");
+		const args = readMockPiArgs(mockPi, 0);
+		assert.equal(args[args.indexOf("--model") + 1], "deepseek/deepseek-v4-flash");
+	});
+
+	it("foreground chains keep the last parent session model after continuation drops ctx.model", { skip: !createSubagentExecutor ? "executor not available" : undefined }, async () => {
+		mockPi.onCall({ output: "Done foreground" });
+		const executor = makeAsyncExecutor([makeAgent("worker", { completionGuard: false })]);
+		const initialCtx = makeMinimalCtx(tempDir);
+		initialCtx.sessionManager.getSessionId = () => "session-continued";
+		initialCtx.model = { provider: "deepseek", id: "deepseek-v4-flash" };
+		await executor.execute("prime-parent-model", { action: "list" }, new AbortController().signal, undefined, initialCtx);
+
+		const continuedCtx = makeMinimalCtx(tempDir);
+		continuedCtx.sessionManager.getSessionId = () => "session-continued";
+		const result = await executor.execute(
+			"continued-foreground-chain",
+			{ chain: [{ agent: "worker", task: "Do work" }], acceptance: false },
+			new AbortController().signal,
+			undefined,
+			continuedCtx,
+		);
+		assert.equal(result.isError, undefined);
+		const args = readMockPiArgs(mockPi, 0);
+		assert.equal(args[args.indexOf("--model") + 1], "deepseek/deepseek-v4-flash");
+	});
+
 	it("background single runs inherit the parent session model when no model is set", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({ output: "Done asynchronously" });
 
@@ -3729,7 +4101,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			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");
+			assertAsyncChildOutput(payload, 0, "async-done-without-watchdog-config");
 			assert.equal((payload.results[0] as { watchdog?: unknown }).watchdog, undefined);
 		});
 	});
@@ -3764,7 +4136,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			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");
+			assertAsyncChildOutput(payload, 0, "async-done-before-watchdog");
 			assert.equal((payload.results[0] as { watchdog?: { phase?: string } }).watchdog?.phase, "idle");
 		});
 	});
@@ -3795,7 +4167,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			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");
+			assertAsyncChildOutput(payload, 0, "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);
@@ -3846,7 +4218,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(payload.success, true);
 		assert.equal(payload.exitCode, 0);
 		assert.equal(payload.results[0].success, true);
-		assert.equal(payload.results[0].output, "async-done-before-drain");
+		assertAsyncChildOutput(payload, 0, "async-done-before-drain");
 	});
 
 	it("background forced drain after empty terminal assistant output is cleanup success", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
@@ -3882,7 +4254,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.equal(payload.success, true);
 		assert.equal(payload.exitCode, 0);
 		assert.equal(payload.results[0].success, true);
-		assert.equal(payload.results[0].output, "");
+		assert.match(payload.results[0].output ?? "", /Output saved to: /);
 	});
 
 	it("background final-drain cleanup preserves explicit assistant errors", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
@@ -4255,7 +4627,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			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]?.output, "Done after noisy stream");
+			assertAsyncChildOutput(payload, 0, "Done after noisy stream");
 
 			const eventsText = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8");
 			assert.doesNotMatch(eventsText, /"type":"message_update"/);
@@ -4334,7 +4706,7 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 
 		const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
 		assert.equal(payload.success, true);
-		assert.equal(payload.results[0].output, "Done streaming");
+		assertAsyncChildOutput(payload, 0, "Done streaming");
 
 		const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
 		assert.deepEqual(status.steps[0].recentTools.map((tool: { tool: string; args: string }) => ({ tool: tool.tool, args: tool.args })), [{ tool: "bash", args: "ls" }]);