@selesai/code 0.5.19 → 0.5.21

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

@@ -8,11 +8,28 @@ import {
 	NATIVE_SUPERVISOR_TOOL_NAME,
 	createNativeSupervisorChannel,
 	ensureSupervisorChannelDir,
+	registerNativeSupervisorClient,
 	resolveSupervisorChannelDir,
 } from "../../src/intercom/native-supervisor-channel.ts";
-import type { SubagentState } from "../../src/shared/types.ts";
+import {
+	SUBAGENT_CHILD_AGENT_ENV,
+	SUBAGENT_CHILD_INDEX_ENV,
+	SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV,
+	SUBAGENT_ORCHESTRATOR_TARGET_ENV,
+	SUBAGENT_RUN_ID_ENV,
+	SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV,
+} from "../../src/runs/shared/pi-args.ts";
+import { INTERCOM_DETACH_REQUEST_EVENT, type SubagentState } from "../../src/shared/types.ts";
 
 const createdChannels: string[] = [];
+const savedEnv = {
+	[SUBAGENT_CHILD_AGENT_ENV]: process.env[SUBAGENT_CHILD_AGENT_ENV],
+	[SUBAGENT_CHILD_INDEX_ENV]: process.env[SUBAGENT_CHILD_INDEX_ENV],
+	[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV]: process.env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV],
+	[SUBAGENT_ORCHESTRATOR_TARGET_ENV]: process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV],
+	[SUBAGENT_RUN_ID_ENV]: process.env[SUBAGENT_RUN_ID_ENV],
+	[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV]: process.env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV],
+};
 
 function makeState(sessionId: string | null, ctx: unknown): SubagentState {
 	return {
@@ -31,7 +48,7 @@ function makeState(sessionId: string | null, ctx: unknown): SubagentState {
 	};
 }
 
-function writeRequest(input: { sessionId: string; runId: string; agent?: string; index?: number; message?: string }): string {
+function writeRequest(input: { sessionId: string; runId: string; agent?: string; index?: number; message?: string; createdAt?: number; expiresAt?: number }): string {
 	const agent = input.agent ?? "worker";
 	const index = input.index ?? 0;
 	const channelDir = resolveSupervisorChannelDir(input.runId, agent, index);
@@ -41,7 +58,8 @@ function writeRequest(input: { sessionId: string; runId: string; agent?: string;
 	fs.writeFileSync(path.join(channelDir, "requests", `${requestId}.json`), JSON.stringify({
 		type: "subagent.supervisor.request",
 		id: requestId,
-		createdAt: Date.now(),
+		createdAt: input.createdAt ?? Date.now(),
+		...(input.expiresAt !== undefined ? { expiresAt: input.expiresAt } : {}),
 		reason: "need_decision",
 		message: input.message ?? "Need a decision",
 		expectsReply: true,
@@ -54,17 +72,51 @@ function writeRequest(input: { sessionId: string; runId: string; agent?: string;
 	return requestId;
 }
 
+function requestFile(runId: string, requestId: string, agent = "worker", index = 0): string {
+	return path.join(resolveSupervisorChannelDir(runId, agent, index), "requests", `${requestId}.json`);
+}
+
+function replyFile(runId: string, requestId: string, agent = "worker", index = 0): string {
+	return path.join(resolveSupervisorChannelDir(runId, agent, index), "replies", `${requestId}.json`);
+}
+
+function makeEmptyChannel(runId: string): string {
+	const channelDir = resolveSupervisorChannelDir(runId, "worker", 0);
+	createdChannels.push(channelDir);
+	ensureSupervisorChannelDir(channelDir);
+	return channelDir;
+}
+
+function ageChannel(channelDir: string, ageMs: number): void {
+	const timestamp = new Date(Date.now() - ageMs);
+	for (const dir of [path.join(channelDir, "requests"), path.join(channelDir, "replies"), channelDir]) {
+		fs.utimesSync(dir, timestamp, timestamp);
+	}
+}
+
+function restoreEnv(): void {
+	for (const [key, value] of Object.entries(savedEnv)) {
+		if (value === undefined) delete process.env[key];
+		else process.env[key] = value;
+	}
+}
+
 afterEach(() => {
+	restoreEnv();
+	delete process.env.PI_INTERCOM_ASK_TIMEOUT_MS;
 	for (const channel of createdChannels.splice(0)) fs.rmSync(channel, { recursive: true, force: true });
 });
 
 describe("native supervisor channel", () => {
-	it("delivers requests only to the exact current session id", () => {
+	it("delivers requests only to the exact current session id and wakes the parent", () => {
 		const currentSessionId = `session-${randomUUID()}`;
 		const otherSessionId = `session-${randomUUID()}`;
 		const matchingId = writeRequest({ sessionId: currentSessionId, runId: `run-${randomUUID()}` });
 		const otherId = writeRequest({ sessionId: otherSessionId, runId: `run-${randomUUID()}` });
-		const sent: Array<{ content?: string; details?: { id?: string } }> = [];
+		const sent: Array<{
+			message: { content?: string; details?: { id?: string } };
+			options?: { triggerTurn?: boolean };
+		}> = [];
 		const registeredTools: string[] = [];
 		const ctx = {
 			cwd: process.cwd(),
@@ -78,7 +130,10 @@ describe("native supervisor channel", () => {
 		const pi = {
 			getAllTools: () => [],
 			registerTool: (tool: { name: string }) => { registeredTools.push(tool.name); },
-			sendMessage: (message: { content?: string; details?: { id?: string } }) => { sent.push(message); },
+			sendMessage: (
+				message: { content?: string; details?: { id?: string } },
+				options?: { triggerTurn?: boolean },
+			) => { sent.push({ message, options }); },
 			getSessionName: () => "shared-name",
 		};
 		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx));
@@ -88,9 +143,162 @@ describe("native supervisor channel", () => {
 		channel.dispose();
 
 		assert.deepEqual(registeredTools, [NATIVE_SUPERVISOR_TOOL_NAME, "intercom"]);
-		assert.deepEqual(sent.map((message) => message.details?.id), [matchingId]);
+		assert.deepEqual(sent.map(({ message }) => message.details?.id), [matchingId]);
+		assert.deepEqual(sent[0]?.options, { triggerTurn: true });
 		assert.equal(channel.pending.has(matchingId), false, "disposed channel clears pending requests");
-		assert.equal(sent.some((message) => message.details?.id === otherId), false);
+		assert.equal(sent.some(({ message }) => message.details?.id === otherId), false);
+	});
+
+	it("prunes stale empty supervisor channel directories before polling", () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const staleEmptyChannel = makeEmptyChannel(`run-${randomUUID()}`);
+		ageChannel(staleEmptyChannel, 2 * 60 * 1000);
+		const sent: Array<{ details?: { id?: string } }> = [];
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [],
+			registerTool: () => {},
+			sendMessage: (message: { details?: { id?: string } }) => { sent.push(message); },
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx));
+
+		channel.start();
+		channel.dispose();
+
+		assert.equal(fs.existsSync(staleEmptyChannel), false);
+		assert.deepEqual(sent, []);
+	});
+
+	it("preserves fresh empty and stale non-empty supervisor channel directories", () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const freshEmptyChannel = makeEmptyChannel(`run-${randomUUID()}`);
+		const staleWithReply = makeEmptyChannel(`run-${randomUUID()}`);
+		fs.writeFileSync(path.join(staleWithReply, "replies", "reply.json"), "{}");
+		ageChannel(staleWithReply, 2 * 60 * 1000);
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [],
+			registerTool: () => {},
+			sendMessage: () => {},
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx));
+
+		channel.start();
+		channel.dispose();
+
+		assert.equal(fs.existsSync(freshEmptyChannel), true);
+		assert.equal(fs.existsSync(staleWithReply), true);
+	});
+
+	it("emits foreground detach only after displaying a pending supervisor request", () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const runId = `run-${randomUUID()}`;
+		const requestId = writeRequest({ sessionId: currentSessionId, runId, agent: "worker", index: 2 });
+		const log: string[] = [];
+		const emitted: Array<{ channel: string; payload: { requestId?: string; runId?: string; agent?: string; childIndex?: number } }> = [];
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [],
+			registerTool: () => {},
+			sendMessage: () => { log.push("send"); },
+			events: {
+				emit: (channel: string, payload: { requestId?: string; runId?: string; agent?: string; childIndex?: number }) => {
+					log.push("emit");
+					emitted.push({ channel, payload });
+				},
+			},
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx));
+
+		channel.start();
+		try {
+			assert.deepEqual(log, ["send", "emit"]);
+			assert.deepEqual(emitted, [{
+				channel: INTERCOM_DETACH_REQUEST_EVENT,
+				payload: { requestId, runId, agent: "worker", childIndex: 2 },
+			}]);
+			assert.equal(channel.pending.has(requestId), true);
+		} finally {
+			channel.dispose();
+		}
+	});
+
+	it("re-arms remembered foreground attention for each blocking supervisor request", async () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const runId = `run-${randomUUID()}`;
+		const requestId = writeRequest({ sessionId: currentSessionId, runId });
+		const registeredTools = new Map<string, { execute: (_id: string, params: { action: string; replyTo?: string; message?: string }) => Promise<unknown> }>();
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const state = makeState(currentSessionId, ctx);
+		state.foregroundRuns = new Map([[runId, {
+			runId,
+			mode: "single",
+			cwd: process.cwd(),
+			sessionId: currentSessionId,
+			updatedAt: 1,
+			children: [{ agent: "worker", index: 0, status: "detached", updatedAt: 1 }],
+		}]]);
+		const pi = {
+			getAllTools: () => [...registeredTools.keys()].map((name) => ({ name })),
+			registerTool: (tool: { name: string; execute: (_id: string, params: { action: string; replyTo?: string; message?: string }) => Promise<unknown> }) => {
+				registeredTools.set(tool.name, tool);
+			},
+			sendMessage: () => {},
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, state);
+
+		try {
+			channel.start();
+			const child = state.foregroundRuns.get(runId)!.children[0]!;
+			assert.equal(child.activityState, "needs_attention");
+			assert.equal(child.currentTool, "contact_supervisor");
+
+			await registeredTools.get(NATIVE_SUPERVISOR_TOOL_NAME)!.execute("reply", {
+				action: "reply",
+				replyTo: requestId,
+				message: "Approved",
+			});
+			assert.equal(child.activityState, undefined);
+			assert.equal(child.currentTool, undefined);
+		} finally {
+			channel.dispose();
+		}
 	});
 
 	it("matches supervisor requests against the runtime session id instead of persisted session file path", () => {
@@ -151,12 +359,135 @@ describe("native supervisor channel", () => {
 
 			assert.deepEqual([...registeredTools.keys()], [NATIVE_SUPERVISOR_TOOL_NAME]);
 			await registeredTools.get(NATIVE_SUPERVISOR_TOOL_NAME)?.execute("reply", { action: "reply", replyTo: requestId, message: "Approved" });
-			const replyFile = path.join(resolveSupervisorChannelDir(runId, "worker", 0), "replies", `${requestId}.json`);
-			const reply = JSON.parse(fs.readFileSync(replyFile, "utf-8")) as { message?: string; requestId?: string };
+			const reply = JSON.parse(fs.readFileSync(replyFile(runId, requestId), "utf-8")) as { message?: string; requestId?: string };
 			assert.equal(reply.requestId, requestId);
 			assert.equal(reply.message, "Approved");
+			assert.equal(fs.existsSync(requestFile(runId, requestId)), false);
+		} finally {
+			channel.dispose();
+		}
+	});
+
+	it("suppresses resolved, expired, and inactive requests before displaying them", () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const resolvedRunId = `run-${randomUUID()}`;
+		const expiredRunId = `run-${randomUUID()}`;
+		const inactiveRunId = `run-${randomUUID()}`;
+		const resolvedId = writeRequest({ sessionId: currentSessionId, runId: resolvedRunId });
+		const expiredId = writeRequest({ sessionId: currentSessionId, runId: expiredRunId, expiresAt: Date.now() - 1 });
+		const inactiveId = writeRequest({ sessionId: currentSessionId, runId: inactiveRunId });
+		fs.writeFileSync(replyFile(resolvedRunId, resolvedId), JSON.stringify({
+			type: "subagent.supervisor.reply",
+			requestId: resolvedId,
+			createdAt: Date.now(),
+			message: "Already handled",
+		}), "utf-8");
+		const sent: Array<{ details?: { id?: string } }> = [];
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const state = makeState(currentSessionId, ctx);
+		state.foregroundRuns = new Map([[inactiveRunId, {
+			runId: inactiveRunId,
+			mode: "single",
+			cwd: process.cwd(),
+			updatedAt: Date.now(),
+			children: [{ agent: "worker", index: 0, status: "completed", updatedAt: Date.now() }],
+		}]]);
+		const pi = {
+			getAllTools: () => [],
+			registerTool: () => {},
+			sendMessage: (message: { details?: { id?: string } }) => { sent.push(message); },
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, state);
+
+		channel.start();
+		channel.dispose();
+
+		assert.deepEqual(sent, []);
+		assert.equal(fs.existsSync(requestFile(resolvedRunId, resolvedId)), false);
+		assert.equal(fs.existsSync(requestFile(expiredRunId, expiredId)), false);
+		assert.equal(fs.existsSync(requestFile(inactiveRunId, inactiveId)), false);
+	});
+
+	it("refreshes pending requests before listing or replying", async () => {
+		const currentSessionId = `session-${randomUUID()}`;
+		const runId = `run-${randomUUID()}`;
+		const requestId = writeRequest({ sessionId: currentSessionId, runId });
+		const registeredTools = new Map<string, { execute: (_id: string, params: { action: string; replyTo?: string; message?: string }) => Promise<{ content: Array<{ text: string }>; details?: { pending?: unknown[] } }> }>();
+		const sent: Array<{ details?: { id?: string } }> = [];
+		const ctx = {
+			cwd: process.cwd(),
+			hasUI: false,
+			sessionManager: {
+				getSessionId: () => currentSessionId,
+				getSessionFile: () => null,
+				getEntries: () => [],
+			},
+		};
+		const pi = {
+			getAllTools: () => [...registeredTools.keys()].map((name) => ({ name })),
+			registerTool: (tool: { name: string; execute: (_id: string, params: { action: string; replyTo?: string; message?: string }) => Promise<{ content: Array<{ text: string }>; details?: { pending?: unknown[] } }> }) => {
+				registeredTools.set(tool.name, tool);
+			},
+			sendMessage: (message: { details?: { id?: string } }) => { sent.push(message); },
+			getSessionName: () => "shared-name",
+		};
+		const channel = createNativeSupervisorChannel(pi as never, makeState(currentSessionId, ctx));
+
+		try {
+			channel.start();
+			assert.deepEqual(sent.map((message) => message.details?.id), [requestId]);
+			assert.equal(channel.pending.has(requestId), true);
+
+			fs.rmSync(requestFile(runId, requestId), { force: true });
+			const pendingResult = await registeredTools.get(NATIVE_SUPERVISOR_TOOL_NAME)!.execute("pending", { action: "pending" });
+
+			assert.match(pendingResult.content[0]!.text, /No pending supervisor requests/);
+			assert.deepEqual(pendingResult.details?.pending, []);
+			assert.equal(channel.pending.has(requestId), false);
+			await assert.rejects(
+				() => registeredTools.get(NATIVE_SUPERVISOR_TOOL_NAME)!.execute("reply", { action: "reply", replyTo: requestId, message: "Too late" }),
+				new RegExp(`No pending supervisor request found for replyTo '${requestId}'`),
+			);
 		} finally {
 			channel.dispose();
 		}
 	});
+
+	it("removes the request file when a child supervisor ask is cancelled", async () => {
+		const runId = `run-${randomUUID()}`;
+		const channelDir = resolveSupervisorChannelDir(runId, "worker", 0);
+		createdChannels.push(channelDir);
+		process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV] = "shared-name";
+		process.env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV] = "session-parent";
+		process.env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV] = channelDir;
+		process.env[SUBAGENT_RUN_ID_ENV] = runId;
+		process.env[SUBAGENT_CHILD_AGENT_ENV] = "worker";
+		process.env[SUBAGENT_CHILD_INDEX_ENV] = "0";
+		const registeredTools = new Map<string, { execute: (_id: string, params: { reason: string; message?: string }, signal?: AbortSignal) => Promise<unknown> | unknown }>();
+		const pi = {
+			getAllTools: () => [...registeredTools.keys()].map((name) => ({ name })),
+			registerTool: (tool: { name: string; execute: (_id: string, params: { reason: string; message?: string }, signal?: AbortSignal) => Promise<unknown> | unknown }) => {
+				registeredTools.set(tool.name, tool);
+			},
+		};
+		registerNativeSupervisorClient(pi as never, { includeIntercomFallback: false });
+		const controller = new AbortController();
+		controller.abort();
+
+		await assert.rejects(
+			() => registeredTools.get("contact_supervisor")!.execute("contact", { reason: "need_decision", message: "Need a decision" }, controller.signal),
+			/Supervisor request cancelled/,
+		);
+
+		assert.deepEqual(fs.readdirSync(path.join(channelDir, "requests")), []);
+	});
 });

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

@@ -301,6 +301,22 @@ describe("nested control routing", () => {
 		}
 	});
 
