@selesai/code 0.5.20 → 0.5.21

package/dist/extensions/pi-subagents/test/unit/completion-guard.test.ts

@@ -8,6 +8,7 @@ import {
 	expectsImplementationMutation,
 	hasMutationToolCall,
 } from "../../src/runs/shared/completion-guard.ts";
+import { isMutatingTool } from "../../src/runs/shared/long-running-guard.ts";
 
 function assistantToolCall(name: string, args: Record<string, unknown> = {}): Message {
 	return {
@@ -52,7 +53,28 @@ test("declared read-only builtin tools suppress implementation-word false positi
 	});
 });
 
-test("omitted, empty, bash, unknown, write, and MCP tool capabilities stay conservative", () => {
+test("read-only issue drafting tasks do not trigger on suggested fix wording", () => {
+	const task = "Draft GitHub issue for pi-subagents bug from current conversation. Include title, environment/context, reproduction steps, actual/expected, logs excerpt, suspected cause, suggested fix. Terse but complete. No tools needed.";
+	const result = evaluateCompletionMutationGuard({
+		agent: "delegate",
+		task,
+		messages: [assistantText("Title: completionGuard false positive\n\nSuggested fix: model read-only intent.")],
+		tools: ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"],
+	});
+
+	assert.deepEqual(result, {
+		expectedMutation: false,
+		attemptedMutation: false,
+		triggered: false,
+	});
+	assert.equal(expectsImplementationMutation("worker", task), false);
+	assert.equal(
+		expectsImplementationMutation("worker", "Draft GitHub issue for a bug. Include suspected cause and suggested fix."),
+		false,
+	);
+});
+
+test("omitted, bash, unknown, write, and MCP tool capabilities stay conservative while empty tools are toolless", () => {
 	const base = {
 		agent: "architect",
 		task: "Implement the approved source fix",
@@ -60,7 +82,7 @@ test("omitted, empty, bash, unknown, write, and MCP tool capabilities stay conse
 	};
 
 	assert.equal(evaluateCompletionMutationGuard(base).triggered, true);
-	assert.equal(evaluateCompletionMutationGuard({ ...base, tools: [] }).triggered, true);
+	assert.equal(evaluateCompletionMutationGuard({ ...base, tools: [] }).triggered, false);
 	assert.equal(evaluateCompletionMutationGuard({ ...base, tools: ["read", "bash", "ls"] }).triggered, true);
 	assert.equal(evaluateCompletionMutationGuard({ ...base, tools: ["read", "custom_lookup"] }).triggered, true);
 	assert.equal(evaluateCompletionMutationGuard({ ...base, tools: ["read", "write"] }).triggered, true);
@@ -82,6 +104,22 @@ test("worker with mutating-capable tools still triggers when no mutation is obse
 	});
 });
 
+test("oracle review tasks with bash available do not require mutation", () => {
+	const task = "Review prep findings and determine what to implement with playbooks instead of before.";
+	const result = evaluateCompletionMutationGuard({
+		agent: "oracle",
+		task,
+		messages: [assistantText("Review complete with file-backed findings.")],
+		tools: ["read", "grep", "find", "ls", "bash", "intercom"],
+	});
+
+	assert.deepEqual(result, {
+		expectedMutation: false,
+		attemptedMutation: false,
+		triggered: false,
+	});
+});
+
 test("review-only, research, and framework output instructions do not expect mutation", () => {
 	assert.equal(expectsImplementationMutation("worker", "Review only: return findings, do not edit"), false);
 	assert.equal(expectsImplementationMutation("worker", "Do not edit files. Tell me how to fix the bug."), false);
@@ -105,13 +143,27 @@ test("review-only, research, and framework output instructions do not expect mut
 	);
 });
 
-test("worker implementation verbs win over investigative wording", () => {
+test("worker implementation verbs win over investigative wording and scoped prohibitions", () => {
 	assert.equal(expectsImplementationMutation("worker", "Investigate why the worker did not edit files and fix it"), true);
+	assert.equal(expectsImplementationMutation("worker", "Do not modify tests; implement the fix"), true);
+	assert.equal(expectsImplementationMutation("worker", "Do not modify tests — implement the fix"), true);
 	assert.equal(expectsImplementationMutation("worker", "Research the current code path and patch the bug"), true);
 	assert.equal(expectsImplementationMutation("worker", "Fix the bug where no edits were made"), true);
+	assert.equal(expectsImplementationMutation("worker", "Fix lint"), true);
+	assert.equal(expectsImplementationMutation("worker", "Fix the build"), true);
+	assert.equal(expectsImplementationMutation("worker", "Fix TypeScript errors"), true);
+	assert.equal(expectsImplementationMutation("worker", "Fix CI"), true);
+	assert.equal(expectsImplementationMutation("worker", "Fix the failing test"), true);
+	assert.equal(expectsImplementationMutation("worker", "Patch the cold start test"), true);
 	assert.equal(expectsImplementationMutation("worker", "Implement the fix and return findings."), true);
 });
 
+test("non-worker implementation tasks still expect mutation", () => {
+	assert.equal(expectsImplementationMutation("delegate", "Fix the bug where no edits were made"), true);
+	assert.equal(expectsImplementationMutation("delegate", "Apply the suggested fix to src/runs/shared/completion-guard.ts"), true);
+	assert.equal(expectsImplementationMutation("worker", "Draft a GitHub issue, then implement the fix"), true);
+});
+
 test("worker edit intent covers common docs, config, and source tasks", () => {
 	assert.equal(expectsImplementationMutation("worker", "Update README to mention the native tool"), true);
 	assert.equal(expectsImplementationMutation("worker", "Remove share functionality and all Vercel references"), true);
@@ -150,3 +202,123 @@ test("implementation task with mutation attempts does not trigger", () => {
 
 	assert.equal(result.triggered, false);
 });
+
+function assistantThinking(thinking: string): Message {
+	return {
+		role: "assistant",
+		content: [{ type: "thinking", thinking }],
+	} as unknown as Message;
+}
+
+test("Cursor edit/write thinking traces count as mutation attempts", () => {
+	assert.equal(
+		hasMutationToolCall([assistantThinking("Cursor edit: docs/BACKEND_ARCHITECTURE.md added 10 lines, removed 3 lines\n")]),
+		true,
+	);
+	assert.equal(
+		hasMutationToolCall([assistantThinking("Cursor write: src/file.ts created\n")]),
+		true,
+	);
+	assert.equal(
+		hasMutationToolCall([assistantThinking("I plan to edit the file next\n")]),
+		false,
+	);
+	assert.equal(
+		hasMutationToolCall([assistantThinking("Cursor read: docs/BACKEND_ARCHITECTURE.md\n")]),
+		false,
+	);
+});
+
+test("Cursor replay tool calls count only edit/write activity as mutation", () => {
+	const cursorEdit = { activityTitle: "Cursor edit", path: "docs/BACKEND_ARCHITECTURE.md" };
+	const cursorWrite = { activityTitle: "Cursor write", path: "src/file.ts" };
+	assert.equal(hasMutationToolCall([assistantToolCall("cursor", cursorEdit)]), true);
+	assert.equal(hasMutationToolCall([assistantToolCall("cursor", cursorWrite)]), true);
+	assert.equal(hasMutationToolCall([assistantToolCall("cursor", { activityTitle: "Cursor read" })]), false);
+	assert.equal(isMutatingTool("cursor", cursorEdit), true);
+	assert.equal(isMutatingTool("cursor", { activityTitle: "Cursor read" }), false);
+});
+
+test("claimed changedFiles without mutation evidence does not bypass the guard", () => {
+	const report = assistantText(`Done.\n\`\`\`acceptance-report\n{\n  "changedFiles": ["docs/BACKEND_ARCHITECTURE.md"]\n}\n\`\`\``);
+	assert.equal(hasMutationToolCall([report]), false);
+});
+
+function checkpointDataEntry(beforeCommit: string, afterCommit: string): Message {
+	return {
+		type: "custom",
+		customType: "pi-checkpoint",
+		data: { beforeCommit, afterCommit },
+	} as unknown as Message;
+}
+
+function checkpointDetailsMessage(beforeCommit: string, afterCommit: string): Message {
+	return {
+		role: "custom",
+		customType: "pi-checkpoint",
+		content: [],
+		details: { beforeCommit, afterCommit },
+	} as unknown as Message;
+}
+
+function checkpointNestedDetailsMessage(beforeCommit: string, afterCommit: string): Message {
+	return {
+		role: "custom",
+		customType: "pi-checkpoint",
+		content: [],
+		details: { data: { beforeCommit, afterCommit } },
+	} as unknown as Message;
+}
+
+test("provider checkpoint with a changed commit counts as mutation evidence", () => {
+	for (const message of [
+		checkpointDataEntry("before", "after"),
+		checkpointDetailsMessage("before", "after"),
+		checkpointNestedDetailsMessage("before", "after"),
+	]) {
+		assert.equal(hasMutationToolCall([message]), true);
+		assert.equal(
+			evaluateCompletionMutationGuard({
+				agent: "worker",
+				task: "Edit the target source file",
+				messages: [message],
+			}).triggered,
+			false,
+		);
+	}
+});
+
+test("unchanged provider checkpoint does not bypass the completion guard", () => {
+	for (const message of [
+		checkpointDataEntry("same", "same"),
+		checkpointDetailsMessage("same", "same"),
+		checkpointNestedDetailsMessage("same", "same"),
+	]) {
+		assert.equal(hasMutationToolCall([message]), false);
+		assert.equal(
+			evaluateCompletionMutationGuard({
+				agent: "worker",
+				task: "Edit the target source file",
+				messages: [message],
+			}).triggered,
+			true,
+		);
+	}
+});
+
+test("implementation task with Cursor edit thinking does not trigger", () => {
+	const result = evaluateCompletionMutationGuard({
+		agent: "worker",
+		task: "Edit docs/BACKEND_ARCHITECTURE.md",
+		messages: [
+			assistantThinking("Cursor edit: docs/BACKEND_ARCHITECTURE.md added 1 line\n"),
+			assistantText("Implemented the six simplifications."),
+		],
+		tools: ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"],
+	});
+	assert.deepEqual(result, {
+		expectedMutation: true,
+		attemptedMutation: true,
+		triggered: false,
+	});
+});

package/dist/extensions/pi-subagents/test/unit/config-dir-runtime.test.ts

@@ -4,20 +4,20 @@ import os from "node:os";
 import path from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
 import { fileURLToPath } from "node:url";
-import { getConfigDirName, PI_CODING_AGENT_PACKAGE_ROOT_ENV, resolveConfigDirName } from "../../src/shared/utils.ts";
+import { getConfigDirName, SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV, resolveConfigDirName, resolveWatchPath } from "../../src/shared/utils.ts";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 let previousPackageRootEnv: string | undefined;
 
 describe("config directory resolution", () => {
 	beforeEach(() => {
-		previousPackageRootEnv = process.env[PI_CODING_AGENT_PACKAGE_ROOT_ENV];
-		delete process.env[PI_CODING_AGENT_PACKAGE_ROOT_ENV];
+		previousPackageRootEnv = process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+		delete process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
 	});
 
 	afterEach(() => {
-		if (previousPackageRootEnv === undefined) delete process.env[PI_CODING_AGENT_PACKAGE_ROOT_ENV];
-		else process.env[PI_CODING_AGENT_PACKAGE_ROOT_ENV] = previousPackageRootEnv;
+		if (previousPackageRootEnv === undefined) delete process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV];
+		else process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV] = previousPackageRootEnv;
 	});
 
 	it("falls back without importing the Pi peer package at runtime", () => {
@@ -65,6 +65,11 @@ describe("config directory resolution", () => {
 		}
 	});
 
+	it("canonicalizes watcher paths and preserves the original path when native realpath fails", () => {
+		assert.equal(resolveWatchPath("C:\\SHORT~1\\watch", () => "C:\\Long Path\\watch"), "C:\\Long Path\\watch");
+		assert.equal(resolveWatchPath("C:\\SHORT~1\\watch", () => { throw new Error("missing"); }), "C:\\SHORT~1\\watch");
+	});
+
 	it("does not runtime-import the coding agent peer from shared utils", () => {
 		const source = fs.readFileSync(path.join(repoRoot, "src/shared/utils.ts"), "utf-8");
 		assert.doesNotMatch(source, /import\s+[^;]*from\s+["']@earendil-works\/pi-coding-agent["']/);

package/dist/extensions/pi-subagents/test/unit/control-channel.test.ts

@@ -4,13 +4,25 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import {
+	closeSteerInbox,
 	consumeInterruptRequest,
+	consumeSteerAcks,
+	consumeSteerCapabilities,
 	consumeSteerRequests,
+	consumeStopRequest,
 	deliverInterruptRequest,
 	enqueueStepSteer,
 	interruptRequestPath,
 	requestAsyncInterrupt,
 	requestAsyncSteer,
+	requestAsyncStop,
+	steerAckPathFromDir,
+	steerAcksDir,
+	steerInboxClosedPath,
+	steerCapabilityPath,
+	writeSteerAck,
+	writeSteerCapability,
+	stopRequestPath,
 	steerRequestsDir,
 	stepSteerInboxDir,
 	watchAsyncControlInbox,
@@ -40,6 +52,23 @@ describe("control channel: request file", () => {
 		}
 	});
 
+	it("writes and consumes a stop request", () => {
+		const asyncDir = tmpAsyncDir("pi-control-stop-");
+		try {
+			const requestPath = requestAsyncStop(asyncDir, { source: "test" }, { now: () => 1234 });
+			assert.equal(requestPath, stopRequestPath(asyncDir));
+			const data = JSON.parse(fs.readFileSync(requestPath, "utf-8"));
+			assert.equal(data.type, "stop");
+			assert.equal(data.ts, 1234);
+			assert.equal(data.source, "test");
+			assert.equal(consumeStopRequest(asyncDir), true);
+			assert.equal(fs.existsSync(stopRequestPath(asyncDir)), false);
+			assert.equal(consumeStopRequest(asyncDir), false);
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
 	it("keeps the request type authoritative even for untyped callers", () => {
 		const asyncDir = tmpAsyncDir("pi-control-write-type-");
 		try {
@@ -80,11 +109,11 @@ describe("control channel: request file", () => {
 		const asyncDir = tmpAsyncDir("pi-control-steer-");
 		try {
 			requestAsyncSteer(asyncDir, { message: "  later guidance  ", targetIndex: 1, id: "b", ts: 200, source: "test" });
-			requestAsyncSteer(asyncDir, { message: "first guidance", id: "a", ts: 100 });
+			requestAsyncSteer(asyncDir, { message: "first guidance", targetIndexes: [0, 2], id: "a", ts: 100 });
 			assert.equal(fs.readdirSync(steerRequestsDir(asyncDir)).length, 2);
 
 			assert.deepEqual(consumeSteerRequests(asyncDir), [
-				{ type: "steer", id: "a", ts: 100, message: "first guidance" },
+				{ type: "steer", id: "a", ts: 100, message: "first guidance", targetIndexes: [0, 2] },
 				{ type: "steer", id: "b", ts: 200, message: "later guidance", targetIndex: 1, source: "test" },
 			]);
 			assert.deepEqual(consumeSteerRequests(asyncDir), []);
@@ -93,6 +122,18 @@ describe("control channel: request file", () => {
 		}
 	});
 
+	it("rejects requests after the runner closes the steering inbox", () => {
+		const asyncDir = tmpAsyncDir("pi-control-steer-closed-");
+		try {
+			closeSteerInbox(asyncDir, "complete");
+			assert.equal(fs.existsSync(steerInboxClosedPath(asyncDir)), true);
+			assert.throws(() => requestAsyncSteer(asyncDir, { message: "too late", targetIndexes: [0] }), /no longer accepts steering/);
+			assert.equal(fs.existsSync(steerRequestsDir(asyncDir)), false);
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
 	it("keeps steer request ids out of filesystem paths", () => {
 		const asyncDir = tmpAsyncDir("pi-control-steer-safe-name-");
 		try {
@@ -132,9 +173,10 @@ describe("control channel: request file", () => {
 	it("enqueues a steer request for a specific child inbox", () => {
 		const asyncDir = tmpAsyncDir("pi-control-step-steer-");
 		try {
-			enqueueStepSteer(asyncDir, 2, { type: "steer", id: "s1", ts: 300, message: "focus", targetIndex: 0 });
+			enqueueStepSteer(asyncDir, 2, { type: "steer", id: "s1", ts: 300, message: "focus", targetIndexes: [0, 1] });
 			const request = JSON.parse(fs.readFileSync(path.join(stepSteerInboxDir(asyncDir, 2), fs.readdirSync(stepSteerInboxDir(asyncDir, 2))[0]!), "utf-8"));
 			assert.equal(request.targetIndex, 2);
+			assert.equal(request.targetIndexes, undefined);
 			assert.equal(request.message, "focus");
 		} finally {
 			cleanup(asyncDir);
@@ -146,6 +188,44 @@ describe("control channel: request file", () => {
 		try {
 			assert.throws(() => requestAsyncSteer(asyncDir, { message: "   " }), /steer message must not be empty/);
 			assert.throws(() => requestAsyncSteer(asyncDir, { message: "ok", targetIndex: -1 }), /targetIndex/);
+			assert.throws(() => requestAsyncSteer(asyncDir, { message: "ok", targetIndex: 1_000_001 }), /targetIndex/);
+			assert.throws(() => requestAsyncSteer(asyncDir, { message: "ok", targetIndexes: [] }), /targetIndexes/);
+			assert.throws(() => requestAsyncSteer(asyncDir, { message: "ok", targetIndexes: [0, 0] }), /targetIndexes/);
+			assert.throws(() => requestAsyncSteer(asyncDir, { message: "ok", targetIndex: 0, targetIndexes: [0] }), /targetIndexes/);
+			assert.throws(() => requestAsyncSteer(asyncDir, { message: "ok", targetIndexes: "bad" as unknown as number[] }), /targetIndexes/);
+			assert.throws(() => requestAsyncSteer(asyncDir, { message: "x".repeat(128 * 1024 + 1) }), /exceeds/);
+			assert.throws(() => requestAsyncSteer(asyncDir, { message: "ok", id: "contains whitespace" }), /malformed/);
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
+	it("writes strict capabilities and acknowledgments with safe paths", () => {
+		const asyncDir = tmpAsyncDir("pi-control-steer-ack-");
+		try {
+			const capabilityPath = writeSteerCapability(asyncDir, { index: 0, pid: 42, readyAt: 100, supported: true });
+			assert.equal(capabilityPath, steerCapabilityPath(asyncDir, 0));
+			writeSteerAck(asyncDir, { requestId: "../request", index: 0, ts: 101, state: "delivered", message: "accepted" });
+			assert.equal(path.dirname(steerAckPathFromDir(steerAcksDir(asyncDir, 0), "../request")), steerAcksDir(asyncDir, 0));
+			assert.deepEqual(consumeSteerCapabilities(asyncDir), [{ type: "steer-capability", protocolVersion: 1, index: 0, pid: 42, readyAt: 100, supported: true }]);
+			assert.deepEqual(consumeSteerAcks(asyncDir), [{ type: "steer-ack", protocolVersion: 1, requestId: "../request", index: 0, ts: 101, state: "delivered", message: "accepted" }]);
+			assert.deepEqual(consumeSteerAcks(asyncDir), []);
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
+	it("ignores malformed capabilities and acknowledgments", () => {
+		const asyncDir = tmpAsyncDir("pi-control-steer-malformed-");
+		try {
+			fs.mkdirSync(path.join(asyncDir, "control", "steer-capabilities"), { recursive: true });
+			fs.writeFileSync(steerCapabilityPath(asyncDir, 0), JSON.stringify({ type: "steer-capability", protocolVersion: 99 }), "utf-8");
+			fs.mkdirSync(steerAcksDir(asyncDir, 0), { recursive: true });
+			fs.writeFileSync(path.join(steerAcksDir(asyncDir, 0), "bad.json"), JSON.stringify({ type: "steer-ack", protocolVersion: 1, requestId: "", index: 0, ts: 1, state: "delivered", message: "bad" }), "utf-8");
+			fs.writeFileSync(path.join(asyncDir, "control", "steer-acks", "1"), "not a directory", "utf-8");
+			writeSteerAck(asyncDir, { requestId: "valid", index: 2, ts: 2, state: "delivered", message: "accepted" });
+			assert.deepEqual(consumeSteerCapabilities(asyncDir), []);
+			assert.deepEqual(consumeSteerAcks(asyncDir), [{ type: "steer-ack", protocolVersion: 1, requestId: "valid", index: 2, ts: 2, state: "delivered", message: "accepted" }]);
 		} finally {
 			cleanup(asyncDir);
 		}
@@ -234,18 +314,24 @@ describe("control channel: watchAsyncControlInbox", () => {
 		timers: import("../../src/runs/background/control-channel.ts").ControlChannelTimers;
 		trigger: () => void;
 		closed: () => boolean;
+		watchedDir: () => string | undefined;
 	};
 
-	function harness(): WatchHarness {
+	function harness(nativeDir?: string): WatchHarness {
 		let listener: (() => void) | undefined;
 		let closed = false;
+		let watchedDir: string | undefined;
+		const realpathSync = ((target: fs.PathLike, options?: unknown) => fs.realpathSync(target, options as BufferEncoding)) as typeof fs.realpathSync;
+		realpathSync.native = ((target: fs.PathLike) => nativeDir ?? fs.realpathSync.native(target)) as typeof fs.realpathSync.native;
 		const fsImpl = {
 			mkdirSync: fs.mkdirSync,
 			existsSync: fs.existsSync,
 			rmSync: fs.rmSync,
 			readdirSync: fs.readdirSync,
 			readFileSync: fs.readFileSync,
-			watch: ((_dir: string, cb: () => void) => {
+			realpathSync,
+			watch: ((dir: string, cb: () => void) => {
+				watchedDir = dir;
 				listener = cb;
 				return { close: () => { closed = true; }, on: () => {} };
 			}),
@@ -254,9 +340,22 @@ describe("control channel: watchAsyncControlInbox", () => {
 			setInterval: (() => ({ unref() {} })) as unknown as typeof setInterval,
 			clearInterval: (() => {}) as unknown as typeof clearInterval,
 		};
-		return { fsImpl, timers, trigger: () => listener?.(), closed: () => closed };
+		return { fsImpl, timers, trigger: () => listener?.(), closed: () => closed, watchedDir: () => watchedDir };
 	}
 
+	it("registers the native canonical control inbox path", () => {
+		const asyncDir = tmpAsyncDir("pi-control-watch-native-");
+		try {
+			const nativeDir = path.join(path.dirname(asyncDir), "native-control-path");
+			const h = harness(nativeDir);
+			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt() {}, fs: h.fsImpl, timers: h.timers });
+			assert.equal(h.watchedDir(), nativeDir);
+			dispose();
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
 	it("fires on a request that arrived before the watcher started", () => {
 		const asyncDir = tmpAsyncDir("pi-control-watch-early-");
 		try {
@@ -301,6 +400,27 @@ describe("control channel: watchAsyncControlInbox", () => {
 		}
 	});
 
+	it("delivers stop requests before interrupt requests", () => {
+		const asyncDir = tmpAsyncDir("pi-control-watch-stop-early-");
+		try {
+			requestAsyncStop(asyncDir);
+			requestAsyncInterrupt(asyncDir);
+			const events: string[] = [];
+			const h = harness();
+			const dispose = watchAsyncControlInbox(asyncDir, {
+				onInterrupt: () => events.push("interrupt"),
+				onStop: () => events.push("stop"),
+				fs: h.fsImpl,
+				timers: h.timers,
+			});
+
+			assert.deepEqual(events, ["stop", "interrupt"]);
+			dispose();
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
 	it("delivers steer requests without firing interrupt", () => {
 		const asyncDir = tmpAsyncDir("pi-control-watch-steer-");
 		try {