@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/test/integration/intercom-result-delivery.test.ts

@@ -5,8 +5,10 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { after, afterEach, before, beforeEach, describe, it } from "node:test";
 import { ASYNC_DIR, INTERCOM_DETACH_REQUEST_EVENT, RESULTS_DIR, SUBAGENT_ASYNC_STARTED_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT } from "../../src/shared/types.ts";
+import { ACTIVE_ASYNC_CAPACITY_DIR, acquireActiveAsyncCapacity, activeAsyncCapacitySessionKey, getActiveAsyncCapacitySnapshot } from "../../src/runs/background/active-async-capacity.ts";
 import { waitForSubagents } from "../../src/runs/background/subagent-wait.ts";
-import { sessionLeaseDir } from "../../src/runs/shared/session-lease.ts";
+import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
+import { acquireSessionLease, sessionLeaseDir } from "../../src/runs/shared/session-lease.ts";
 import type { MockPi } from "../support/helpers.ts";
 import {
 	createMockPi,
@@ -26,6 +28,7 @@ interface ExecutorResult {
 		runId?: string;
 		results?: Array<{ agent?: string; finalOutput?: string; sessionFile?: string; acceptance?: { status?: string }; artifactPaths?: { metadataPath?: string } }>;
 		asyncId?: string;
+		workflow?: { value?: unknown };
 	};
 }
 
@@ -81,6 +84,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 	let mockPi: MockPi;
 	let originalHome: string | undefined;
 	let originalUserProfile: string | undefined;
