@selesai/code 0.8.4 → 0.8.5

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

@@ -25,6 +25,7 @@ import { registerSubagentCapabilityCeiling } from "../../src/api/capability-ceil
 import { resolveSubagentLaunchContract } from "../../src/api/preflight.ts";
 import { discoverAgents } from "../../src/agents/agents.ts";
 import { runSync } from "../../src/runs/foreground/execution.ts";
+import { ACTIVE_ASYNC_CAPACITY_DIR, acquireActiveAsyncCapacity, activeAsyncCapacitySessionKey } from "../../src/runs/background/active-async-capacity.ts";
 
 interface LaunchResolvedExtensions {
 	version?: number;
@@ -80,7 +81,7 @@ interface AsyncResultPayload {
 	totalCost?: { inputTokens: number; outputTokens: number; costUsd: number };
 	usageBudget?: UsageBudgetState;
 	checkpoint?: { name?: string; status?: string };
-	results: Array<{ agent?: string; launchContractDigest?: string; launchResolvedExtensions?: LaunchResolvedExtensions; runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions; output?: 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 }; outputSaveError?: string; metadataSaveError?: string; capabilityCeiling?: { version?: number; allowedTools?: string[]; denyExtensions?: boolean; sources?: string[] }; capabilityAudit?: { effectiveTools?: string[]; removedTools?: string[]; extensionsDenied?: boolean } }>;
+	results: Array<{ agent?: string; launchContractDigest?: string; launchResolvedExtensions?: LaunchResolvedExtensions; runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions; output?: 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; transcriptPath?: string }; outputSaveError?: string; metadataSaveError?: 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 };
@@ -572,6 +573,8 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 			acceptance: false,
 		});
 		assert.match(launch.details.launchContractDigest ?? "", /^[a-f0-9]{64}$/);
+		const recovery = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "recovery-descriptor.json"), "utf-8")) as { runFanoutBudget?: { rootRunId?: string; limit?: number } };
+		assert.deepEqual(recovery.runFanoutBudget && { rootRunId: recovery.runFanoutBudget.rootRunId, limit: recovery.runFanoutBudget.limit }, { rootRunId: id, limit: 64 });
 		const payload = await readAsyncPayload(id);
 		const status = await waitForAsyncState(id, (candidate) => candidate.state === "complete" && candidate.runtimeAcknowledgedExtensions !== undefined);
 		assert.equal(payload.launchContractDigest, launch.details.launchContractDigest);
@@ -796,6 +799,44 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		}
 	});
 
