@selesai/code 0.13.40 → 0.14.3

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

@@ -17,7 +17,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { setChildSessionFactoryModule } from "../../src/runs/shared/child-session.ts";
 import { createEventBus, createTempDir, events, makeAgent, removeTempDir } from "../support/helpers.ts";
-import { deliverInterruptRequest, deliverStopRequest } from "../../src/runs/background/control-channel.ts";
+import { deliverInterruptRequest, deliverStopRequest, requestAsyncSteer } from "../../src/runs/background/control-channel.ts";
 import { SUBAGENT_PROCESS_TERMINAL_EVENT } from "../../src/shared/types.ts";
 import { waitForSubagents } from "../../src/runs/background/subagent-wait.ts";
 import type { AsyncResultPayload, AsyncStatusPayload } from "../support/async-execution-fixture.ts";
@@ -178,9 +178,21 @@ const args = process.argv.slice(2);
 if (args.includes('--version')) { console.log('wt v0.75.0'); process.exit(0); }
 if (args.includes('--help')) { console.log('--create --base --no-cd --no-hooks --format'); process.exit(0); }
 if (${allocatorFailure}) require('node:child_process').execFileSync('git', ['branch', args[args.indexOf('--create') + 1]], { cwd: ${JSON.stringify(repo)} });