+	let budgetDirectories: string[] = [];
 
 	before(() => {
 		originalHome = process.env.HOME;
@@ -111,6 +115,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 
 	afterEach(() => {
 		removeTempDir(tempDir);
+		for (const directory of budgetDirectories.splice(0)) fs.rmSync(directory, { recursive: true, force: true });
 	});
 
 	async function readMockCallArgs(index: number): Promise<string[]> {
@@ -161,7 +166,39 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		}
 	}
 
-	function makeExecutor(options: { bridgeMode?: "always" | "off"; resultDelivery?: boolean; agents?: ReturnType<typeof makeAgent>[]; acknowledgeResults?: boolean; kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean } = {}) {
+	async function waitForStatus(filePath: string, predicate: (status: any) => boolean, timeoutMs = 10_000): Promise<any> {
+		const deadline = Date.now() + timeoutMs;
+		let lastStatus: any;
+		while (Date.now() <= deadline) {
+			if (fs.existsSync(filePath)) {
+				lastStatus = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+				if (predicate(lastStatus)) return lastStatus;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 50));
+		}
+		assert.fail(`Timed out waiting for status at ${filePath}; last status: ${JSON.stringify(lastStatus)}`);
+	}
+
+	function writeRecoveryDescriptor(asyncDir: string, runId: string, agent = "worker", overrides: Record<string, unknown> = {}): void {
+		const runFanoutBudget = createRunFanoutBudget(runId, 64);
+		budgetDirectories.push(runFanoutBudget.directory);
+		fs.writeFileSync(path.join(asyncDir, "recovery-descriptor.json"), JSON.stringify({
+			version: 1,
+			runFanoutBudget,
+			sourceRunId: runId,
+			agent,
+			cwd: tempDir,
+			systemPromptMode: "replace",
+			inheritProjectContext: false,
+			inheritSkills: false,
+			outputMode: "inline",
+			maxSubagentDepth: 2,
+			share: false,
+			...overrides,
+		}, null, 2), "utf-8");
+	}
+
+	function makeExecutor(options: { bridgeMode?: "always" | "off"; resultDelivery?: boolean; agents?: ReturnType<typeof makeAgent>[]; acknowledgeResults?: boolean; kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean; maxActiveAsyncRunsPerSession?: number } = {}) {
 		const events = createRecordingEventBus({ acknowledgeResults: options.acknowledgeResults ?? true });
 		const state = {
 			baseCwd: tempDir,
@@ -193,24 +230,25 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 					mode: options.bridgeMode ?? "always",
 					...(options.resultDelivery === undefined ? {} : { resultDelivery: options.resultDelivery }),
 				},
+				...(options.maxActiveAsyncRunsPerSession === undefined ? {} : { maxActiveAsyncRunsPerSession: options.maxActiveAsyncRunsPerSession }),
 			},
 			asyncByDefault: false,
 			tempArtifactsDir: tempDir,
 			getSubagentSessionRoot: () => tempDir,
 			expandTilde: (value: string) => value,
-			discoverAgents: () => ({ agents: options.agents ?? [makeAgent("builder")] }),
+			discoverAgents: () => ({ agents: options.agents ?? [makeAgent("worker")] }),
 			kill: options.kill,
 		});
 		return { executor, events, state };
 	}
 
 	it("single foreground runs emit one grouped event and return a compact receipt", async () => {
-		mockPi.onCall({ output: "Full child output from builder" });
+		mockPi.onCall({ output: "Full child output from worker" });
 		const { executor, events } = makeExecutor({ resultDelivery: true });
 
 		const result = await executor.execute(
 			"single-intercom",
-			{ agent: "builder", task: "Implement feature" },
+			{ agent: "worker", task: "Implement feature" },
 			new AbortController().signal,
 			undefined,
 			makeMinimalCtx(tempDir),
@@ -221,14 +259,83 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		const payload = intercomEvents[0]!.payload as { children?: Array<{ agent?: string; intercomTarget?: string }>; message?: string; mode?: string };
 		assert.equal(payload.mode, "single");
 		assert.equal(payload.children?.length, 1);
-		assert.equal(payload.children?.[0]?.agent, "builder");
-		assert.match(payload.children?.[0]?.intercomTarget ?? "", /^subagent-builder-[a-f0-9]+-1$/);
+		assert.equal(payload.children?.[0]?.agent, "worker");
+		assert.match(payload.children?.[0]?.intercomTarget ?? "", /^subagent-worker-[a-f0-9]+-1$/);
 		assert.match(String(payload.message ?? ""), /Intercom targets below identify child sessions used while they were running/);
-		assert.match(String(payload.message ?? ""), /Run intercom target: subagent-builder-[a-f0-9]+-1/);
+		assert.match(String(payload.message ?? ""), /Run intercom target: subagent-worker-[a-f0-9]+-1/);
 		assert.match(result.content[0]?.text ?? "", /Delivered single subagent result via intercom\./);
-		assert.doesNotMatch(result.content[0]?.text ?? "", /Full child output from builder/);
+		assert.doesNotMatch(result.content[0]?.text ?? "", /Full child output from worker/);
 		assert.equal(result.details?.results?.[0]?.finalOutput, undefined);
-		assert.match(String(payload.message ?? ""), /Full child output from builder/);
+		assert.match(String(payload.message ?? ""), /Full child output from worker/);
+	});
+
+	it("keeps child output available to workflow runs after grouped delivery", async () => {
+		mockPi.onCall({ output: "Workflow child output" });
+		const { executor, events } = makeExecutor({ resultDelivery: true });
+
+		const result = await executor.execute(
+			"workflow-intercom-output",
+			{ workflowScript: "const result = await runs.run('worker', { agent: 'worker', task: 'task' }); return result.output;", async: false },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(events.emitted.filter((entry) => entry.channel === "subagent:result-intercom").length, 1);
+		assert.match(result.content[0]?.text ?? "", /Workflow child output/);
+		assert.doesNotMatch(result.content[0]?.text ?? "", /Delivered single subagent result via intercom\./);
+	});
+
+	it("waits for retained workflow resume loops and returns each completed revived child", async () => {
+		mockPi.onCall({ output: "Completed retained follow-up one" });
+		mockPi.onCall({ output: "Completed retained follow-up two" });
+		const sourceRunId = `workflow-resume-source-${Date.now()}`;
+		const sourceAsyncDir = path.join(ASYNC_DIR, sourceRunId);
+		const sessionFile = path.join(tempDir, "workflow-resume-session.jsonl");
+		let revivedIds: string[] = [];
+		try {
+			fs.mkdirSync(sourceAsyncDir, { recursive: true });
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			fs.writeFileSync(path.join(sourceAsyncDir, "status.json"), JSON.stringify({
+				runId: sourceRunId,
+				sessionId: "session-123",
+				mode: "single",
+				state: "complete",
+				startedAt: 100,
+				lastUpdate: 200,
+				cwd: tempDir,
+				sessionFile,
+				steps: [{ agent: "worker", status: "complete", sessionFile }],
+			}, null, 2), "utf-8");
+			writeRecoveryDescriptor(sourceAsyncDir, sourceRunId);
+			const { executor } = makeExecutor();
+
+			const result = await executor.execute(
+				"workflow-retained-resume",
+				{
+					workflowScript: `const first = await runs.run("followup-1", { resume: "${sourceRunId}", task: "Continue once" }); const second = await runs.run("followup-2", { resume: first.runId, task: "Continue twice" }); return { firstRunId: first.runId, firstOutput: first.output, runId: second.runId, output: second.output };`,
+					async: false,
+				},
+				new AbortController().signal,
+				undefined,
+				makeMinimalCtx(tempDir),
+			);
+
+			assert.equal(result.isError, undefined, result.content[0]?.text);
+			assert.match(result.content[0]?.text ?? "", /Completed retained follow-up two/);
+			assert.doesNotMatch(result.content[0]?.text ?? "", /detached and running in the background/);
+			const value = result.details?.workflow?.value as { firstRunId?: string; firstOutput?: string; runId?: string; output?: string } | undefined;
+			revivedIds = [value?.firstRunId, value?.runId].filter((id): id is string => Boolean(id));
+			assert.equal(revivedIds.length, 2);
+			assert.notEqual(revivedIds[0], sourceRunId);
+			assert.notEqual(revivedIds[1], revivedIds[0], "expected the latest revived run id from pass two");
+			assert.equal(value?.firstOutput, "Completed retained follow-up one");
+			assert.equal(value?.output, "Completed retained follow-up two");
+			assert.equal(revivedIds.every((id) => !fs.existsSync(path.join(ASYNC_DIR, id, "workflow-result.json"))), true);
+		} finally {
+			fs.rmSync(sourceAsyncDir, { recursive: true, force: true });
+			for (const id of revivedIds) fs.rmSync(path.join(ASYNC_DIR, id), { recursive: true, force: true });
+		}
 	});
 
 	it("falls back to legacy foreground output when the bridge is inactive", async () => {
@@ -237,7 +344,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 
 		const result = await executor.execute(
 			"single-no-intercom",
-			{ agent: "builder", task: "Summarize feature" },
+			{ agent: "worker", task: "Summarize feature" },
 			new AbortController().signal,
 			undefined,
 			makeMinimalCtx(tempDir),
@@ -253,7 +360,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 
 		const result = await executor.execute(
 			"single-native-delivery",
-			{ agent: "builder", task: "Summarize feature" },
+			{ agent: "worker", task: "Summarize feature" },
 			new AbortController().signal,
 			undefined,
 			makeMinimalCtx(tempDir),
@@ -269,7 +376,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 
 		const result = await executor.execute(
 			"single-no-ack",
-			{ agent: "builder", task: "Summarize feature" },
+			{ agent: "worker", task: "Summarize feature" },
 			new AbortController().signal,
 			undefined,
 			makeMinimalCtx(tempDir),
@@ -317,7 +424,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 
 		const result = await executor.execute(
 			"workflow-worktree-live-card",
-			{ workflowScript: "const result = await runs.run('builder', { agent: 'builder', task: 'task', worktree: true }); return result.output;", async: false, chatProgress: "live-card" },
+			{ workflowScript: "const result = await runs.run('worker', { agent: 'worker', task: 'task', worktree: true }); return result.output;", async: false, chatProgress: "live-card" },
 			new AbortController().signal,
 			undefined,
 			makeMinimalCtx(tempDir),
@@ -349,7 +456,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		);
 		assert.equal(rejected, true);
 		assert.equal(result.isError, true);
-		assert.equal(state.foregroundControls.size, 1, "remaining builder still owns queued scheduling");
+		assert.equal(state.foregroundControls.size, 1, "remaining worker still owns queued scheduling");
 		await waitForCallCount(3);
 		const liveControl = [...state.foregroundControls.values()][0];
 		assert.equal(liveControl?.currentAgent, "c", "later queued child must remain discoverable after launch");
@@ -379,7 +486,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		);
 		assert.equal(rejected, true);
 		assert.equal(result.isError, true);
-		assert.equal(state.foregroundControls.size, 1, "remaining chain builder still owns queued scheduling");
+		assert.equal(state.foregroundControls.size, 1, "remaining chain worker still owns queued scheduling");
 		await waitForCallCount(3);
 		const liveControl = [...state.foregroundControls.values()][0];
 		assert.equal(liveControl?.currentAgent, "c", "later queued chain child must remain discoverable after launch");
@@ -391,12 +498,12 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 
 	it("cleans a rejected sequential chain child and releases foreground ownership", async () => {
 		mockPi.onCall({ output: "sequential child output" });
-		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("builder")] });
+		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("worker")] });
 		let rejected = false;
 		let ownedControl: { schedulingOwners?: number; activeChildren?: Map<number, unknown> } | undefined;
 		const result = await executor.execute(
 			"chain-sequential-rejection-cleanup",
-			{ chain: [{ agent: "builder", task: "sequential task" }] },
+			{ chain: [{ agent: "worker", task: "sequential task" }] },
 			new AbortController().signal,
 			(update: { details?: { progress?: Array<{ status?: string }> } }) => {
 				if (rejected || !update.details?.progress?.some((entry) => entry.status === "completed")) return;
@@ -415,10 +522,10 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 	});
 
 	it("cleans a sequential chain child after an early tool-budget validation return", async () => {
-		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("builder")] });
+		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("worker")] });
 		const execution = executor.execute(
 			"chain-sequential-budget-cleanup",
-			{ chain: [{ agent: "builder", task: "invalid budget task", toolBudget: { hard: 0 } }] },
+			{ chain: [{ agent: "worker", task: "invalid budget task", toolBudget: { hard: 0 } }] },
 			new AbortController().signal,
 			undefined,
 			makeMinimalCtx(tempDir),
@@ -443,11 +550,11 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			].map((entry) => JSON.stringify(entry)).join("\n") + "\n",
 			structuredOutputCapture: { ok: true },
 		});
