@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/unit/supervisor-ask-registration.test.ts

@@ -1,10 +1,11 @@
 import assert from "node:assert/strict";
-import * as fs from "node:fs";
+import fsDefault, * as fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
 import * as os from "node:os";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
 import { execFileSync } from "node:child_process";
-import { afterEach, describe, it } from "node:test";
+import { afterEach, describe, it, type TestContext } from "node:test";
 import {
 	NATIVE_SUPERVISOR_TOOL_NAME,
 	createNativeSupervisorChannel,
@@ -15,7 +16,11 @@ import {
 import { steerWorkflowForegroundTarget } from "../../src/runs/foreground/workflow-foreground-steering.ts";
 import { createSubagentExecutor } from "../../src/runs/foreground/subagent-executor.ts";
 import type { ForegroundRunControl, ForegroundSteerInput, SubagentState } from "../../src/shared/types.ts";
-import { DIRS } from "../../src/shared/types.ts";
+import { DIRS, SUBAGENT_ASYNC_STARTED_EVENT } from "../../src/shared/types.ts";
+import { runSync } from "../../src/runs/foreground/execution.ts";
+import { setChildSessionFactory, type ChildSessionFactory, type ChildSessionLaunch, type ChildSessionEvent } from "../../src/runs/shared/child-session.ts";
+import { createEventBus, makeAgent } from "../support/helpers.ts";
+import { buildInProcessChildLaunch } from "../../src/runs/shared/child-launch.ts";
 
 const createdChannels: string[] = [];
 
@@ -41,10 +46,10 @@ function makeState(sessionId: string | null, ctx: unknown): SubagentState {
 	};
 }
 
-function makeCtx(sessionId: string, sessionFile: string | null = null): { cwd: string; hasUI: boolean; sessionManager: { getSessionId: () => string; getSessionFile: () => string | null; getEntries: () => [] } } {
+function makeCtx(sessionId: string, sessionFile: string | null = null): { cwd: string; isIdle: () => boolean; hasUI: boolean; sessionManager: { getSessionId: () => string; getSessionFile: () => string | null; getEntries: () => [] } } {
 	return {
 		cwd: process.cwd(),
-		hasUI: false,
+		isIdle() { return false; }, hasUI: false,
 		sessionManager: {
 			getSessionId: () => sessionId,
 			getSessionFile: () => sessionFile,
@@ -100,7 +105,449 @@ afterEach(() => {
 	for (const channel of createdChannels.splice(0)) fs.rmSync(channel, { recursive: true, force: true });
 });
 
+/** Deterministic session/model seam: real launch hooks and tools, with the host's tool allowlist. */
+function hookRuntime(launch: ChildSessionLaunch, platform: NodeJS.Platform, signal: AbortSignal) {
+	type Tool = { execute(id: string, params: Record<string, unknown>, signal: AbortSignal, update: undefined, ctx: unknown): Promise<{
+		content: Array<{ type: string; text?: string }>; isError?: boolean;
+		details: { asyncDir: string; pending: Array<{ id: string; agent: string }>; requestId?: string; replyTo?: string };
+	}> };
+	const owner = randomUUID();
+	const sessionFile = path.join(launch.cwd, `${owner}.jsonl`);
+	const ctx = { ...makeCtx(owner, sessionFile), cwd: launch.cwd, ui: {}, modelRegistry: { getAvailable: () => [] } };
+	const registered = new Map<string, Tool>();
+	const handlers = new Map<string, Array<(event: unknown, ctx: unknown) => unknown>>();
+	const subscribers = new Set<(event: ChildSessionEvent) => void>();
+	const notices: Array<{ customType?: string; details?: { requestId?: string } }> = [];
+	const active = () => [...registered.keys()].filter(name => (!launch.tools || launch.tools.includes(name)) && !launch.excludeTools?.includes(name));
+	let closed = false;
+	const pi = {
+		events: createEventBus(),
+		on(name: string, handler: (event: unknown, ctx: unknown) => unknown) { handlers.set(name, [...(handlers.get(name) ?? []), handler]); },
+		registerTool(tool: Tool & { name: string }) { registered.set(tool.name, tool); },
+		getAllTools: () => active().map(name => ({ name, sourceInfo: { source: name === "read" ? "builtin" : "extension" } })),
+		getSessionName: () => "shared-name",
+		setSessionName() {},
+		sendMessage(message: typeof notices[number]) { if (message.customType === "subagent_supervisor_request") notices.push(message); },
+	};
+	registered.set("read", { execute: async () => { throw new Error("fixture has no model-authored read calls"); } });
+	// Capture each native channel's platform without changing unrelated executor filesystem behavior.
+	const descriptor = Object.getOwnPropertyDescriptor(process, "platform")!;
+	try {
+		Object.defineProperty(process, "platform", { ...descriptor, value: platform });
+		for (const hook of launch.hooks) hook.factory(pi as never);
+	} finally { Object.defineProperty(process, "platform", descriptor); }
+	return {
+		owner, sessionFile, registered, active, notices, events: pi.events,
+		get closed() { return closed; },
+		subscribe(listener: (event: ChildSessionEvent) => void) { subscribers.add(listener); return () => { subscribers.delete(listener); }; },
+		async emit(type: string, fields = {}) {
+			if (type === "session_shutdown") { if (closed) return; closed = true; }
+			const event = { type, ...fields };
+			for (const handler of handlers.get(type) ?? []) await handler(event, ctx);
+			for (const listener of subscribers) listener(event);
+		},
+		async call(name: string, params: Record<string, unknown>) {
+			assert.ok(active().includes(name), `Tool '${name}' is not active in ${launch.runtime.agent}`);
+			return registered.get(name)!.execute(randomUUID(), params, signal, undefined, ctx);
+		},
+	};
+}
+
+function captureSupervisorPolling(t: TestContext, allowedDirs: Set<string>) {
+	const intervals = new Map<object, () => void>();
+	const scans: string[] = [];
+	const watches: string[] = [];
+	let starts = 0;
+	const set = globalThis.setInterval;
+	const clear = globalThis.clearInterval;
+	t.mock.method(globalThis, "setInterval", ((handler: () => void, delay: number, ...args: unknown[]) => {
+		if (delay !== 250) return set(handler, delay, ...args);
+		starts++;
+		const token = { unref() {} };
+		intervals.set(token, handler);
+		return token;
+	}) as typeof setInterval);
+	t.mock.method(globalThis, "clearInterval", ((token: ReturnType<typeof setInterval>) => {
+		if (!intervals.delete(token)) clear(token);
+	}) as typeof clearInterval);
+	const channelRoot = path.dirname(resolveSupervisorChannelDir("fixture", "worker", 0));
+	const readdir = fsDefault.readdirSync;
+	const watch = fsDefault.watch;
+	t.mock.method(fsDefault, "readdirSync", ((dir: fs.PathLike, options: unknown) => {
+		if (String(dir).startsWith(channelRoot)) scans.push(String(dir));
+		return (readdir as (dir: fs.PathLike, options: unknown) => unknown)(dir, options);
+	}) as typeof fsDefault.readdirSync);
+	t.mock.method(fsDefault, "watch", ((dir: fs.PathLike, ...args: unknown[]) => {
+		if (String(dir).startsWith(channelRoot)) watches.push(String(dir));
+		return (watch as (dir: fs.PathLike, ...args: unknown[]) => fs.FSWatcher)(dir, ...args);
+	}) as typeof fsDefault.watch);
+	syncBuiltinESMExports();
+	return {
+		intervals, scans, get starts() { return starts; },
+		tick() { for (const handler of [...intervals.values()]) handler(); },
+		assertScoped() {
+			assert.deepEqual(watches, [], "coordinator must not watch supervisor channels");
+			for (const dir of scans) assert.ok(allowedDirs.has(dir), `Unexpected supervisor scan: ${dir}`);
+		},
+		restore() { t.mock.restoreAll(); syncBuiltinESMExports(); },
+	};
+}
+
 describe("supervisor ask registration", () => {
+	for (const platform of ["darwin", "win32", "linux"] as const) {
+		it(`drains foreground and workflow progress completed between ticks exactly once (${platform})`, async (t) => {
+			const root = fs.mkdtempSync(path.join(os.tmpdir(), "nested-final-progress-"));
+			const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+			process.env.SELESAI_CODING_AGENT_DIR = root;
+			fs.mkdirSync(path.join(root, "agents"), { recursive: true });
+			fs.writeFileSync(path.join(root, "agents", "leaf.md"), "---\nname: leaf\ndescription: Read-only leaf\ntools: read, contact_supervisor\nmodel: mock/test-model\n---\nInspect only.\n");
+			const launch = buildInProcessChildLaunch({
+				host: "parent", cwd: root, childAgentName: "coordinator", childIndex: 0,
+				sessionEnabled: false, tools: ["subagent", "subagent_supervisor"],
+				inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false,
+			});
+			const abort = new AbortController();
+			const runtime = hookRuntime(launch.session, platform, abort.signal);
+			const allowed = new Set<string>();
+			const polling = captureSupervisorPolling(t, allowed);
+			const leaves: ReturnType<typeof hookRuntime>[] = [];
+			setChildSessionFactory({
+				async create(childLaunch) {
+					const leaf = hookRuntime(childLaunch, platform, abort.signal);
+					leaves.push(leaf);
+					const dir = childLaunch.runtime.supervisorChannelDir!;
+					createdChannels.push(dir);
+					allowed.add(path.join(dir, "requests"));
+					assert.equal(childLaunch.runtime.orchestratorSessionId, runtime.owner);
+					await leaf.emit("session_start");
+					return {
+						sessionId: leaf.owner, sessionFile: leaf.sessionFile, modelId: "mock/test-model", messages: [],
+						subscribe: leaf.subscribe, steer: async () => {}, followUp: async () => {},
+						abort: async () => { abort.abort(); }, dispose: () => leaf.emit("session_shutdown"),
+						async prompt() {
+							await leaf.emit("agent_start");
+							await leaf.call("contact_supervisor", { reason: "progress_update", message: "Inspection complete." });
+							await leaf.emit("message_end", { message: { role: "assistant", content: [{ type: "text", text: "Inspection complete." }], model: "mock/test-model", stopReason: "stop", usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } } } });
+							await leaf.emit("agent_end");
+							await leaf.emit("agent_settled");
+						},
+					};
+				},
+				async dispose() {},
+			});
+			try {
+				for (let i = 0; i < 100; i++) writeRequest({ sessionId: runtime.owner, runId: randomUUID(), reason: "progress_update" });
+				await runtime.emit("session_start");
+				assert.equal(polling.intervals.size, 0);
+				assert.equal(polling.scans.length, 0);
+				const workflowPath = path.join(root, "inspect.js");
+				fs.writeFileSync(workflowPath, "return runs.run('inspect', { agent: 'leaf', task: 'Inspect read-only and report progress.', async: false, output: false });");
+				for (const mode of ["foreground", "workflow"] as const) {
+					const params = mode === "foreground"
+						? { agent: "leaf", task: "Inspect read-only and report progress.", async: false, output: false }
+						: { workflow: workflowPath, async: false };
+					const result = await runtime.call("subagent", params);
+					assert.notEqual(result.isError, true, text(result));
+					assert.equal(leaves.at(-1)!.closed, true, "child starts and completes without a timer tick");
+					assert.equal(polling.intervals.size, 1, "final mailbox drain remains scheduled");
+					const scansBeforeDrain = polling.scans.length;
+					polling.tick();
+					assert.equal(polling.scans.length, scansBeforeDrain + 1, "terminal child gets exactly one final mailbox scan");
+					assert.deepEqual(runtime.notices.map(notice => notice.details?.requestId), []);
+					polling.assertScoped();
+					assert.equal(polling.intervals.size, 0, "last drain retires the poller");
+					const scans = polling.scans.length;
+					polling.tick();
+					await runtime.call(NATIVE_SUPERVISOR_TOOL_NAME, { action: "pending" });
+					assert.equal(polling.scans.length, scans, "retired mailboxes are not scanned by idle queries");
+					assert.equal(runtime.notices.length, 0, "progress updates do not notify the parent");
+				}
+				assert.equal(polling.starts, 2, "next launch rearms polling");
+			} finally {
+				abort.abort();
+				setChildSessionFactory(undefined);
+				for (const leaf of leaves) await leaf.emit("session_shutdown");
+				await runtime.emit("session_shutdown");
+				polling.restore();
+				if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+				else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+				fs.rmSync(root, { recursive: true, force: true });
+			}
+		});
+
+		it(`drains direct-async progress completed between ticks and retires only owned mailboxes (${platform})`, async (t) => {
+			const root = fs.mkdtempSync(path.join(os.tmpdir(), "nested-async-final-progress-"));
+			const launch = buildInProcessChildLaunch({
+				host: "parent", cwd: root, childAgentName: "coordinator", childIndex: 0,
+				sessionEnabled: false, tools: ["subagent", "subagent_supervisor"],
+				inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false,
+			});
+			const runtime = hookRuntime(launch.session, platform, new AbortController().signal);
+			const allowed = new Set<string>();
+			const polling = captureSupervisorPolling(t, allowed);
+			try {
+				await runtime.emit("session_start");
+				assert.equal(polling.intervals.size, 0);
+				for (let cycle = 0; cycle < 2; cycle++) {
+					const runId = randomUUID();
+					const dir = resolveSupervisorChannelDir(runId, "leaf", 0);
+					allowed.add(path.join(dir, "requests"));
+					const unrelatedRun = randomUUID();
+					writeRequest({ sessionId: runtime.owner, runId: unrelatedRun, reason: "progress_update" });
+					runtime.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: unrelatedRun, asyncDir: root, agent: "worker", sessionId: "foreign-session" });
+					fs.writeFileSync(path.join(root, "status.json"), JSON.stringify({ runId, state: "running" }));
+					runtime.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: runId, asyncDir: root, agent: "leaf", sessionId: runtime.sessionFile });
+					assert.equal(polling.intervals.size, 1);
+					const progress = writeRequest({ sessionId: runtime.owner, runId, agent: "leaf", reason: "progress_update" });
+					const foreign = writeRequest({ sessionId: "foreign-owner", runId, agent: "leaf", reason: "progress_update" });
+					fs.writeFileSync(path.join(root, "status.json"), JSON.stringify({ runId, state: "complete" }));
+					const scans = polling.scans.length;
+					polling.tick();
+					assert.equal(runtime.notices.at(-1)?.details?.requestId, undefined);
+					polling.assertScoped();
+					assert.equal(runtime.notices.length, 0);
+					assert.equal(polling.scans.length, scans + 1, "terminal mailbox gets exactly one final scan");
+					assert.equal(fs.existsSync(path.join(dir, "requests", `${progress}.json`)), false);
+					assert.equal(fs.existsSync(path.join(dir, "requests", `${foreign}.json`)), true, "foreign requests are never accepted or deleted");
+					assert.equal(polling.intervals.size, 0);
+					await runtime.call(NATIVE_SUPERVISOR_TOOL_NAME, { action: "pending" });
+					polling.tick();
+					assert.equal(polling.scans.length, scans + 1);
+					assert.equal(runtime.notices.length, 0);
+				}
+				assert.equal(polling.starts, 2);
+				const live = randomUUID();
+				allowed.add(path.join(resolveSupervisorChannelDir(live, "leaf", 0), "requests"));
+				fs.writeFileSync(path.join(root, "status.json"), JSON.stringify({ runId: live, state: "running" }));
+				runtime.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: live, asyncDir: root, agent: "leaf", sessionId: runtime.sessionFile });
+				assert.equal(polling.intervals.size, 1);
+				await runtime.emit("session_shutdown");
+				assert.equal(polling.intervals.size, 0, "shutdown closes live polling too");
+			} finally {
+				await runtime.emit("session_shutdown");
+				polling.restore();
+				fs.rmSync(root, { recursive: true, force: true });
+			}
+		});
+	}
+
+	for (const platform of ["darwin", "win32"] as const) {
+		it(`answers nested A → B → C asks through the child hooks and executor (${platform})`, { timeout: 15_000 }, async () => {
+			const root = fs.mkdtempSync(path.join(os.tmpdir(), "nested-supervisor-"));
+			const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+			process.env.SELESAI_CODING_AGENT_DIR = root;
+			const agentsDir = path.join(root, "agents");
+			fs.mkdirSync(agentsDir, { recursive: true });
+			fs.writeFileSync(path.join(agentsDir, "leaf.md"), "---\nname: leaf\ndescription: Read-only leaf\ntools: read, contact_supervisor\nmodel: mock/test-model\n---\nInspect only.\n");
+			const a = randomUUID();
+			const parentTools = new Map<string, SupervisorTool>();
+			const parent = createNativeSupervisorChannel(makePi({ tools: parentTools }) as never, makeState(a, makeCtx(a)), { platform });
+			const runtimes: ReturnType<typeof hookRuntime>[] = [];
+			const workflows: string[] = [];
+			let cRequest: string | undefined;
+			let cReturned = false;
+			let bReturned = false;
+			let bDrainReturnedBeforeReply = false;
+			const abort = new AbortController();
+			const factory: ChildSessionFactory = {
+				async create(launch) {
+					const runtime = hookRuntime(launch, platform, abort.signal);
+					runtimes.push(runtime);
+					if (launch.runtime.supervisorChannelDir) createdChannels.push(launch.runtime.supervisorChannelDir);
+					await runtime.emit("session_start");
+					return {
+						sessionId: runtime.owner, sessionFile: runtime.sessionFile, modelId: "mock/test-model", messages: [],
+						subscribe: runtime.subscribe,
+						steer: async () => { throw new Error("steering is not a supervisor reply"); },
+						followUp: async () => { throw new Error("follow-up is not a supervisor reply"); },
+						abort: async () => { abort.abort(); },
+						dispose: () => runtime.emit("session_shutdown"),
+						async prompt() {
+							await runtime.emit("agent_start");
+							if (launch.runtime.agent === "coordinator") {
+								assert.ok(runtime.registered.has(NATIVE_SUPERVISOR_TOOL_NAME), "B needs a native downward provider");
+								assert.ok(runtime.active().includes(NATIVE_SUPERVISOR_TOOL_NAME), "B's requested supervisor tool must be callable");
+								const workflowPath = path.join(root, "inspect.js");
+								fs.writeFileSync(workflowPath, "return runs.run('inspect', { agent: 'leaf', task: 'Inspect the repository read-only and ask which option to report.', async: false });");
+								const receipt = await runtime.call("subagent", {
+									workflow: workflowPath,
+									async: true,
+								});
+								assert.notEqual(receipt.isError, true, text(receipt));
+								workflows.push(receipt.details.asyncDir);
+								// Enter B's real prompt-runtime final drain before C writes its delayed ask.
+								await runtime.emit("agent_end");
+								bDrainReturnedBeforeReply = true;
+								assert.equal(cReturned, false, "the owner drain must yield before C is replied to");
+								// No explicit pending scan: executor activation must discover C's delayed ask.
+								await waitForCondition(() => runtime.notices.length > 0, "B to discover C's ask without a manual scan");
+								const pending = await runtime.call(NATIVE_SUPERVISOR_TOOL_NAME, { action: "pending" });
+								const [ask] = pending.details.pending;
+								cRequest = ask.id;
+								assert.equal(ask.agent, "leaf");
+								assert.equal(cReturned, false);
+								await assert.rejects(parentTools.get(NATIVE_SUPERVISOR_TOOL_NAME)!.execute("foreign", { action: "reply", replyTo: cRequest, message: "A cannot answer C" }), /No pending supervisor request found/);
+								await assert.rejects(runtime.call(NATIVE_SUPERVISOR_TOOL_NAME, { action: "reply", replyTo: "wrong-request-id", message: "Wrong" }), /No pending supervisor request found/);
+								const escalation = await runtime.call("contact_supervisor", { reason: "need_decision", message: "C needs a choice; may I approve option A?" });
+								assert.match(text(escalation), /Approve option A/);
+								assert.equal(cReturned, false, "A's answer to B must not unblock C");
+								const reply = await runtime.call(NATIVE_SUPERVISOR_TOOL_NAME, { action: "reply", replyTo: cRequest, message: "Use option A" });
+								assert.equal(reply.details.replyTo, cRequest);
+								bReturned = true;
+							} else {
+								assert.equal(launch.runtime.agent, "leaf");
+								assert.equal(launch.runtime.orchestratorSessionId, runtimes[0]!.owner, "C belongs to B's exact runtime id, not A or B's file");
+								assert.equal(runtime.registered.has(NATIVE_SUPERVISOR_TOOL_NAME), false, "leaf must not get downward authority");
+								await new Promise(resolve => setTimeout(resolve, 25));
+								const reply = await runtime.call("contact_supervisor", { reason: "need_decision", message: "Which option?" });
+								assert.equal(reply.details.requestId, cRequest);
+								assert.match(text(reply), /Use option A/);
+								cReturned = true;
+							}
+							await runtime.emit("message_end", { message: { role: "assistant", content: [{ type: "text", text: "Inspection complete." }], model: "mock/test-model", stopReason: "stop", usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } } } });
+							await runtime.emit("agent_end");
+							await runtime.emit("agent_settled");
+						},
+					};
+				},
+				async dispose() {},
+			};
+			try {
+				parent.start();
+				setChildSessionFactory(factory);
+				const run = runSync(root, [makeAgent("coordinator", { model: "mock/test-model", tools: ["read", "subagent", "contact_supervisor", "subagent_supervisor"] })], "coordinator", "Inspect read-only with the assigned leaf.", {
+					runId: randomUUID(), parentSessionId: a, orchestratorIntercomTarget: "shared-name", signal: abort.signal,
+				});
+				await waitForCondition(() => runtimes.length > 0, "coordinator startup");
+				// Surface diagnostic failures immediately rather than hiding them behind an ask timeout.
+				const result = await Promise.race([
+					run.then(result => { assert.equal(result.exitCode, 0, result.error); return result; }),
+					(async () => {
+						await waitForCondition(() => {
+							// A may be idle; its explicit query is authoritative.
+							void parentTools.get(NATIVE_SUPERVISOR_TOOL_NAME)!.execute("pending", { action: "pending" });
+							return parent.pending.size > 0;
+						}, "B's escalation to A");
+						const [ask] = parent.pending.values();
+						assert.equal(ask!.agent, "coordinator");
+						assert.notEqual(ask!.id, cRequest);
+						await parentTools.get(NATIVE_SUPERVISOR_TOOL_NAME)!.execute("reply", { action: "reply", replyTo: ask!.id, message: "Approve option A" });
+						return await run;
+					})(),
+				]);
+				assert.equal(result.exitCode, 0, result.error);
+				assert.equal(bReturned, true);
+				assert.equal(bDrainReturnedBeforeReply, true);
+				assert.equal(cReturned, true, "B's final drain must await C's real blocked contact call and workflow completion");
+				for (const dir of workflows) {
+					const status = JSON.parse(fs.readFileSync(path.join(dir, "status.json"), "utf8"));
+					assert.equal(status.state, "complete", JSON.stringify(status));
+				}
+				for (const runtime of runtimes) assert.equal(runtime.closed, true);
+				const stale = writeRequest({ sessionId: runtimes[0]!.owner, runId: randomUUID() });
+				await assert.rejects(runtimes[0]!.call(NATIVE_SUPERVISOR_TOOL_NAME, { action: "reply", replyTo: stale, message: "No authority after shutdown" }), /No pending supervisor request found/);
+			} finally {
+				abort.abort();
+				setChildSessionFactory(undefined);
+				for (const runtime of runtimes) await runtime.emit("session_shutdown");
+				parent.dispose();
+				if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+				else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+				for (const dir of workflows) fs.rmSync(dir, { recursive: true, force: true });
+				fs.rmSync(root, { recursive: true, force: true });
+			}
+		});
+	}
+
+	it("discovers a direct async child's ask without polling pending on Darwin", { timeout: 5000 }, async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "nested-async-supervisor-"));
+		const launch = buildInProcessChildLaunch({
+			host: "parent", cwd: root, childAgentName: "coordinator", childIndex: 0,
+			sessionEnabled: false, tools: ["subagent", "subagent_supervisor"],
+			inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false,
+		});
+		const abort = new AbortController();
+		const runtime = hookRuntime(launch.session, "darwin", abort.signal);
+		const runId = randomUUID();
+		const channelDir = resolveSupervisorChannelDir(runId, "leaf", 0);
+		createdChannels.push(channelDir);
+		const childTools = new Map<string, SupervisorTool>();
+		registerNativeSupervisorClient(makePi({ tools: childTools }) as never, { channelDir, runId, agent: "leaf", childIndex: 0, orchestratorSessionId: runtime.owner });
+		let request: Promise<{ content: Array<{ type: string; text?: string }> }> | undefined;
+		const contact = childTools.get("contact_supervisor") as unknown as {
+			execute(id: string, params: { reason: string; message: string }, signal: AbortSignal): NonNullable<typeof request>;
+		};
+		try {
+			await runtime.emit("session_start");
+			fs.writeFileSync(path.join(root, "status.json"), JSON.stringify({ runId, state: "running" }));
+			runtime.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: runId, asyncDir: root, agent: "leaf", sessionId: runtime.sessionFile });
+			request = contact.execute("ask", { reason: "need_decision", message: "Which option?" }, abort.signal);
+			// Attach rejection handling before any assertion can abort the child.
+			void request!.catch(() => {});
+			await waitForCondition(() => runtime.notices.length > 0, "direct async ask notification");
+			const pending = await runtime.call(NATIVE_SUPERVISOR_TOOL_NAME, { action: "pending" });
+			await runtime.call(NATIVE_SUPERVISOR_TOOL_NAME, { action: "reply", replyTo: pending.details.pending[0]!.id, message: "Use option A" });
+			assert.match(text(await request), /Use option A/);
+		} finally {
+			abort.abort();
+			await request?.catch(() => {});
+			await runtime.emit("session_shutdown");
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("does not activate supervision when the coordinator excludes the reply tool", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "nested-no-supervisor-"));
+		const launch = buildInProcessChildLaunch({
+			host: "parent", cwd: root, childAgentName: "coordinator", childIndex: 0,
+			sessionEnabled: false, tools: ["subagent"],
+			inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false,
+		});
+		const runtime = hookRuntime(launch.session, "win32", new AbortController().signal);
+		const runId = randomUUID();
+		try {
+			writeRequest({ sessionId: runtime.owner, runId });
+			await runtime.emit("session_start");
+			runtime.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: runId, asyncDir: root, agent: "worker", sessionId: runtime.sessionFile });
+			await new Promise(resolve => setTimeout(resolve, 600));
+			assert.equal(runtime.notices.length, 0, "no instructions to call an excluded reply tool");
+			await assert.rejects(runtime.call(NATIVE_SUPERVISOR_TOOL_NAME, { action: "pending" }), /not active/);
+			await assert.rejects(runtime.call("subagent", { action: "schedule.run", id: "not-authorized" }), /not available/);
+		} finally {
+			await runtime.emit("session_shutdown");
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("wires fresh pending-ask lookup into the child-safe steering executor", async () => {
+		fs.mkdirSync(DIRS.async, { recursive: true });
+		const root = fs.mkdtempSync(path.join(DIRS.async, "child-blocked-steer-"));
+		const launch = buildInProcessChildLaunch({
+			host: "parent", cwd: root, childAgentName: "coordinator", childIndex: 0,
+			sessionEnabled: false, tools: ["subagent", "subagent_supervisor"],
+			inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false,
+		});
+		const runtime = hookRuntime(launch.session, "darwin", new AbortController().signal);
+		try {
+			await runtime.emit("session_start");
+			const runId = randomUUID();
+			const requestId = writeRequest({ sessionId: runtime.owner, runId });
+			const status = JSON.stringify({ runId, sessionId: runtime.sessionFile, state: "running", mode: "single", pid: process.pid, startedAt: Date.now(), steps: [{ agent: "worker", status: "running" }] });
+			fs.writeFileSync(path.join(root, "status.json"), status);
+			await assert.rejects(runtime.call("subagent", { action: "steer", dir: root, message: "After the decision, inspect docs." }), (error: Error) => {
+				assert.ok(error.message.includes(`"replyTo":"${requestId}"`), error.message);
+				assert.match(error.message, /not delivered or queued/);
+				return true;
+			});
+			assert.equal(runtime.notices.length, 0, "receipt lookup must not register or notify");
+			assert.equal(fs.readFileSync(path.join(root, "status.json"), "utf8"), status);
+			assert.deepEqual(fs.readdirSync(path.join(resolveSupervisorChannelDir(runId, "worker", 0), "replies")), []);
+		} finally {
+			await runtime.emit("session_shutdown");
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("public single async steering reports exact pending asks without reply, queue or recovery", async () => {
 		const owner = randomUUID();
 		fs.mkdirSync(DIRS.async, { recursive: true });
@@ -308,7 +755,7 @@ describe("supervisor ask registration", () => {
 				let stale = false;
 				const ctx = {
 					cwd: root,
-					get hasUI() { if (stale) throw new Error("This extension ctx is stale after session replacement or reload."); return false; },
+					isIdle() { return false; }, get hasUI() { if (stale) throw new Error("This extension ctx is stale after session replacement or reload."); return false; },
 					ui: { setWidget() {}, requestRender() {}, onTerminalInput() { return () => {}; }, notify() {}, theme: { fg(_name, text) { return text; }, bold(text) { return text; } } },
 					sessionManager: {
 						getSessionId() { if (stale) throw new Error("stale session manager"); return owner; },
@@ -536,22 +983,17 @@ describe("supervisor ask registration", () => {
 		}
 	});
 
-	it("retains a failed progress update until a later query accepts it without duplicate notifications", async () => {
+	it("consumes progress updates without parent notifications", async () => {
 		const sessionId = `session-${randomUUID()}`;
 		const runId = `run-${randomUUID()}`;
 		const tools = new Map<string, SupervisorTool>();
 		const state = makeState(`/sessions/${sessionId}.jsonl`, makeCtx(sessionId));
 		state.lastUiContext = null;
 		let attempts = 0;
-		let accepted = 0;
 		let requestFile = "";
-		let visibleText = "";
 		const pi = makePi({ tools, onSend: (message) => {
-			visibleText = message.content;
 			attempts++;
-			assert.equal(fs.existsSync(requestFile), true, "retain the update until sendMessage returns");
-			if (attempts === 1) throw new Error("notification not accepted");
-			accepted++;
+			assert.fail(`progress update should not be sent: ${message.content}`);
 		} });
 		const channel = createNativeSupervisorChannel(pi as never, state, { platform: "darwin" });
 		try {
@@ -560,19 +1002,14 @@ describe("supervisor ask registration", () => {
 			requestFile = path.join(resolveSupervisorChannelDir(runId, "worker", 0), "requests", `${requestId}.json`);
 			const tool = tools.get(NATIVE_SUPERVISOR_TOOL_NAME)!;
 			await tool.execute("failed", { action: "pending" });
-			assert.equal(attempts, 1);
-			assert.equal(accepted, 0);
-			assert.equal(fs.existsSync(requestFile), true);
+			assert.equal(attempts, 0);
+			assert.equal(fs.existsSync(requestFile), false);
 			assert.equal(channel.pending.size, 0, "a progress update must not become a blocking ask");
 			await tool.execute("retry", { action: "pending" });
-			assert.equal(attempts, 2);
-			assert.equal(accepted, 1);
+			assert.equal(attempts, 0);
 			assert.equal(fs.existsSync(requestFile), false);
-			assert.ok(visibleText.includes(`Live guidance: subagent({ action: "steer", id: "${runId}", index: 0, message: "..." })`));
-			assert.doesNotMatch(visibleText, /Reply with:|replyTo:|Child intercom target:/);
 			await tool.execute("after-acceptance", { action: "pending" });
-			assert.equal(attempts, 2);
-			assert.equal(accepted, 1);
+			assert.equal(attempts, 0);
 			assert.equal(channel.pending.size, 0);
 		} finally { channel.dispose(); }
 	});

package/dist/extensions/pi-subagents/test/unit/temp-paths.test.ts

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { spawnSync } from "node:child_process";
 import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
 import {
 	ASYNC_DIR,
 	CHAIN_RUNS_DIR,
@@ -88,6 +89,7 @@ describe("shared temp paths", () => {
 			const utilsUrl = new URL("../../src/shared/utils.ts", import.meta.url).href;
 			const script = `
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { applySubagentProfile, getSubagentProfilesDir } from ${JSON.stringify(profilesUrl)};
 import { getAgentDir } from ${JSON.stringify(utilsUrl)};
@@ -96,7 +98,7 @@ const profilesDir = getSubagentProfilesDir();
 fs.mkdirSync(profilesDir, { recursive: true });
 fs.writeFileSync(path.join(profilesDir, "isolated.json"), JSON.stringify({ subagents: { agentOverrides: { worker: { thinking: "high" } } } }));
 const result = applySubagentProfile("isolated");
-console.log(JSON.stringify({ agentDir: getAgentDir(), profilePath: path.join(profilesDir, "isolated.json"), settingsPath: result.settingsPath }));
+console.log(JSON.stringify({ agentDir: getAgentDir(), profilePath: path.join(profilesDir, "isolated.json"), settingsPath: result.settingsPath, tempDir: os.tmpdir(), testParentPid: process.env.SELESAI_SUBAGENTS_TEST_PARENT_PID }));
 `;
 			const env = {
 				...process.env,
@@ -115,11 +117,14 @@ console.log(JSON.stringify({ agentDir: getAgentDir(), profilePath: path.join(pro
 				env,
 			});
 			assert.equal(result.status, 0, result.stderr);
-			const output = JSON.parse(result.stdout.trim()) as { agentDir: string; profilePath: string; settingsPath: string };
+			const output = JSON.parse(result.stdout.trim()) as { agentDir: string; profilePath: string; settingsPath: string; tempDir: string; testParentPid: string };
 			const isolatedAgentDir = path.join(tempRoot, "home", ".selesai", "agent");
 			assert.equal(output.agentDir, isolatedAgentDir);
 			assert.equal(output.profilePath, path.join(isolatedAgentDir, "profiles", "pi-subagents", "isolated.json"));
 			assert.equal(output.settingsPath, path.join(isolatedAgentDir, "settings.json"));
+			assert.equal(output.tempDir, tempRoot);
+			assert.equal(output.testParentPid, String(result.pid));
+			if (process.platform === "darwin") assert.equal(fs.existsSync(path.join(tempRoot, ".metadata_never_index")), true);
 			assert.equal(fs.existsSync(output.profilePath), true);
 			assert.equal(fs.existsSync(output.settingsPath), true);
 			assert.equal(fs.existsSync(callerAgentDir), false);
@@ -128,6 +133,20 @@ console.log(JSON.stringify({ agentDir: getAgentDir(), profilePath: path.join(pro
 		}
 	});
 
+	it("records a nested test process as the runner parent", () => {
+		const loaderUrl = new URL("../support/isolated-temp-root.mjs", import.meta.url).href;
+		const result = spawnSync(process.execPath, [
+			"--import", loaderUrl,
+			"--input-type=module",
+			"--eval", "console.log(process.env.SELESAI_SUBAGENTS_TEST_PARENT_PID)",
+		], {
+			encoding: "utf-8",
+			env: { ...process.env, SELESAI_SUBAGENTS_TEST_LOADER: "loaded", SELESAI_SUBAGENTS_TEST_PARENT_PID: String(process.pid) },
+		});
+		assert.equal(result.status, 0, result.stderr);
+		assert.equal(result.stdout.trim(), String(result.pid));
+	});
+
 	it("anchors shared temp directories under one scoped root", () => {
 		assert.equal(path.dirname(RESULTS_DIR), TEMP_ROOT_DIR);
 		assert.equal(path.dirname(ASYNC_DIR), TEMP_ROOT_DIR);
@@ -140,8 +159,29 @@ console.log(JSON.stringify({ agentDir: getAgentDir(), profilePath: path.join(pro
 		assert.equal(path.basename(TEMP_ARTIFACTS_DIR), "artifacts");
 	});
 
+	it("stops a test runner before consuming config when its test parent is gone", () => {
+		const configPath = path.join(os.tmpdir(), "orphan-check.json");
+		fs.writeFileSync(configPath, "{}", "utf-8");
+		try {
+			const result = spawnSync(process.execPath, [
+				"--experimental-strip-types",
+				"--import", new URL("../support/register-loader.mjs", import.meta.url).href,
+				fileURLToPath(new URL("../../src/runs/background/subagent-runner-bootstrap.ts", import.meta.url)),
+				configPath,
+			], {
+				env: { ...process.env, SELESAI_SUBAGENTS_TEST_PARENT_PID: "2147483647" },
+				encoding: "utf-8",
+				timeout: 10_000,
+			});
+			assert.equal(result.status, 1, result.stderr);
+			assert.equal(fs.existsSync(configPath), true);
+		} finally {
+			fs.rmSync(configPath, { force: true });
+		}
+	});
+
 	it("writes async config files under the same scoped temp root", () => {
 		assert.equal(path.dirname(getAsyncConfigPath("abc123")), TEMP_ROOT_DIR);
 		assert.equal(path.basename(getAsyncConfigPath("abc123")), "async-cfg-abc123.json");
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/timeout-defaults.test.ts

@@ -38,6 +38,16 @@ describe("single-agent launch timeout wiring", () => {
 		assert.match(result.error!, /positive integer/);
 	});
 
+	it("rejects explicit timeouts above the maximum schedulable timer delay", () => {
+		for (const key of ["timeoutMs", "maxRuntimeMs"] as const) {
+			const result = resolveSingleAgentLaunchTimeout({ [key]: 2_147_483_648 }, true);
+			assert.equal(result.error, `${key} must be a positive integer no larger than 2147483647.`);
+		}
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({ timeoutMs: 2_147_483_647 }, true), {
+			timeoutMs: 2_147_483_647,
+		});
+	});
+
 	it("rejects mismatched alias values", () => {
 		const result = resolveSingleAgentLaunchTimeout({ timeoutMs: 1_000, maxRuntimeMs: 2_000 }, true);
 		assert.ok(result.error);
@@ -135,4 +145,4 @@ describe("resolveConfigDefaultTimeoutMs", () => {
 		assert.equal(resolveConfigDefaultTimeoutMs(2_147_483_648), undefined);
 		assert.equal(resolveConfigDefaultTimeoutMs(Number.MAX_SAFE_INTEGER), undefined);
 	});
-});
+});