+	it("rejects stopped nested runs before attempting revival", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-nested-stopped-resume-"));
+		try {
+			const route = createNestedRun("nested-stopped-resume", "stopped", { sessionFile: path.join(root, "missing-session.jsonl") });
+
+			const result = await createExecutor(stateWithNestedRoute(route), [{ name: "worker", description: "Worker", prompt: "Do work" }])
+				.execute("resume", { action: "resume", id: "nested-stopped-resume", message: "continue" }, new AbortController().signal, undefined, ctx(root));
+
+			assert.equal(result.isError, true);
+			assert.match(text(result), /was stopped and cannot be resumed/);
+			assert.doesNotMatch(text(result), /session file/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("rejects terminal nested resume session files outside trusted roots", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-nested-terminal-untrusted-"));
 		try {

package/dist/extensions/pi-subagents/test/unit/nested-events.test.ts

@@ -7,6 +7,7 @@ import {
 	buildNestedRouteIndex,
 	createNestedRoute,
 	hasLiveNestedDescendants,
+	nestedSummaryFromAsyncStatus,
 	parseNestedEventRecords,
 	projectNestedEvents,
 	resolveNestedParentAddressFromEnv,
@@ -326,4 +327,55 @@ describe("nested event parsing and projection", () => {
 		assert.equal(records.length, 1);
 		assert.equal(records[0]?.child.id, "jsonl-good");
 	});
+
+
+	it("sanitizes malformed process-terminal proofs in nested status summaries", () => {
+		const summary = nestedSummaryFromAsyncStatus({
+			runId: "child-run",
+			mode: "single",
+			state: "complete",
+			startedAt: 1,
+			processTerminal: { version: 1, state: "bogus", runId: "child-run", runnerProcessInstanceId: "runner-1" } as never,
+			steps: [{
+				agent: "worker",
+				status: "complete",
+				processTerminal: { version: 1, state: "observed", runId: "wrong-run", runnerProcessInstanceId: "runner-1" } as never,
+			}],
+		}, "/tmp/child-run", { id: "child-run", parentRunId: "parent-run", depth: 1, mode: "single", ts: 2 });
+
+		assert.equal(summary.processTerminal?.state, "unknown");
+		assert.equal(summary.processTerminal?.reason, "proof-write-failed");
+		assert.equal(summary.steps?.[0]?.processTerminal?.state, "unknown");
+		assert.equal(summary.steps?.[0]?.processTerminal?.reason, "proof-write-failed");
+	});
+
+	it("removes evicted status files without replaying completed children", () => {
+		const route = trackRoute();
+		for (let index = 0; index < 1000; index++) {
+			writeNestedEvent(route, {
+				type: "subagent.nested.updated",
+				ts: index + 1,
+				parentRunId: "root-run",
+				parentStepIndex: 1,
+				child: child("nested-retained", "running", index + 1),
+			});
+		}
+		writeNestedEvent(route, {
+			type: "subagent.nested.completed",
+			ts: 1001,
+			parentRunId: "root-run",
+			parentStepIndex: 1,
+			child: child("nested-retained", "complete", 1001),
+		});
+
+		assert.equal(fs.readdirSync(route.eventSink).length, 1001);
+		const firstProjection = projectNestedEvents(route);
+		assert.equal(firstProjection.processedEvents.length, 1000);
+		assert.equal(fs.readdirSync(route.eventSink).length, 1000);
+		assert.equal(firstProjection.children[0]?.state, "complete");
+
+		const secondProjection = projectNestedEvents(route);
+		assert.deepEqual(secondProjection, firstProjection);
+		assert.equal(secondProjection.children[0]?.state, "complete");
+	});
 });