-		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("builder")] });
+		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("worker")] });
 		let structuredDir: string | undefined;
 		const result = await executor.execute(
 			"single-rejection-cleanup",
-			{ agent: "builder", task: "structured task", artifacts: false, outputSchema: { type: "object", properties: { ok: { type: "boolean" } }, required: ["ok"] } },
+			{ agent: "worker", task: "structured task", artifacts: false, outputSchema: { type: "object", properties: { ok: { type: "boolean" } }, required: ["ok"] } },
 			new AbortController().signal,
 			(update: { details?: { results?: Array<{ structuredOutputPath?: string }>; progress?: Array<{ status?: string }> } }) => {
 				const outputPath = update.details?.results?.[0]?.structuredOutputPath;
@@ -541,7 +648,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 				pid: process.pid,
 				startedAt: 100,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}, null, 2), "utf-8");
 			const { executor, events } = makeExecutor({
 				kill: (pid, signal) => {
@@ -583,7 +690,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 					pid: process.pid,
 					startedAt: 100,
 					lastUpdate: Date.now(),
-					steps: [{ agent: "builder", status: "running" }],
+					steps: [{ agent: "worker", status: "running" }],
 				}, null, 2), "utf-8");
 				const { executor } = makeExecutor();
 
@@ -607,9 +714,9 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 	it("resume action rejects explicit reviewed acceptance before launching", async () => {
 		for (const [index, params] of [
 			{ message: "Continue", acceptance: "reviewed" },
-			{ chain: [{ agent: "commentator", task: "Review {previous}", acceptance: { level: "reviewed" } }] },
+			{ chain: [{ agent: "reviewer", task: "Review {previous}", acceptance: { level: "reviewed" } }] },
 		].entries()) {
-			const { executor, events } = makeExecutor({ agents: [makeAgent("commentator")] });
+			const { executor, events } = makeExecutor({ agents: [makeAgent("reviewer")] });
 			const result = await executor.execute(
 				`resume-invalid-acceptance-${index}`,
 				{ action: "resume", id: "missing-source-run", ...params },
@@ -642,26 +749,26 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 				startedAt: 100,
 				lastUpdate: 100,
 				cwd: tempDir,
-				steps: [{ agent: "builder", status: "running", sessionFile: sourceSession }],
+				steps: [{ agent: "worker", status: "running", sessionFile: sourceSession }],
 			}, null, 2), "utf-8");
 			fs.writeFileSync(sourceResultPath, JSON.stringify({
 				id: sourceRunId,
 				sessionId: "session-123",
-				agent: "builder",
+				agent: "worker",
 				mode: "single",
 				success: true,
 				state: "complete",
 				summary: "root output",
-				results: [{ agent: "builder", output: "root output", success: true, sessionFile: sourceSession }],
+				results: [{ agent: "worker", output: "root output", success: true, sessionFile: sourceSession }],
 			}, null, 2), "utf-8");
-			const { executor, events } = makeExecutor({ agents: [makeAgent("builder"), makeAgent("commentator")] });
+			const { executor, events } = makeExecutor({ agents: [makeAgent("worker"), makeAgent("reviewer")] });
 
 			const result = await executor.execute(
 				"resume-chain-root",
 				{
 					action: "resume",
 					id: sourceRunId,
-					chain: [{ agent: "commentator", task: "Review this root result: {previous}" }],
+					chain: [{ agent: "reviewer", task: "Review this root result: {previous}" }],
 				},
 				new AbortController().signal,
 				undefined,
@@ -671,11 +778,11 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			assert.equal(result.isError, undefined);
 			assert.match(result.content[0]?.text ?? "", /Attached async subagent/);
 			const startedEvent = events.emitted.find((entry) => entry.channel === SUBAGENT_ASYNC_STARTED_EVENT)?.payload as { agent?: string; agents?: string[]; chain?: string[]; chainStepCount?: number; goal?: string } | undefined;
-			assert.equal(startedEvent?.agent, "builder");
-			assert.deepEqual(startedEvent?.agents, ["builder", "commentator"]);
-			assert.deepEqual(startedEvent?.chain, ["builder", "commentator"]);
+			assert.equal(startedEvent?.agent, "worker");
+			assert.deepEqual(startedEvent?.agents, ["worker", "reviewer"]);
+			assert.deepEqual(startedEvent?.chain, ["worker", "reviewer"]);
 			assert.equal(startedEvent?.chainStepCount, 2);
-			assert.equal(startedEvent?.goal, "Review this root result: {previous}");
+			assert.equal(startedEvent?.goal, "[prompt redacted]");
 			const attachedId = result.details?.asyncId;
 			assert.ok(attachedId, "expected attached chain async id");
 			assert.match(result.details?.asyncDir ?? "", new RegExp(`${attachedId}$`));
@@ -684,7 +791,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			const attachedStatus = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as { mode?: string; chainStepCount?: number; steps?: Array<{ agent?: string; label?: string; status?: string }> };
 			assert.equal(attachedStatus.mode, "chain");
 			assert.equal(attachedStatus.chainStepCount, 2);
-			assert.deepEqual(attachedStatus.steps?.map((step) => step.agent), ["builder", "commentator"]);
+			assert.deepEqual(attachedStatus.steps?.map((step) => step.agent), ["worker", "reviewer"]);
 			assert.match(attachedStatus.steps?.[0]?.label ?? "", /Attached resume-chain-root-/);
 			await waitForFile(path.join(RESULTS_DIR, `${attachedId}.json`));
 		} finally {
@@ -708,19 +815,19 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 				startedAt: 100,
 				lastUpdate: 200,
 				cwd: tempDir,
-				steps: [{ agent: "builder", status: "complete" }],
+				steps: [{ agent: "worker", status: "complete" }],
 			}, null, 2), "utf-8");
 			fs.writeFileSync(sourceResultPath, JSON.stringify({
 				id: sourceRunId,
 				sessionId: "session-123",
-				agent: "builder",
+				agent: "worker",
 				mode: "single",
 				success: true,
 				state: "complete",
 				summary: "completed root output",
-				results: [{ agent: "builder", output: "completed root output", success: true }],
+				results: [{ agent: "worker", output: "completed root output", success: true }],
 			}, null, 2), "utf-8");