-const socket = require('node:net').connect(${port}, '127.0.0.1', () => socket.write('ready'));
-socket.on('data', data => {
- if (data.toString() === 'release') { socket.end(); if (${allocatorFailure}) process.exitCode = 1; else console.log('{}'); }
+// Complete the setup stdin contract before exposing the independent release gate.
+// Otherwise the hook can exit before the runner writes input and cause EPIPE.
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+ if (!${allocatorFailure}) {
+  const setup = JSON.parse(input);
+  require('node:assert/strict').equal(setup.runId, ${JSON.stringify(`${id}-s0`)});
+  require('node:assert/strict').equal(setup.repoRoot, ${JSON.stringify(fs.realpathSync(repo))});
+ }
+ const socket = require('node:net').connect(${port}, '127.0.0.1', () => socket.write('ready'));
+ socket.on('data', data => {
+  if (data.toString() === 'release') { socket.end(); if (${allocatorFailure}) process.exitCode = 1; else console.log('{}'); }
+ });
 });
 setTimeout(() => process.exit(90), 15000).unref();
 `, { mode: 0o755 });
@@ -195,7 +207,7 @@ setTimeout(() => process.exit(90), 15000).unref();
 				const connection = once(server, "connection", { signal: AbortSignal.timeout(20_000) });
 				const receipt = executeAsyncChain(id, {
 					chain: [{ agent: "worker", task: "Do work", worktree: true }],
-					agents: [makeAgent("worker", { completionGuard: false })],
+					agents: [makeAgent("worker")],
 					ctx: { pi: { events: bus }, cwd: repo, currentSessionId: "session-1" },
 					artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
 					shareEnabled: false, sessionRoot: path.join(tempDir, "sessions"), maxSubagentDepth: 2, acceptance: false,
@@ -527,6 +539,107 @@ setTimeout(() => process.exit(90), 15000).unref();
 		});
 	});
 
+	it("background publishes a structured-only terminal after watchdog settlement", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		await withIsolatedWatchdogSettings(tempDir, async () => {
+			writeWatchdogSettings(tempDir);
+			const id = `async-watchdog-structured-${Date.now().toString(36)}`;
+			const callsBefore = mockPi.callCount();
+			mockPi.onCall({ jsonl: [childWatchdogStatus(id, "idle", 1)], structuredOutput: { ok: true } });
+
+			executeAsyncSingle(id, {
+				agent: "worker", task: "Return data", agentConfig: makeAgent("worker"),
+				ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+				shareEnabled: false, sessionRoot: path.join(tempDir, "sessions"), maxSubagentDepth: 2,
+				structuredOutputSchema: { type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } },
+			});
+
+			const payload = await readAsyncPayload(id);
+			assert.equal(payload.success, true, payload.results[0]?.error);
+			assert.deepEqual(payload.results[0]?.structuredOutput, { ok: true });
+			assert.equal((payload.results[0] as { watchdog?: { phase?: string } }).watchdog?.phase, "idle");
+			assert.equal(mockPi.callCount(), callsBefore + 1, "settled structured completion must not continue with another turn");
+		});
+	});
+
+	for (const terminal of ["error", "aborted"] as const) {
+		it(`background preserves structured evidence when a later ${terminal} terminal keeps the run failed`, { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+			const id = `async-structured-${terminal}-${Date.now().toString(36)}`;
+			const terminalMessage = {
+				type: "message_end",
+				message: {
+					role: "assistant",
+					content: [],
+					model: "mock/test-model",
+					stopReason: terminal,
+					errorMessage: terminal === "error" ? "later provider failure" : "This operation was aborted",
+					usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } },
+				},
+			};
+			mockPi.onCall({
+				structuredOutputCapture: { ok: true },
+				jsonl: [
+					{ type: "tool_execution_start", toolName: "structured_output", args: { value: { ok: true } } },
+					{ type: "tool_result_end", message: { role: "toolResult", toolName: "structured_output", content: [{ type: "text", text: "Structured output captured." }] } },
+					{ type: "tool_execution_end", toolName: "structured_output" },
+					terminalMessage,
+				],
+			});
+
+			executeAsyncSingle(id, {
+				agent: "worker", task: "Return data, then fail", agentConfig: makeAgent("worker"), acceptance: false,
+				ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+				shareEnabled: false, sessionRoot: path.join(tempDir, "sessions"), maxSubagentDepth: 2,
+				structuredOutputSchema: { type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } },
+			});
+
+			const payload = await readAsyncPayload(id);
+			// The runner publishes the result before the terminal status.
+			const status = await waitForAsyncState(id, (candidate) => candidate.state !== "running" && candidate.state !== "queued");
+			const child = payload.results[0]!;
+			assert.equal(payload.success, false);
+			assert.equal(payload.state, "failed");
+			assert.equal(child.success, false);
+			assert.deepEqual(child.structuredOutput, { ok: true });
+			assert.ok(child.structuredOutputPath);
+			assert.deepEqual(JSON.parse(fs.readFileSync(child.structuredOutputPath, "utf-8")), { ok: true });
+			assert.equal(status.state, "failed");
+			assert.equal(status.steps?.[0]?.status, "failed");
+			assert.deepEqual(status.steps?.[0]?.structuredOutput, { ok: true });
+			assert.equal(status.steps?.[0]?.structuredOutputPath, child.structuredOutputPath);
+		});
+	}
+
+	it("background keeps invalid and missing structured captures absent", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		for (const capture of ["invalid", "missing"] as const) {
+			const id = `async-structured-${capture}-${Date.now().toString(36)}`;
+			mockPi.onCall(capture === "invalid" ? {
+				jsonl: [
+					{ type: "tool_execution_start", toolName: "structured_output", args: { value: { ok: "invalid" } } },
+					{ type: "tool_result_end", message: { role: "toolResult", toolName: "structured_output", content: [{ type: "text", text: "Structured output validation failed." }], isError: true } },
+					{ type: "tool_execution_end", toolName: "structured_output", isError: true },
+					events.assistantMessage("done"),
+				],
+			} : { output: "done" });
+
+			executeAsyncSingle(id, {
+				agent: "worker", task: "Return data", agentConfig: makeAgent("worker"), acceptance: false,
+				ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+				shareEnabled: false, sessionRoot: path.join(tempDir, "sessions"), maxSubagentDepth: 2,
+				structuredOutputSchema: { type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } },
+			});
+
+			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.results[0]?.structuredOutput, undefined);
+			assert.equal(status.steps?.[0]?.structuredOutput, undefined);
+			assert.equal(fs.existsSync(path.join(ASYNC_DIR, id, "structured-output", "output.json")), false);
+		}
+	});
+
 	it("background child watchdog tail timeout still finalizes successful output", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		await withIsolatedWatchdogSettings(tempDir, async () => {
 			writeWatchdogSettings(tempDir, 150);
@@ -564,7 +677,7 @@ setTimeout(() => process.exit(90), 15000).unref();
 		await withIsolatedWatchdogSettings(tempDir, async () => {
 			writeWatchdogSettings(tempDir);
 			const id = `async-watchdog-blocker-${Date.now().toString(36)}`;
-			mockPi.onCall({ jsonl: [events.acceptanceReport(), events.watchdogWarning("blocker", "Claims tests passed without running them")] });
+			mockPi.onCall({ jsonl: [events.acceptanceReport(), events.watchdogStatusWarning("blocker", "Claims tests passed without running them", { runId: id, agent: "worker", childIndex: 0 })], structuredOutput: { ok: true } });
 
 			executeAsyncSingle(id, {
 				agent: "worker",
@@ -576,12 +689,14 @@ setTimeout(() => process.exit(90), 15000).unref();
 				sessionRoot: path.join(tempDir, "sessions"),
 				maxSubagentDepth: 2,
 				acceptance: { level: "checked", criteria: ["Ship it"] },
+				structuredOutputSchema: { type: "object", required: ["ok"], properties: { ok: { type: "boolean" } } },
 			});
 
 			const resultPath = await waitForAsyncResultFile(id, 10_000);
 			const payload = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as AsyncResultPayload;
 			assert.equal(payload.success, false);
 			const child = payload.results[0] as AsyncResultPayload["results"][number] & { watchdog?: { warnings?: Array<{ severity: string; addressed: boolean; summary: string }> } };
+			assert.deepEqual(child.structuredOutput, { ok: true }, "a real blocker remains visible alongside valid structured evidence");
 			assert.deepEqual(child.watchdog?.warnings?.map((warning) => [warning.severity, warning.addressed]), [["blocker", false]]);
 			const check = child.acceptance?.runtimeChecks?.find((entry) => entry.id === "watchdog-blocker");
 			assert.equal(check?.status, "failed");
@@ -589,6 +704,79 @@ setTimeout(() => process.exit(90), 15000).unref();
 		});
 	});
 
+	it("background does not abort when a steer arrives after the final stop and turn_start is delayed", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({
+			jsonl: [events.assistantMessage("before steer")],
+			keepAliveAfterFinalMessageMs: 15_000,
+			queuedMessageTurnStartDelayMs: 1400,
+			queuedMessageOutput: "after steer",
+		});
+		const id = `async-queued-steer-after-final-${Date.now().toString(36)}`;
+		executeAsyncSingle(id, {
+			agent: "worker", task: "Do work", agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false, sessionRoot: path.join(tempDir, "sessions"), maxSubagentDepth: 2,
+		});
+		await waitForMockPiCall(mockPi, 0, 10_000);
+		const scriptedFinal = path.join(mockPi.dir, "scripted-final.jsonl");
+		const deadline = Date.now() + 10_000;
+		while (!fs.existsSync(scriptedFinal)) {
+			if (Date.now() > deadline) assert.fail("Timed out waiting for scripted final message");
+			await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+		requestAsyncSteer(path.join(ASYNC_DIR, id), { message: "Continue after the final stop.", id: "after-final", ts: Date.now() });
+		const payload = await readAsyncPayload(id);
+		assert.equal(payload.success, true, payload.results[0]?.error);
+		assert.equal(payload.results[0]?.error, undefined);
+		assert.equal(payload.results[0]?.output, "after steer");
+		assert.doesNotMatch(JSON.stringify(payload), /did not settle within \d+ms after its terminal event/);
+	});
+
+	for (const type of ["turn_start", "agent_start", "auto_retry_start"]) {
+		it(`background keeps resumed work alive after ${type}`, { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+			const id = `async-resumed-${type}-${Date.now().toString(36)}`;
+			mockPi.onCall({
+				steps: [
+					{ jsonl: [events.assistantMessage("before continuation"), { type }] },
+					// Queued steering/follow-up work is allowed to outlive the old final-stop grace.
+					{ delay: 1400, jsonl: [events.assistantMessage("after continuation")] },
+				],
+			});
+			executeAsyncSingle(id, {
+				agent: "worker", task: "Do work", agentConfig: makeAgent("worker"),
+				ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+				shareEnabled: false, sessionRoot: path.join(tempDir, "sessions"), maxSubagentDepth: 2,
+			});
+			const payload = await readAsyncPayload(id);
+			assert.equal(payload.success, true, payload.results[0]?.error);
+			assert.equal(payload.results[0]?.output, "after continuation");
+		});
+	}
+
+	it("background ignores stale watchdog completion after resumed work", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		await withIsolatedWatchdogSettings(tempDir, async () => {
+			writeWatchdogSettings(tempDir);
+			const id = `async-resumed-watchdog-${Date.now().toString(36)}`;
+			mockPi.onCall({
+				steps: [
+					{ jsonl: [events.assistantMessage("before continuation"), { type: "turn_start" }, childWatchdogStatus(id, "idle", 1)] },
+					{ delay: 1400, jsonl: [events.assistantMessage("after continuation")] },
+				],
+			});
+			executeAsyncSingle(id, {
+				agent: "worker", task: "Do work", agentConfig: makeAgent("worker"),
+				ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+				shareEnabled: false, sessionRoot: path.join(tempDir, "sessions"), maxSubagentDepth: 2,
+			});
+			const payload = await readAsyncPayload(id);
+			assert.equal(payload.success, true, payload.results[0]?.error);
+			assert.equal(payload.results[0]?.output, "after continuation");
+		});
+	});
+
 	it("background forced drain after final assistant output is cleanup success", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({
 			jsonl: [events.assistantMessage("async-done-before-drain")],
@@ -773,8 +961,6 @@ setTimeout(() => process.exit(90), 15000).unref();
 			assert.equal(child?.success, false);
 			assert.match(diagnostic, /^Subagent produced no output after terminal assistant stopReason "aborted"\./);
 			assert.match(diagnostic, new RegExp(`Required file-only output was not produced: ${escapeRegExp(outputPath)}`));
-			assert.doesNotMatch(diagnostic, /completed without making edits/);
-			assert.doesNotMatch(child?.modelAttempts?.[0]?.error ?? "", /completed without making edits/);
 			assert.equal(child?.effects?.fileMutation?.status, "observed");
 			assert.equal(child?.effects?.fileMutation?.attempted, true);
 			assert.deepEqual(child?.effects?.fileMutation?.evidence?.changedFiles, ["input.md"]);
@@ -785,8 +971,6 @@ setTimeout(() => process.exit(90), 15000).unref();
 			assert.equal(status.activityState, "needs_attention");
 			assert.equal(status.steps?.[0]?.activityState, "needs_attention");
 			assert.equal(status.steps?.[0]?.error, diagnostic);
-			const eventsText = fs.readFileSync(path.join(ASYNC_DIR, id, "events.jsonl"), "utf-8");
-			assert.doesNotMatch(eventsText, /completed without making edits/);
 		} finally {
 			removeTempDir(repo);
 		}
@@ -837,14 +1021,10 @@ setTimeout(() => process.exit(90), 15000).unref();
 		assert.equal(child?.success, false);
 		assert.match(diagnostic, /^Subagent produced no output after terminal assistant stopReason "aborted"\./);
 		assert.match(diagnostic, /Required file-only output was not produced/);
-		assert.doesNotMatch(diagnostic, /completed without making edits/);
-		assert.doesNotMatch(child?.modelAttempts?.[0]?.error ?? "", /completed without making edits/);
 		assert.equal(child?.effects?.settlementDiagnostic?.requiredOutput?.missing, true);
 		assert.equal(child?.effects?.settlementDiagnostic?.finalTextPresent, true);
 		assert.equal(fs.existsSync(outputPath), false);
 
-		const eventsText = fs.readFileSync(path.join(ASYNC_DIR, id, "events.jsonl"), "utf-8");
-		assert.doesNotMatch(eventsText, /completed without making edits/);
 	});
 
 	it("reports bounded compaction failure context when file-only output is missing", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
@@ -894,7 +1074,6 @@ setTimeout(() => process.exit(90), 15000).unref();
 		assert.equal(payload.success, false);
 		assert.equal(child?.success, false);
 		assert.match(diagnostic, /^This operation was aborted/);
-		assert.match(diagnostic, /Compaction-induced child abort could not be resumed safely: retained session unavailable\./);
 		assert.match(diagnostic, /failure followed session compaction and agent settlement/);
 		assert.match(diagnostic, /Required file-only output was not produced/);
 		assert.ok(diagnostic.length <= 8_192);
@@ -919,7 +1098,7 @@ setTimeout(() => process.exit(90), 15000).unref();
 		const sourceId = `partial-source-${Date.now().toString(36)}`;
 		const sourceDir = path.join(ASYNC_DIR, sourceId);
 		const message = "Required file-only output was not produced: report.md";
-		const effects = { fileMutation: { status: "observed", expected: true, attempted: true, evidence: { source: "tracked-files", trackedOnly: true, cwd: tempDir, changedFiles: ["input.md"], attemptedMutation: true } } };
+		const effects = { fileMutation: { status: "observed", attempted: true, evidence: { source: "tracked-files", trackedOnly: true, cwd: tempDir, changedFiles: ["input.md"], attemptedMutation: true } } };
 		fs.mkdirSync(sourceDir, { recursive: true });
 		fs.writeFileSync(path.join(sourceDir, "status.json"), JSON.stringify({
 			runId: sourceId,
@@ -989,7 +1168,7 @@ setTimeout(() => process.exit(90), 15000).unref();
 					concurrency: 2,
 				}],
 				resultMode: "parallel",
-				agents: [makeAgent("partial", { output: outputPath, outputMode: "file-only" }), makeAgent("failure", { completionGuard: false })],
+				agents: [makeAgent("partial", { output: outputPath, outputMode: "file-only" }), makeAgent("failure")],
 				ctx: { pi: { events: { emit() {} } }, cwd: repo, currentSessionId: "session-1" },
 				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
 				shareEnabled: false,
@@ -1012,6 +1191,28 @@ setTimeout(() => process.exit(90), 15000).unref();
 		}
 	});
 
+	it("notifies once for each distinct long-open background command", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		mockPi.onCall({ steps: [
+			{ jsonl: [{ type: "tool_execution_start", toolCallId: "bash-first", toolName: "bash", args: { command: "sleep 2" } }] },
+			{ delay: 2200, jsonl: [{ type: "tool_execution_end", toolCallId: "bash-first", toolName: "bash" }, events.toolResult("bash", "done")] },
+			{ jsonl: [{ type: "tool_execution_start", toolCallId: "bash-second", toolName: "bash", args: { command: "sleep 2" } }] },
+			{ delay: 2200, jsonl: [{ type: "tool_execution_end", toolCallId: "bash-second", toolName: "bash" }, events.toolResult("bash", "done"), events.assistantMessage("Done")] },
+		] });
+		const id = `async-sequential-attention-${Date.now().toString(36)}`;
+		executeAsyncSingle(id, {
+			agent: "worker", task: "Run commands", agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false, sessionRoot: path.join(tempDir, "sessions"), maxSubagentDepth: 2,
+			controlConfig: { enabled: true, needsAttentionAfterMs: 999_999, activeNoticeAfterMs: 100, failedToolAttemptsBeforeAttention: 3, notifyOn: ["needs_attention"], notifyChannels: ["event", "async"] },
+		});
+		const result = await readAsyncPayload(id);
+		assert.equal(result.success, true);
+		const rows = fs.readFileSync(path.join(ASYNC_DIR, id, "events.jsonl"), "utf8").trim().split("\n").map((line) => JSON.parse(line));
+		const attention = rows.filter((row) => row.type === "subagent.control" && row.event?.reason === "tool_open_threshold").map((row) => row.event.toolCallId);
+		assert.deepEqual(attention, ["bash-first", "bash-second"]);
+	});
+
 	it("background runs emit active-long-running control events from child turns", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		mockPi.onCall({
 			steps: [
@@ -1202,6 +1403,52 @@ setTimeout(() => process.exit(90), 15000).unref();
 		await waitForAsyncResultFile(id);
 	});
 
+	it("background open-tool attention survives a supervisor request that ends first", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+		const id = `async-supervisor-then-tool-attention-${Date.now().toString(36)}`;
+		const supervisorReleasePath = path.join(tempDir, `${id}.supervisor`);
+		const finalReleasePath = path.join(tempDir, `${id}.final`);
+		mockPi.onCall({ steps: [
+			{ jsonl: [
+				{ type: "tool_execution_start", toolCallId: "bash-1", toolName: "bash", args: { command: "sleep 5" } },
+				{ type: "tool_execution_start", toolCallId: "decision", toolName: "contact_supervisor", args: { reason: "need_decision", message: "Choose" } },
+			] },
+			{ waitForPath: supervisorReleasePath, jsonl: [{ type: "tool_execution_end", toolCallId: "decision", toolName: "contact_supervisor" }] },
+			{ waitForPath: finalReleasePath, jsonl: [{ type: "tool_execution_end", toolCallId: "bash-1", toolName: "bash" }, events.toolResult("bash", "done"), events.assistantMessage("Done")] },
+		] });
+		const eventsPath = path.join(ASYNC_DIR, id, "events.jsonl");
+		const statusPath = path.join(ASYNC_DIR, id, "status.json");
+		executeAsyncSingle(id, {
+			agent: "worker", task: "Run the command", agentConfig: makeAgent("worker"),
+			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+			shareEnabled: false, sessionRoot: path.join(tempDir, "sessions"), maxSubagentDepth: 2,
+			controlConfig: { enabled: true, needsAttentionAfterMs: 999_999, activeNoticeAfterMs: 100, failedToolAttemptsBeforeAttention: 3, notifyOn: ["needs_attention"], notifyChannels: ["event", "async"] },
+		});
+		try {
+			const deadline = Date.now() + 10_000;
+			while (Date.now() < deadline && !(fs.existsSync(eventsPath) && fs.readFileSync(eventsPath, "utf-8").includes('"reason":"tool_open_threshold"'))) {
+				await new Promise((resolve) => setTimeout(resolve, 50));
+			}
+			assert.match(fs.readFileSync(eventsPath, "utf-8"), /"reason":"tool_open_threshold"/);
+			fs.writeFileSync(supervisorReleasePath, "");
+			let status: AsyncStatusPayload | undefined;
+			while (Date.now() < deadline) {
+				status = JSON.parse(fs.readFileSync(statusPath, "utf-8")) as AsyncStatusPayload;
+				// The supervisor call's end is in recentTools only after its cleanup ran.
+				if (status.steps?.[0]?.recentTools?.some((tool) => tool.tool === "contact_supervisor")) break;
+				await new Promise((resolve) => setTimeout(resolve, 50));
+			}
+			assert.ok(status?.steps?.[0]?.recentTools?.some((tool) => tool.tool === "contact_supervisor"), "expected the supervisor call to have ended");
+			assert.equal(status?.currentTool, "bash");
+			assert.equal(status?.steps?.[0]?.activityState, "needs_attention");
+			assert.equal(status?.activityState, "needs_attention");
+		} finally {
+			fs.writeFileSync(supervisorReleasePath, "");
+			fs.writeFileSync(finalReleasePath, "");
+			await waitForAsyncResultFile(id);
+		}
+	});
+
 	it("bg_wait wakes when an async child is waiting on contact_supervisor", { skip: !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
 		const id = `async-supervisor-attention-${Date.now().toString(36)}`;
 		const replyReleasePath = path.join(tempDir, `${id}.reply`);