+	it("redacts async task text from durable artifacts, transcripts, and metadata", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ output: "async redaction complete" });
+		const id = `async-prompt-redaction-${Date.now().toString(36)}`;
+		const sentinel = "ASYNC_RAW_PROMPT_SENTINEL_1021";
+		executeAsyncSingle(id, {
+			agent: "worker",
+			task: `Handle ${sentinel} without persisting it`,
+			agentConfig: makeAgent("worker", { completionGuard: false }),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: true, includeInput: true, includeOutput: true, includeJsonl: false, includeTranscript: true, includeMetadata: true, cleanupDays: 7 },
+			artifactsDir: path.join(tempDir, ".pi-subagents", "artifacts"),
+			shareEnabled: false,
+			maxSubagentDepth: 2,
+			acceptance: false,
+		});
+
+		await waitForMockPiCall(mockPi, 0);
+		const callFile = fs.readdirSync(mockPi.dir).find((name) => name.endsWith(".json"));
+		assert.ok(callFile);
+		const call = JSON.parse(fs.readFileSync(path.join(mockPi.dir, callFile), "utf-8")) as { args?: string[] };
+		assert.match(call.args?.join("\n") ?? "", new RegExp(sentinel));
+
+		const payload = await readAsyncPayload(id);
+		const artifactPaths = payload.results[0]?.artifactPaths;
+		assert.ok(artifactPaths?.inputPath);
+		assert.ok(artifactPaths.metadataPath);
+		assert.ok(artifactPaths.transcriptPath);
+		const inputText = fs.readFileSync(artifactPaths.inputPath, "utf-8");
+		const transcriptText = fs.readFileSync(artifactPaths.transcriptPath, "utf-8");
+		const metadataText = fs.readFileSync(artifactPaths.metadataPath, "utf-8");
+		assert.doesNotMatch(inputText, new RegExp(sentinel));
+		assert.doesNotMatch(transcriptText, new RegExp(sentinel));
+		assert.doesNotMatch(metadataText, new RegExp(sentinel));
+		assert.match(inputText, /\[prompt redacted\]/);
+		assert.match(transcriptText, /\[prompt redacted\]/);
+		assert.equal((JSON.parse(metadataText) as { task?: string }).task, "[prompt redacted]");
+	});
+
 	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)}`;
@@ -1531,8 +1572,8 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.match(singleResult.content[0]?.text ?? "", /Do not run sleep timers or polling loops/);
 		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));
+		assert.equal(startedEvent(singleId).task, "[prompt redacted]");
+		assert.equal(startedEvent(singleId).goal, "[prompt redacted]");
 		await waitForAsyncResultFile(singleId, 30_000);
 
 		mockPi.onCall({ output: "interactive done" });
@@ -1562,7 +1603,7 @@ 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 subagent_wait\(\)/i);
-		assert.equal(startedEvent(parallelId).goal, "Do one");
+		assert.equal(startedEvent(parallelId).goal, "[prompt redacted]");
 		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");
@@ -1581,8 +1622,8 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		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));
+		assert.equal(chainEvent.task, "[prompt redacted]");
+		assert.equal(chainEvent.goal, "[prompt redacted]");
 		await waitForAsyncResultFile(chainId, 10_000);
 	});
 
@@ -3565,6 +3606,55 @@ describe("async execution utilities", { skip: !available ? "pi packages not avai
 		assert.deepEqual(payload.results[0].attemptedModels, ["github-copilot/gpt-5-mini"]);
 	});
 
+	it("rejects an over-cap top-level async launch before creating run artifacts", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
+		fs.rmSync(path.join(ACTIVE_ASYNC_CAPACITY_DIR, activeAsyncCapacitySessionKey("session-cap")), { recursive: true, force: true });
+		const state = {
+			baseCwd: tempDir,
+			currentSessionId: "session-cap",
+			asyncJobs: new Map(),
+			fleetJobs: new Map(),
+			foregroundControls: new Map(),
+			lastForegroundControlId: null,
+		};
+		const occupied = acquireActiveAsyncCapacity({
+			sessionId: "session-cap",
+			limit: 1,
+			runId: "held-run",
+			kind: "runner",
+			asyncDir: path.join(tempDir, "held-run"),
+		});
+		assert.ok(occupied);
+		occupied.markStarted("held-runner");
+		const rejectedAsyncDir = path.join(ASYNC_DIR, "cap-rejected");
+		const rejectedResultPath = path.join(RESULTS_DIR, "cap-rejected.json");
+		fs.rmSync(rejectedAsyncDir, { recursive: true, force: true });
+		fs.rmSync(rejectedResultPath, { force: true });
+		const executor = createSubagentExecutor!({
+			pi: { events: createEventBus(), getSessionName: () => undefined },
+			state,
+			config: { maxActiveAsyncRunsPerSession: 1, artifactDir: "project" },
+			asyncByDefault: false,
+			tempArtifactsDir: tempDir,
+			getSubagentSessionRoot: () => path.join(tempDir, "sessions"),
+			expandTilde: (p: string) => p,
+			discoverAgents: () => ({ agents: [makeAgent("worker")] }),
+		});
+		const context = makeMinimalCtx(tempDir);
+		context.sessionManager.getSessionFile = () => null;
+		context.sessionManager.getSessionId = () => "session-cap";
+		const previousDepth = process.env.SELESAI_SUBAGENT_DEPTH;
+		process.env.SELESAI_SUBAGENT_DEPTH = "0";
+		const result = await executor.execute("cap-rejected", { agent: "worker", task: "Must not start", async: true }, new AbortController().signal, undefined, context);
+		if (previousDepth === undefined) delete process.env.SELESAI_SUBAGENT_DEPTH;
+		else process.env.SELESAI_SUBAGENT_DEPTH = previousDepth;
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.type === "text" ? result.content[0].text : "", /Active async run capacity exhausted: 1\/1 used/);
+		assert.equal(fs.existsSync(rejectedAsyncDir), false);
+		assert.equal(fs.existsSync(rejectedResultPath), false);
+		assert.equal(fs.existsSync(path.join(tempDir, ".pi-subagents")), false);
+		fs.rmSync(path.join(ACTIVE_ASYNC_CAPACITY_DIR, activeAsyncCapacitySessionKey("session-cap")), { recursive: true, force: true });
+	});
+
 	it("scheduled executor launches retain the live active session ownership", { skip: !isAsyncAvailable() || !createSubagentExecutor ? "jiti or executor not available" : undefined }, async () => {
 		mockPi.onCall({ output: "Scheduled work completed" });
 		const liveCwd = path.join(tempDir, "live-project");

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

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import { describe, it } from "node:test";
 import { formatAsyncRunList, listAsyncRuns } from "../../src/runs/background/async-status.ts";
 import { ACTIVE_RUN_INDEX_DIR, updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
+import { claimRunFanoutBatch, createRunFanoutBudget, writeRunFanoutBudgetDescriptor } from "../../src/runs/shared/run-fanout-budget.ts";
 
 function createAsyncDir(root: string, id: string, status: Record<string, unknown>): string {
 	const dir = path.join(root, id);
@@ -17,9 +18,10 @@ function createAsyncDir(root: string, id: string, status: Record<string, unknown
 describe("async status helpers", () => {
 	it("lists only requested states and includes flattened step summaries", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-"));
+		let budgetDirectory: string | undefined;
 		try {
 			const outputFile = path.join(root, "run-a", "output-1.log");
-			createAsyncDir(root, "run-a", {
+			const runDir = createAsyncDir(root, "run-a", {
 				runId: "run-a",
 				mode: "chain",
 				state: "running",
@@ -27,12 +29,17 @@ describe("async status helpers", () => {
 				lastUpdate: 200,
 				cwd: "/repo-a",
 				currentStep: 1,
+				runFanoutBudget: { used: 2, limit: 64, remaining: 62 },
 				outputFile,
 				steps: [
 					{ agent: "scout", status: "complete", durationMs: 10, description: "Inspect auth only" },
 					{ agent: "worker", status: "running", durationMs: 20, description: "Patch billing only" },
 				],
 			});
+			const descriptor = createRunFanoutBudget("run-a", 64);
+			budgetDirectory = descriptor.directory;
+			writeRunFanoutBudgetDescriptor(runDir, descriptor);
+			claimRunFanoutBatch(descriptor, ["chain[0]", "chain[1]", "chain[1]/single"]);
 			createAsyncDir(root, "run-b", {
 				runId: "run-b",
 				mode: "single",
@@ -51,9 +58,12 @@ describe("async status helpers", () => {
 			assert.equal(runs[0]?.steps[1]?.status, "running");
 			assert.equal(runs[0]?.steps[0]?.description, "Inspect auth only");
 			assert.equal(runs[0]?.steps[1]?.description, "Patch billing only");
-			assert.match(formatAsyncRunList(runs), /output: .*output-1\.log/);
+			const text = formatAsyncRunList(runs);
+			assert.match(text, /Run fan-out: 3\/64 used, 61 remaining/);
+			assert.match(text, /output: .*output-1\.log/);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
+			if (budgetDirectory) fs.rmSync(budgetDirectory, { recursive: true, force: true });
 		}
 	});
 
@@ -597,7 +607,7 @@ describe("async status helpers", () => {
 		}
 	});
 
-	it("prunes terminal active markers while preserving history listing", () => {
+	it("keeps terminal active markers until observed process-terminal proof releases them", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-index-prune-"));
 		try {
 			const asyncDir = createAsyncDir(root, "finished", {
@@ -606,13 +616,26 @@ describe("async status helpers", () => {
 				state: "complete",
 				startedAt: 100,
 				lastUpdate: 200,
+				displayDismissedAt: 250,
+				processTerminal: { version: 1, state: "unknown", runId: "finished", runnerProcessInstanceId: "runner", reason: "process-tree-unverified" },
 				steps: [{ agent: "worker", status: "complete" }],
 			});
 			updateActiveRunIndex(asyncDir, "running");
+			const markerPath = path.join(root, ACTIVE_RUN_INDEX_DIR, "finished");
+
+			assert.deepEqual(listAsyncRuns(root, { states: ["running"], reconcile: false }), []);
+			assert.equal(fs.existsSync(markerPath), true);
 
+			fs.writeFileSync(path.join(asyncDir, "process-terminal.json"), JSON.stringify({
+				version: 1,
+				state: "observed",
+				runId: "finished",
+				runnerProcessInstanceId: "runner",
+				observedAt: 300,
+				instances: [{ kind: "runner", processInstanceId: "runner", closeObservedAt: 300, exitCode: 0, signal: null }],
+			}), "utf-8");
 			assert.deepEqual(listAsyncRuns(root, { states: ["running"], reconcile: false }), []);
-			assert.equal(fs.existsSync(path.join(root, ACTIVE_RUN_INDEX_DIR, "finished")), false);
-			assert.deepEqual(listAsyncRuns(root, { states: ["complete"], reconcile: false }).map((run) => run.id), ["finished"]);
+			assert.equal(fs.existsSync(markerPath), false);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}

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

@@ -667,10 +667,11 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		);
 
 		assert.ok(!result.isError);
-		const step2Task = result.details.results[1].task;
+		assert.equal(result.details.results[1].task, "[prompt redacted]");
+		const step2Task = readCallArgs(1).at(-1) ?? "";
 		assert.ok(
 			step2Task.includes("MARKER_ABC_123"),
-			`step 2 task should contain step 1 output via {previous}: ${step2Task.slice(0, 200)}`,
+			`step 2 invocation should contain step 1 output via {previous}: ${step2Task.slice(0, 200)}`,
 		);
 	});
 
@@ -1164,10 +1165,11 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		);
 
 		assert.ok(!result.isError);
-		const workerTask = result.details.results[0].task;
+		assert.equal(result.details.results[0].task, "[prompt redacted]");
+		const workerTask = readCallArgs(0).at(-1) ?? "";
 		assert.ok(
 			workerTask.includes("the authentication module"),
-			`should substitute {task}: ${workerTask.slice(0, 200)}`,
+			`should substitute {task} in the child invocation: ${workerTask.slice(0, 200)}`,
 		);
 	});
 
@@ -1566,7 +1568,8 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 
 		assert.ok(!result.isError);
 		assert.equal(result.details.results.length, 3);
-		const synthTask = result.details.results[2].task;
+		assert.equal(result.details.results[2].task, "[prompt redacted]");
+		const synthTask = readCallArgs(2).at(-1) ?? "";
 		assert.ok(
 			synthTask.includes("=== Parallel Task 1 (reviewer-a) ==="),
 			"synthesizer should include reviewer-a output block",

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

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import type { MockPi } from "../support/helpers.ts";
 import { createEventBus, createMockPi, createTempDir, events, removeTempDir, tryImport } from "../support/helpers.ts";
 import { discoverAgents } from "../../src/agents/agents.ts";
+import { ACTIVE_ASYNC_CAPACITY_DIR, acquireActiveAsyncCapacity, activeAsyncCapacitySessionKey } from "../../src/runs/background/active-async-capacity.ts";
 import { DEFAULT_FORK_PREAMBLE, INTERCOM_DETACH_REQUEST_EVENT, SUBAGENT_ASYNC_STARTED_EVENT } from "../../src/shared/types.ts";
 
 interface ExecutorModule {
@@ -1523,6 +1524,7 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		const rawParallelChainGoal = "Parallel chain first child raw goal";
 		const paddedWorkflowGoal = "  preserve this workflow padding  ";
 		const literalPreambleGoal = `${DEFAULT_FORK_PREAMBLE}\n\nTask:\nliteral fresh-context text`;
+		const redactedGoal = "[prompt redacted]";
 		const executor = makeExecutorWithDiscoverAgents(() => ({
 			agents: [
 				{ name: "echo", description: "Echo", defaultContext: "fork" },
@@ -1576,13 +1578,91 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 			assert.ok(result.details?.asyncId, `${testCase.name}: expected an async id`);
 			const event = started.find((entry) => entry.id === result.details?.asyncId);
 			assert.ok(event, `${testCase.name}: missing async-started event for ${result.details?.asyncId}`);
-			assert.equal(event.goal, testCase.goal, testCase.name);
+			assert.equal(event.goal, redactedGoal, testCase.name);
 			if (!("allowsLiteralPreamble" in testCase)) {
 				assert.doesNotMatch(event.goal ?? "", /delegated subagent running from a fork/, testCase.name);
+				assert.notEqual(event.goal, testCase.goal, testCase.name);
 			}
 		}
 	});
 
+	it("rejects Clarify background switches over the active async capacity cap", { skip: !asyncAvailable ? "jiti not available" : undefined }, async () => {
+		const previousDepth = process.env.SELESAI_SUBAGENT_DEPTH;
+		process.env.SELESAI_SUBAGENT_DEPTH = "0";
+		try {
+			for (const testCase of [
+				{
+					name: "single",
+					mode: "single",
+					params: { agent: "echo", task: "Original single", async: true, clarify: true },
+					templates: ["Edited single"],
+				},
+				{
+					name: "parallel",
+					mode: "parallel",
+					params: { tasks: [{ agent: "echo", task: "Original parallel" }, { agent: "second", task: "Second child" }], async: true, clarify: true },
+					templates: ["Edited parallel", "Second child"],
+				},
+				{
+					name: "chain",
+					mode: "chain",
+					params: { chain: [{ agent: "echo", task: "Original chain" }], async: true, clarify: true },
+					templates: ["Edited chain"],
+				},
+			] as const) {
+				const sessionId = `session-clarify-cap-${testCase.name}-${Date.now()}`;
+				const sessionCapacityDir = path.join(ACTIVE_ASYNC_CAPACITY_DIR, activeAsyncCapacitySessionKey(sessionId));
+				fs.rmSync(sessionCapacityDir, { recursive: true, force: true });
+				const held = acquireActiveAsyncCapacity({
+					sessionId,
+					limit: 1,
+					runId: `held-${testCase.name}`,
+					kind: "runner",
+					asyncDir: path.join(tempDir, `held-${testCase.name}`),
+				});
+				held?.markStarted(`held-runner-${testCase.name}`);
+				try {
+					const executor = makeExecutorWithConfig({ maxActiveAsyncRunsPerSession: 1 });
+					const manager = {
+						...makeSessionManagerRecorder().manager,
+						getSessionId: () => sessionId,
+					};
+					const ctx = {
+						...makeCtx(manager),
+						hasUI: true,
+						ui: {
+							custom: async () => ({
+								confirmed: true,
+								templates: testCase.templates,
+								behaviorOverrides: testCase.templates.map(() => undefined),
+								runInBackground: true,
+							}),
+						},
+					};
+
+					const result = await executor.execute(
+						`clarify-cap-${testCase.name}`,
+						testCase.params,
+						new AbortController().signal,
+						undefined,
+						ctx,
+					);
+
+					assert.equal(result.isError, true, testCase.name);
+					assert.equal(result.details?.mode, testCase.mode, testCase.name);
+					assert.equal(result.details?.asyncId, undefined, testCase.name);
+					assert.match(result.content[0]?.text ?? "", /Active async run capacity exhausted: 1\/1 used/, testCase.name);
+					assert.equal(mockPi.callCount(), 0, testCase.name);
+				} finally {
+					fs.rmSync(sessionCapacityDir, { recursive: true, force: true });
+				}
+			}
+		} finally {
+			if (previousDepth === undefined) delete process.env.SELESAI_SUBAGENT_DEPTH;
+			else process.env.SELESAI_SUBAGENT_DEPTH = previousDepth;
+		}
+	});
+
 	it("uses edited raw goals when clarification switches each mode to background", { skip: !asyncAvailable ? "jiti not available" : undefined }, async () => {
 		const executor = makeExecutorWithDiscoverAgents(() => ({
 			agents: [
@@ -1640,7 +1720,8 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 			assert.equal(result.isError, undefined, testCase.name);
 			assert.ok(result.details?.asyncId, `${testCase.name}: expected an async id`);
 			const event = started.find((entry) => entry.id === result.details?.asyncId);
-			assert.equal(event?.goal, testCase.goal, testCase.name);
+			assert.equal(event?.goal, "[prompt redacted]", testCase.name);
+			assert.notEqual(event?.goal, testCase.goal, testCase.name);
 			assert.doesNotMatch(event?.goal ?? "", /delegated subagent running from a fork/, testCase.name);
 		}
 	});