-			const { executor } = makeExecutor({ agents: [makeAgent("builder"), makeAgent("commentator")] });
+			const { executor } = makeExecutor({ agents: [makeAgent("worker"), makeAgent("reviewer")] });
 
 			const reviveOnly = await executor.execute(
 				"resume-chain-complete-root-revive-only",
@@ -737,7 +844,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 				{
 					action: "resume",
 					id: sourceRunId,
-					chain: [{ agent: "commentator", task: "Review this completed root result: {previous}" }],
+					chain: [{ agent: "reviewer", task: "Review this completed root result: {previous}" }],
 				},
 				new AbortController().signal,
 				undefined,
@@ -777,6 +884,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 					{ agent: "b", status: "complete", sessionFile: secondSession, model: "anthropic/claude-sonnet-4", thinking: "high" },
 				],
 			}, null, 2), "utf-8");
+			writeRecoveryDescriptor(asyncDir, runId, "b", { model: "anthropic/claude-sonnet-4:high" });
 			const { executor } = makeExecutor({ agents: [makeAgent("a"), makeAgent("b")] });
 
 			const result = await executor.execute(
@@ -816,8 +924,9 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 				lastUpdate: 200,
 				cwd: tempDir,
 				sessionFile,
-				steps: [{ agent: "builder", status: "complete", launchContractDigest: "source-launch-contract-digest" }],
+				steps: [{ agent: "worker", status: "complete", launchContractDigest: "source-launch-contract-digest" }],
 			}, null, 2), "utf-8");
+			writeRecoveryDescriptor(asyncDir, runId, "worker", { launchContractDigest: "source-launch-contract-digest" });
 			const { executor, events } = makeExecutor();
 
 			const result = await executor.execute(
@@ -838,7 +947,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			assert.ok(revivedId, "expected revived async id");
 			assert.equal(result.details?.sourceLaunchContractDigest, "source-launch-contract-digest");
 			const startedEvent = events.emitted.find((entry) => entry.channel === SUBAGENT_ASYNC_STARTED_EVENT && (entry.payload as { id?: string }).id === revivedId)?.payload as { goal?: string } | undefined;
-			assert.equal(startedEvent?.goal, "What changed?");
+			assert.equal(startedEvent?.goal, "[prompt redacted]");
 			const resultPath = path.join(RESULTS_DIR, `${revivedId}.json`);
 			const deadline = Date.now() + 10_000;
 			while (!fs.existsSync(resultPath)) {
@@ -861,23 +970,14 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			fs.writeFileSync(sessionFile, "", "utf-8");
 			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
 				runId, sessionId: "session-123", mode: "single", state: "paused", startedAt: 100, lastUpdate: 200, cwd: tempDir,
-				steps: [{ agent: "removed-builder", status: "paused", sessionFile }],
+				steps: [{ agent: "removed-worker", status: "paused", sessionFile }],
 			}, null, 2), "utf-8");
-			fs.writeFileSync(path.join(asyncDir, "recovery-descriptor.json"), JSON.stringify({
-				version: 1,
-				sourceRunId: runId,
-				agent: "removed-builder",
-				cwd: tempDir,
+			writeRecoveryDescriptor(asyncDir, runId, "removed-worker", {
 				model: "anthropic/claude-sonnet-4:high",
 				tools: ["read"],
 				systemPrompt: "Original persisted prompt",
-				systemPromptMode: "replace",
-				inheritProjectContext: false,
-				inheritSkills: false,
-				outputMode: "inline",
 				maxSubagentDepth: 1,
-				share: false,
-			}, null, 2), "utf-8");
+			});
 			const { executor } = makeExecutor({ agents: [] });
 
 			const result = await executor.execute(
@@ -921,8 +1021,9 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			lastUpdate: 200,
 			cwd: tempDir,
 			sessionFile,
-			steps: [{ agent: "builder", status: "complete" }],
+			steps: [{ agent: "worker", status: "complete" }],
 		}, null, 2), "utf-8");
+		writeRecoveryDescriptor(sourceAsyncDir, sourceRunId);
 		try {
 			const { executor } = makeExecutor();
 			const first = await executor.execute(
@@ -967,6 +1068,170 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		}
 	});
 
+	it("marks a resumed workflow child async when its runner starts and fails before proceed", async () => {
+		const parentSessionId = `session-workflow-resume-start-${Date.now()}`;
+		const sourceRunId = `workflow-resume-start-source-${Date.now()}`;
+		const sourceAsyncDir = path.join(ASYNC_DIR, sourceRunId);
+		const sessionFile = path.join(tempDir, "workflow-resume-start-session.jsonl");
+		let workflowRunId: string | undefined;
+		let revivedRunId: string | undefined;
+		try {
+			fs.mkdirSync(sourceAsyncDir, { recursive: true });
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			fs.writeFileSync(path.join(sourceAsyncDir, "status.json"), JSON.stringify({
+				runId: sourceRunId,
+				sessionId: parentSessionId,
+				mode: "single",
+				state: "complete",
+				startedAt: 100,
+				lastUpdate: 200,
+				cwd: tempDir,
+				sessionFile,
+				steps: [{ agent: "worker", status: "complete", sessionFile }],
+			}, null, 2), "utf-8");
+			writeRecoveryDescriptor(sourceAsyncDir, sourceRunId);
+			const competingLease = acquireSessionLease({ sessionFile, runId: "workflow-competing-revival", sourceRunId, parentSessionId });
+			const { executor } = makeExecutor({ maxActiveAsyncRunsPerSession: 1 });
+			const ctx = makeMinimalCtx(tempDir);
+			ctx.sessionManager.getSessionId = () => parentSessionId;
+			try {
+				const failed = await executor.execute(
+					"workflow-resume-start-failure",
+					{ workflowScript: `return await runs.run("resume-child", { resume: "${sourceRunId}", task: "Continue" });`, async: true },
+					new AbortController().signal,
+					undefined,
+					ctx,
+				);
+				workflowRunId = failed.details?.asyncId;
+				assert.ok(workflowRunId, "expected async workflow id");
+				await waitForFile(path.join(RESULTS_DIR, `${workflowRunId}.json`));
+				const workflowStatusPath = path.join(ASYNC_DIR, workflowRunId, "status.json");
+				const workflowStatus = await waitForStatus(workflowStatusPath, (value) => value?.state === "failed") as { steps?: Array<{ async?: boolean; runId?: string }>; error?: string };
+				revivedRunId = workflowStatus.steps?.[0]?.runId;
+
+				assert.equal(workflowStatus.steps?.[0]?.async, true);
+				assert.ok(revivedRunId, "expected the workflow step to keep revived run identity");
+				assert.match(workflowStatus.error ?? "", /already owned by run 'workflow-competing-revival'/);
+				assert.deepEqual(getActiveAsyncCapacitySnapshot(parentSessionId, 1), { used: 0, limit: 1 });
+			} finally {
+				competingLease.release();
+			}
+		} finally {
+			fs.rmSync(sourceAsyncDir, { recursive: true, force: true });
+			if (workflowRunId) fs.rmSync(path.join(ASYNC_DIR, workflowRunId), { recursive: true, force: true });
+			if (revivedRunId) fs.rmSync(path.join(ASYNC_DIR, revivedRunId), { recursive: true, force: true });
+			fs.rmSync(path.join(ACTIVE_ASYNC_CAPACITY_DIR, activeAsyncCapacitySessionKey(parentSessionId)), { recursive: true, force: true });
+		}
+	});
+
+	it("releases async workflow capacity after child launch preparation fails", async () => {
+		const parentSessionId = `session-workflow-prep-${Date.now()}`;
+		try {
+			const { executor } = makeExecutor({ maxActiveAsyncRunsPerSession: 1 });
+			const ctx = makeMinimalCtx(tempDir);
+			ctx.sessionManager.getSessionId = () => parentSessionId;
+			const failed = await executor.execute(
+				"workflow-prep-capacity-release",
+				{
+					workflowScript: `return await runs.run("gated", { agent: "worker", task: "run", gate: "npm test" });`,
+					async: true,
+					acceptance: false,
+				},
+				new AbortController().signal,
+				undefined,
+				ctx,
+			);
+			const workflowRunId = failed.details?.asyncId;
+			assert.ok(workflowRunId, "expected async workflow id");
+			await waitForFile(path.join(RESULTS_DIR, `${workflowRunId}.json`));
+			const statusPath = path.join(ASYNC_DIR, workflowRunId, "status.json");
+			const status = await waitForStatus(statusPath, (value) => value?.state === "failed") as { state?: string; steps?: Array<{ async?: boolean }>; error?: string };
+
+			assert.equal(status.state, "failed");
+			assert.equal(status.steps?.[0]?.async, false);
+			assert.match(status.error ?? "", /gate cannot be combined with acceptance/);
+			assert.deepEqual(getActiveAsyncCapacitySnapshot(parentSessionId, 1), { used: 0, limit: 1 });
+
+			const next = await executor.execute(
+				"workflow-prep-capacity-next",
+				{ workflowScript: `return "ok";`, async: true },
+				new AbortController().signal,
+				undefined,
+				ctx,
+			);
+			assert.equal(next.isError, undefined);
+			const nextWorkflowRunId = next.details?.asyncId;
+			assert.ok(nextWorkflowRunId, "expected the next async workflow to acquire capacity");
+			await waitForFile(path.join(RESULTS_DIR, `${nextWorkflowRunId}.json`));
+		} finally {
+			fs.rmSync(path.join(ACTIVE_ASYNC_CAPACITY_DIR, activeAsyncCapacitySessionKey(parentSessionId)), { recursive: true, force: true });
+		}
+	});
+
+	it("restores active capacity when revival fails before startup proceed", async () => {
+		const parentSessionId = `session-resume-handshake-${Date.now()}`;
+		const sourceRunId = `resume-handshake-source-${Date.now()}`;
+		const sourceAsyncDir = path.join(ASYNC_DIR, sourceRunId);
+		const sessionFile = path.join(tempDir, "resume-handshake-child.jsonl");
+		fs.mkdirSync(sourceAsyncDir, { recursive: true });
+		fs.writeFileSync(sessionFile, "", "utf-8");
+		fs.writeFileSync(path.join(sourceAsyncDir, "status.json"), JSON.stringify({
+			runId: sourceRunId,
+			sessionId: parentSessionId,
+			mode: "single",
+			state: "complete",
+			startedAt: 100,
+			lastUpdate: 200,
+			cwd: tempDir,
+			sessionFile,
+			steps: [{ agent: "worker", status: "complete", sessionFile }],
+		}, null, 2), "utf-8");
+		writeRecoveryDescriptor(sourceAsyncDir, sourceRunId);
+		const sourceCapacity = acquireActiveAsyncCapacity({ sessionId: parentSessionId, limit: 1, runId: sourceRunId, kind: "runner", asyncDir: sourceAsyncDir });
+		assert.ok(sourceCapacity);
+		sourceCapacity.markStarted("source-runner");
+		fs.writeFileSync(path.join(sourceAsyncDir, "process-terminal.json"), JSON.stringify({
+			version: 1,
+			state: "observed",
+			runId: sourceRunId,
+			runnerProcessInstanceId: "source-runner",
+			observedAt: Date.now(),
+			instances: [{ kind: "runner", processInstanceId: "source-runner", closeObservedAt: Date.now(), exitCode: 0, signal: null }],
+		}), "utf-8");
+		const competingLease = acquireSessionLease({ sessionFile, runId: "competing-revival", sourceRunId, parentSessionId });
+		try {
+			const { executor } = makeExecutor({ maxActiveAsyncRunsPerSession: 1 });
+			const ctx = makeMinimalCtx(tempDir);
+			ctx.sessionManager.getSessionId = () => parentSessionId;
+			const failed = await executor.execute(
+				"resume-handshake-failure",
+				{ action: "resume", id: sourceRunId, message: "Retry safely" },
+				new AbortController().signal,
+				undefined,
+				ctx,
+			);
+			assert.equal(failed.isError, true);
+			assert.match(failed.content[0]?.text ?? "", /already owned by run 'competing-revival'/);
+			const revivedStatusDirs = fs.readdirSync(ASYNC_DIR)
+				.map((name) => path.join(ASYNC_DIR, name))
+				.filter((dir) => {
+					try {
+						const status = JSON.parse(fs.readFileSync(path.join(dir, "status.json"), "utf-8"));
+						return status.sessionId === parentSessionId && status.runId !== sourceRunId && status.processTerminal?.runnerProcessInstanceId;
+					} catch {
+						return false;
+					}
+				});
+			assert.equal(revivedStatusDirs.length, 1, "expected one failed revived run with runner identity");
+			fs.rmSync(path.join(revivedStatusDirs[0]!, "process-terminal.json"), { force: true });
+			assert.deepEqual(getActiveAsyncCapacitySnapshot(parentSessionId, 1), { used: 0, limit: 1 });
+		} finally {
+			competingLease.release();
+			getActiveAsyncCapacitySnapshot(parentSessionId, 1);
+			fs.rmSync(sourceAsyncDir, { recursive: true, force: true });
+		}
+	});
+
 	it("resume action revives a completed foreground child by index", async () => {
 		mockPi.onCall({ output: "first child done" });
 		mockPi.onCall({ output: "second child done" });
@@ -1031,7 +1296,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		try {
 			const original = await executor.execute(
 				"foreground-lease-original",
-				{ agent: "builder", task: "Original task" },
+				{ agent: "worker", task: "Original task" },
 				new AbortController().signal,
 				undefined,
 				makeMinimalCtx(tempDir),
@@ -1746,11 +2011,11 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 
 	it("does not treat a synthetic foreground startup error as child output", async () => {
 		mockPi.onCall({ output: "", stderr: "mock startup failure", exitCode: 1 });
-		const { executor, events } = makeExecutor({ resultDelivery: true, agents: [makeAgent("builder")] });
+		const { executor, events } = makeExecutor({ resultDelivery: true, agents: [makeAgent("worker")] });
 
 		await executor.execute(
 			"foreground-synthetic-error",
-			{ agent: "builder", task: "synthetic-error-task" },
+			{ agent: "worker", task: "synthetic-error-task" },
 			new AbortController().signal,
 			undefined,
 			makeMinimalCtx(tempDir),