@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/support/fake-child-session.ts

@@ -0,0 +1,418 @@
+/**
+ * Scripted in-process child sessions for tests.
+ *
+ * Foreground runs and the detached async runner create their children through
+ * `ChildSessionFactory`. This factory replays the responses `createMockPi()`
+ * queues, so one `mockPi.onCall(...)` feeds whichever launch path a test
+ * exercises. A scripted `stdoutRaw` is parsed as JSON event lines so older
+ * fixtures still replay; there is no stdout transport. `stderr` only names the
+ * failure a non-zero `exitCode` raises.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ChildSession, ChildSessionEvent, ChildSessionFactory, ChildSessionLaunch } from "../../src/runs/shared/child-session.ts";
+import { isChildWatchdogStatusEvent } from "../../src/watchdog/child-status.ts";
+
+export interface FakeChildResponse {
+	output?: string;
+	stderr?: string;
+	exitCode?: number;
+	delay?: number;
+	waitForPath?: string;
+	keepAliveAfterFinalMessageMs?: number;
+	jsonl?: unknown[];
+	/** Raw JSON lines; parsed into events for the in-process child without acceptance-report injection. */
+	stdoutRaw?: string;
+	steps?: Array<{ delay?: number; waitForPath?: string; jsonl?: unknown[]; stdoutRaw?: string }>;
+	/** Emits one assistant message with a JSON object of the listed names mapped to null; in-process children have no launch environment. */
+	echoEnv?: string[];
+	matchArgIncludes?: string | string[];
+	/** Files the fake child writes before emitting output, standing in for its write-tool side effects. */
+	writeFiles?: Array<{ path: string; content: string }>;
+	/** Captures structured output through the runtime config without emitting a structured_output tool event. */
+	structuredOutputCapture?: unknown;
+	structuredOutputAcceptanceReport?: unknown;
+	/** Captures structured output and emits the structured_output tool events. */
+	structuredOutput?: unknown;
+	runtimeAcknowledgedExtensions?: unknown;
+	missingTools?: string[];
+	/** Rejects the session creation itself (a startup failure). */
+	createError?: string;
+	/** Keeps the run open until the parent aborts it. */
+	hangUntilAbort?: boolean;
+}
+
+export interface FakeChildSessionRecord {
+	launch: ChildSessionLaunch;
+	task: string | undefined;
+	steers: Array<{ text: string; mode: "steer" | "followUp" }>;
+	aborted: boolean;
+	disposed: boolean;
+	settled: boolean;
+	session?: ChildSession;
+}
+
+export interface FakeChildSessions {
+	readonly sessions: FakeChildSessionRecord[];
+	readonly factory: ChildSessionFactory;
+	readonly disposeCalls: number;
+	reset(): void;
+}
+
+function listPendingFiles(dir: string): string[] {
+	try {
+		return fs.readdirSync(dir).filter((name) => name.startsWith("pending-") && name.endsWith(".json")).sort();
+	} catch {
+		return [];
+	}
+}
+
+function readJson(filePath: string): FakeChildResponse | undefined {
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf-8")) as FakeChildResponse;
+	} catch {
+		return undefined;
+	}
+}
+
+function responseMatches(response: FakeChildResponse, haystack: string): boolean {
+	const matcher = response.matchArgIncludes;
+	if (matcher === undefined) return true;
+	const needles = Array.isArray(matcher) ? matcher : [matcher];
+	return needles.every((needle) => typeof needle === "string" && haystack.includes(needle));
+}
+
+function claimResponse(dir: string, fileName: string): FakeChildResponse | undefined {
+	const sourcePath = path.join(dir, fileName);
+	const targetPath = path.join(dir, fileName.replace(/^pending-/, "consumed-"));
+	try {
+		fs.renameSync(sourcePath, targetPath);
+		return JSON.parse(fs.readFileSync(targetPath, "utf-8")) as FakeChildResponse;
+	} catch {
+		return undefined;
+	}
+}
+
+function claimNextResponse(dir: string, haystack: string): FakeChildResponse {
+	for (const withMatcher of [true, false]) {
+		for (const fileName of listPendingFiles(dir)) {
+			const response = readJson(path.join(dir, fileName));
+			if (!response || Object.prototype.hasOwnProperty.call(response, "matchArgIncludes") !== withMatcher) continue;
+			if (!responseMatches(response, haystack)) continue;
+			const claimed = claimResponse(dir, fileName);
+			if (claimed) return claimed;
+		}
+	}
+	const fallback = readJson(path.join(dir, "default-response.json"));
+	if (fallback && responseMatches(fallback, haystack)) return fallback;
+	return { output: "ok" };
+}
+
+/** Synthetic argv in the shape existing call assertions read; a child session receives no argv. */
+export function fakeChildArgs(launch: ChildSessionLaunch, task: string): string[] {
+	const args: string[] = ["--mode", "json", "-p"];
+	if (launch.storage.kind === "file") args.push("--session", launch.storage.sessionFile);
+	else if (launch.storage.kind === "dir") args.push("--session-dir", launch.storage.sessionDir);
+	else if (launch.storage.kind === "memory") args.push("--no-session");
+	if (launch.model) args.push("--model", launch.model);
+	if (launch.tools) {
+		if (launch.tools.length > 0) args.push("--tools", launch.tools.join(","));
+		else args.push("--no-tools");
+	} else if (launch.excludeTools?.length) args.push("--exclude-tools", launch.excludeTools.join(","));
+	if (!launch.ambientExtensions) args.push("--no-extensions");
+	for (const extensionPath of launch.extensionPaths) args.push("--extension", extensionPath);
+	if (launch.noContextFiles) args.push("--no-context-files");
+	if (launch.noSkills) args.push("--no-skills");
+	if (launch.systemPrompt !== undefined) args.push("--system-prompt", launch.systemPrompt);
+	if (launch.appendSystemPrompt !== undefined) args.push("--append-system-prompt", launch.appendSystemPrompt);
+	args.push(task);
+	return args;
+}
+
+function defaultAssistantMessage(output: string, model: string | undefined): unknown {
+	return {
+		type: "message_end",
+		message: {
+			role: "assistant",
+			content: [{ type: "text", text: output }],
+			model: model ?? "mock/test-model",
+			stopReason: "stop",
+			usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: { total: 0.001 } },
+		},
+	};
+}
+
+function defaultAcceptanceReport(): string {
+	return [
+		"```acceptance-report",
+		JSON.stringify({
+			criteriaSatisfied: [
+				{ id: "criterion-1", status: "satisfied", evidence: "mock acceptance evidence" },
+				{ id: "criterion-2", status: "satisfied", evidence: "mock acceptance evidence" },
+			],
+			changedFiles: ["mock-file.ts"],
+			testsAddedOrUpdated: ["mock-file.test.ts"],
+			commandsRun: [{ command: "mock validation", result: "passed", summary: "passed" }],
+			validationOutput: ["mock validation passed"],
+			residualRisks: [],
+			noStagedFiles: true,
+			reviewFindings: [],
+			manualNotes: "mock run completed",
+			notes: "mock run completed",
+		}),
+		"```",
+	].join("\n");
+}
+
+function withAcceptanceReport(output: string, prompt: string): string {
+	if (!prompt.includes("## Acceptance Contract") || output.includes("```acceptance-report")) return output;
+	return `${output}\n${defaultAcceptanceReport()}`;
+}
+
+function sleep(ms: number, until?: Promise<void>): Promise<void> {
+	const wait = new Promise<void>((resolve) => setTimeout(resolve, ms));
+	return until ? Promise.race([wait, until]) : wait;
+}
+
+function parseRawStdout(response: FakeChildResponse): unknown[] {
+	const chunks: Buffer[] = [];
+	if (typeof response.stdoutRaw === "string") chunks.push(Buffer.from(response.stdoutRaw, "utf-8"));
+	const entries: unknown[] = [];
+	for (const line of Buffer.concat(chunks).toString("utf-8").split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			entries.push(JSON.parse(line));
+		} catch {
+			// Non-JSON stdout is not an event for an in-process child.
+		}
+	}
+	return entries;
+}
+
+/** Model id without a `:thinking` suffix, as the child would report it. */
+function reportedModel(model: string | undefined): string | undefined {
+	if (!model) return undefined;
+	const colon = model.lastIndexOf(":");
+	if (colon === -1) return model;
+	const suffix = model.slice(colon + 1);
+	return ["off", "minimal", "low", "medium", "high", "xhigh"].includes(suffix) ? model.slice(0, colon) : model;
+}
+
+export function createFakeChildSessions(queueDir: () => string): FakeChildSessions {
+	const sessions: FakeChildSessionRecord[] = [];
+	let disposeCalls = 0;
+	const factory: ChildSessionFactory = {
+		async create(launch) {
+			const record: FakeChildSessionRecord = { launch, task: undefined, steers: [], aborted: false, disposed: false, settled: false };
+			sessions.push(record);
+			const listeners = new Set<(event: ChildSessionEvent) => void>();
+			const messages: AgentMessage[] = [];
+			const model = reportedModel(launch.model);
+			let abortResolve: (() => void) | undefined;
+			const abortedPromise = new Promise<void>((resolve) => { abortResolve = resolve; });
+			const sessionId = randomUUID();
+			let sessionFile: string | undefined;
+			if (launch.storage.kind === "file") {
+				sessionFile = launch.storage.sessionFile;
+				fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+				fs.writeFileSync(sessionFile, "", { flag: "a" });
+			} else if (launch.storage.kind === "dir") {
+				// A real session writes its file on the first message; the scripted child leaves the directory empty.
+				fs.mkdirSync(launch.storage.sessionDir, { recursive: true });
+			}
+			/** Steers are also appended to `steers.jsonl` in the queue dir so a test can observe a child hosted in another process. */
+			const recordSteer = (text: string, mode: "steer" | "followUp"): void => {
+				try {
+					fs.appendFileSync(path.join(queueDir(), "steers.jsonl"), `${JSON.stringify({ sessionId, text, mode })}\n`, "utf-8");
+				} catch {
+					// Observability for tests only.
+				}
+			};
+			const emit = (event: unknown): void => {
+				const typed = event as ChildSessionEvent & { message?: AgentMessage };
+				if ((typed.type === "message_end" || typed.type === "tool_result_end") && typed.message) messages.push(typed.message);
+				for (const listener of [...listeners]) listener(typed);
+			};
+			let sawProviderError = false;
+			const emitEntries = async (entries: unknown[], task: string, injectAcceptance = true): Promise<void> => {
+				for (const entry of entries) {
+					if (record.aborted) return;
+					const typed = entry as { type?: string; message?: { content?: Array<{ type?: string; text?: string }>; errorMessage?: string; stopReason?: string } };
+					if (typed?.type === "message_end" && injectAcceptance) {
+						const textPart = typed.message?.content?.find?.((part) => part?.type === "text");
+						const providerError = Boolean(typed.message?.errorMessage || typed.message?.stopReason === "error");
+						if (providerError) sawProviderError = true;
+						// Native acceptance lives in system resources, not the compactable task.
+						if (!providerError && textPart && typeof textPart.text === "string" && (!sawProviderError || textPart.text.trim())) textPart.text = withAcceptanceReport(textPart.text, [launch.systemPrompt, launch.appendSystemPrompt, task].join("\n"));
+					}
+					// A real child's watchdog hook reports through the host's sink, not the session stream.
+					if (isChildWatchdogStatusEvent(entry)) launch.runtime.watchdogStatus?.(entry);
+					else emit(entry);
+					await Promise.resolve();
+				}
+			};
+			const waitForReleasePath = async (releasePath: string | undefined): Promise<void> => {
+				if (typeof releasePath !== "string") return;
+				const deadline = Date.now() + 30_000;
+				while (!fs.existsSync(releasePath)) {
+					if (record.aborted) return;
+					if (Date.now() >= deadline) throw new Error(`Timed out waiting for mock release path: ${releasePath}`);
+					await sleep(20, abortedPromise);
+				}
+			};
+			const runScript = async (response: FakeChildResponse, task: string): Promise<void> => {
+				if (typeof response.delay === "number" && response.delay > 0) await sleep(response.delay, abortedPromise);
+				await waitForReleasePath(response.waitForPath);
+				if (record.aborted) return;
+				for (const file of response.writeFiles ?? []) {
+					if (!file || typeof file.path !== "string" || typeof file.content !== "string") continue;
+					const target = path.resolve(launch.cwd, file.path);
+					fs.mkdirSync(path.dirname(target), { recursive: true });
+					fs.writeFileSync(target, file.content, "utf-8");
+				}
+				if (Object.prototype.hasOwnProperty.call(response, "structuredOutputCapture")) {
+					launch.runtime.structuredOutput?.capture(
+						response.structuredOutputCapture,
+						Object.prototype.hasOwnProperty.call(response, "structuredOutputAcceptanceReport") ? response.structuredOutputAcceptanceReport : undefined,
+					);
+				}
+				if (Object.prototype.hasOwnProperty.call(response, "runtimeAcknowledgedExtensions")) {
+					const raw = response.runtimeAcknowledgedExtensions as { ids?: unknown } | unknown[];
+					const ids = Array.isArray(raw) ? raw : Array.isArray(raw?.ids) ? raw.ids : [];
+					launch.runtime.runtimeAcknowledgements?.(ids.filter((id): id is string => typeof id === "string"));
+				}
+				if (Array.isArray(response.missingTools) && response.missingTools.length > 0) {
+					const required = launch.runtime.requiredTools ?? [];
+					const missing = response.missingTools.filter((name) => required.includes(name));
+					if (missing.length > 0) {
+						launch.runtime.toolDiagnostic?.({
+							...(launch.runtime.agent ? { agent: launch.runtime.agent } : {}),
+							required,
+							available: required.filter((name) => !missing.includes(name)),
+							missing,
+						});
+					}
+				}
+				emit({ type: "agent_start" });
+				if (Array.isArray(response.steps) && response.steps.length > 0) {
+					for (const step of response.steps) {
+						if (typeof step?.delay === "number" && step.delay > 0) await sleep(step.delay, abortedPromise);
+						await waitForReleasePath(step?.waitForPath);
+						if (record.aborted) return;
+						if (Array.isArray(step?.jsonl)) await emitEntries(step.jsonl, task);
+						await emitEntries(parseRawStdout(step ?? {}), task, false);
+					}
+				} else if (Array.isArray(response.jsonl) && response.jsonl.length > 0) {
+					await emitEntries(response.jsonl, task);
+				} else if (response.stdoutRaw !== undefined) {
+					await emitEntries(parseRawStdout(response), task, false);
+				} else if (Array.isArray(response.echoEnv) && response.echoEnv.length > 0) {
+					await emitEntries([defaultAssistantMessage(JSON.stringify(Object.fromEntries(response.echoEnv.map((key) => [key, null]))), model)], task);
+				} else if (typeof response.output === "string") {
+					await emitEntries([defaultAssistantMessage(response.output, model)], task);
+				}
+				if (Object.prototype.hasOwnProperty.call(response, "structuredOutput")) {
+					launch.runtime.structuredOutput?.capture(response.structuredOutput, undefined);
+					emit({ type: "tool_execution_start", toolName: "structured_output", args: { value: response.structuredOutput } });
+					emit({ type: "tool_result_end", message: { role: "toolResult", toolName: "structured_output", content: [{ type: "text", text: "Structured output captured." }] } });
+					emit({ type: "tool_execution_end", toolName: "structured_output" });
+				}
+				if (record.aborted) return;
+				emit({ type: "agent_end", messages: [...messages], willRetry: false });
+				emit({ type: "agent_settled" });
+				if (typeof response.keepAliveAfterFinalMessageMs === "number" && response.keepAliveAfterFinalMessageMs > 0) {
+					await Promise.race([sleep(response.keepAliveAfterFinalMessageMs), abortedPromise]);
+				}
+				if (response.hangUntilAbort) await abortedPromise;
+				if (typeof response.exitCode === "number" && response.exitCode !== 0) {
+					throw new Error(response.stderr?.trim() || `mock child exited with code ${response.exitCode}`);
+				}
+			};
+			const session: ChildSession = {
+				subscribe(listener) {
+					listeners.add(listener);
+					return () => listeners.delete(listener);
+				},
+				async prompt(text) {
+					record.task = text;
+					const systemPrompt = launch.systemPrompt ?? launch.appendSystemPrompt ?? "";
+					const args = fakeChildArgs(launch, text);
+					const response = claimNextResponse(queueDir(), `${args.join("\n")}\n${systemPrompt}`);
+					const dir = queueDir();
+					fs.mkdirSync(dir, { recursive: true });
+					const callPath = path.join(dir, `call-${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.json`);
+					fs.writeFileSync(callPath, JSON.stringify({
+						args,
+						effectiveArgs: args,
+						cwd: launch.cwd,
+						systemPrompts: launch.systemPrompt !== undefined
+							? [{ mode: "--system-prompt", text: launch.systemPrompt }]
+							: launch.appendSystemPrompt !== undefined
+								? [{ mode: "--append-system-prompt", text: launch.appendSystemPrompt }]
+								: [],
+						requiredChildTools: launch.runtime.requiredTools ?? [],
+						launch: {
+							cwd: launch.cwd,
+							storage: launch.storage,
+							model: launch.model,
+							tools: launch.tools,
+							excludeTools: launch.excludeTools,
+							extensionPaths: launch.extensionPaths,
+							ambientExtensions: launch.ambientExtensions,
+							hooks: launch.hooks.map((hook) => hook.name),
+							noSkills: launch.noSkills,
+							noContextFiles: launch.noContextFiles,
+							processEnv: launch.processEnv,
+						},
+						runtime: { ...launch.runtime, structuredOutput: launch.runtime.structuredOutput ? { schema: launch.runtime.structuredOutput.schema, acceptanceReport: launch.runtime.structuredOutput.acceptanceReport } : undefined },
+					}), "utf-8");
+					if (response.createError) throw new Error(response.createError);
+					try {
+						await runScript(response, text);
+					} finally {
+						record.settled = true;
+					}
+				},
+				async steer(text) {
+					record.steers.push({ text, mode: "steer" });
+					recordSteer(text, "steer");
+				},
+				async followUp(text) {
+					record.steers.push({ text, mode: "followUp" });
+					recordSteer(text, "followUp");
+				},
+				async abort() {
+					record.aborted = true;
+					abortResolve?.();
+				},
+				async dispose() {
+					record.disposed = true;
+				},
+				get messages() { return messages; },
+				get sessionFile() { return sessionFile; },
+				get sessionId() { return sessionId; },
+				get modelId() { return model; },
+			};
+			record.session = session;
+			return session;
+		},
+		async dispose() {
+			disposeCalls += 1;
+			for (const record of sessions) {
+				if (record.session?.detached) continue;
+				if (record.session) record.session.shutDown = true;
+				await record.session?.abort();
+				record.aborted = true;
+				record.disposed = true;
+			}
+		},
+	};
+	return {
+		sessions,
+		factory,
+		get disposeCalls() { return disposeCalls; },
+		reset() { sessions.length = 0; },
+	};
+}

package/dist/extensions/pi-subagents/test/support/foreign-workflow-steer-host.mjs

@@ -0,0 +1,13 @@
+// Separate caller process: deliberately no local workflow/controller state.
+import fs from "node:fs";
+import { createSubagentExecutor } from "../../src/runs/foreground/subagent-executor.ts";
+import { makeMinimalCtx, createEventBus } from "./helpers.ts";
+import { currentCompletionOwnerId } from "../../src/shared/completion-owner.ts";
+const [cwd, sessionFile, paramsJson, output, policy = "auto"] = process.argv.slice(2);
+const state = { baseCwd: cwd, currentSessionId: null, asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null };
+const executor = createSubagentExecutor({ pi: { events: createEventBus(), getSessionName: () => undefined }, state, config: { authorityPolicy: { steerRun: policy } }, asyncByDefault: false, tempArtifactsDir: cwd, getSubagentSessionRoot: () => cwd, expandTilde: p => p, discoverAgents: () => ({ agents: [] }), kill: () => { throw new Error("foreign steering must not probe/kill an owner"); } });
+const ctx = makeMinimalCtx(cwd);
+ctx.sessionManager.getSessionFile = () => sessionFile;
+ctx.sessionManager.getSessionId = () => "different-runtime-id-in-caller";
+const result = await executor.execute("foreign-steer", { action: "steer", message: "B actual tool route", ...JSON.parse(paramsJson) }, new AbortController().signal, undefined, ctx);
+fs.writeFileSync(output, JSON.stringify({ pid: process.pid, sessionId: state.currentSessionId, completionOwnerId: currentCompletionOwnerId(), controllers: state.workflowControllers?.size ?? 0, controls: state.foregroundControls.size, result }));

package/dist/extensions/pi-subagents/test/support/mock-pi.ts

@@ -1,42 +1,27 @@
+/**
+ * Scripted child sessions for tests.
+ *
+ * `install()` replaces the process-wide foreground `ChildSessionFactory` with
+ * a scripted one and names the runner-side scripted factory module for
+ * background launches. Both replay the responses queued with `onCall()` from
+ * one directory, so a test scripts a child the same way whichever launch path
+ * it exercises.
+ */
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
+import { setChildSessionFactory, setChildSessionFactoryModule } from "../../src/runs/shared/child-session.ts";
+import { createFakeChildSessions, type FakeChildResponse, type FakeChildSessionRecord } from "./fake-child-session.ts";
 
-interface MockPiResponse {
-	output?: string;
-	stderr?: string;
-	exitCode?: number;
-	signal?: NodeJS.Signals;
-	delay?: number;
-	waitForPath?: string;
-	keepAliveAfterFinalMessageMs?: number;
-	ignoreSigterm?: boolean;
-	jsonl?: unknown[];
-	stdoutRaw?: string;
-	stdoutBase64Chunks?: string[];
-	steps?: Array<{
-		delay?: number;
-		waitForPath?: string;
-		jsonl?: unknown[];
-		stdoutRaw?: string;
-		stdoutBase64Chunks?: string[];
-		stderr?: string;
-	}>;
-	echoEnv?: string[];
-	missingTools?: string[];
-	matchArgIncludes?: string | string[];
-	/** Files the mock child writes to disk before emitting output, standing in for its write-tool side effects. */
-	writeFiles?: Array<{ path: string; content: string }>;
-	/** Writes the structured-output capture file without emitting a structured_output tool event. */
-	structuredOutputCapture?: unknown;
-	structuredOutputAcceptanceReport?: unknown;
-	structuredOutputAcceptanceReportRaw?: string;
-	runtimeAcknowledgedExtensions?: unknown;
-}
+export type MockPiResponse = FakeChildResponse;
 
 export interface MockPi {
 	readonly dir: string;
+	/** In-process foreground child sessions created since the last reset, in launch order. */
+	readonly sessions: FakeChildSessionRecord[];
+	/** Number of times the foreground child session factory was disposed. */
+	readonly disposeCalls: number;
 	install(): void;
 	uninstall(): void;
 	onCall(response: MockPiResponse): void;
@@ -44,8 +29,7 @@ export interface MockPi {
 	callCount(): number;
 }
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SCRIPT_PATH = path.join(__dirname, "mock-pi-script.mjs");
+const RUNNER_FACTORY_MODULE = path.join(path.dirname(fileURLToPath(import.meta.url)), "runner-child-session-factory.ts");
 const CALL_PREFIX = "call-";
 const DEFAULT_RESPONSE_FILE = "default-response.json";
 const QUEUED_PREFIX = "pending-";
@@ -54,11 +38,6 @@ function ensureDir(dir: string): void {
 	fs.mkdirSync(dir, { recursive: true });
 }
 
-function writeExecutable(filePath: string, content: string): void {
-	fs.writeFileSync(filePath, content, "utf-8");
-	fs.chmodSync(filePath, 0o755);
-}
-
 function listQueueFiles(queueDir: string, prefix: string): string[] {
 	try {
 		return fs.readdirSync(queueDir)
@@ -73,62 +52,36 @@ export function createMockPi(): MockPi {
 	const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-mock-cli-"));
 	let queueGeneration = 0;
 	let queueDir = path.join(rootDir, `queue-${queueGeneration}`);
-	const binDir = path.join(rootDir, "bin");
-	const piPackageDir = path.join(rootDir, "pi-package");
-	const cliScriptPath = path.join(piPackageDir, "dist", "cli.mjs");
 	ensureDir(queueDir);
-	ensureDir(binDir);
-	ensureDir(path.dirname(cliScriptPath));
-	fs.copyFileSync(SCRIPT_PATH, cliScriptPath);
-	fs.writeFileSync(
-		path.join(piPackageDir, "package.json"),
-		JSON.stringify({ name: "@selesai/code" }),
-		"utf-8",
-	);
-
-	const shellScriptPath = path.join(binDir, "pi");
-	const cmdScriptPath = path.join(binDir, "pi.cmd");
-	writeExecutable(shellScriptPath, `#!/bin/sh\nexec "${process.execPath}" "${cliScriptPath}" "$@"\n`);
-	writeExecutable(cmdScriptPath, `@echo off\r\n"${process.execPath}" "${cliScriptPath}" %*\r\n`);
 
+	const fakeSessions = createFakeChildSessions(() => queueDir);
 	let installed = false;
 	let nextSequence = 0;
-	let originalPath: string | undefined;
-	let originalPiBinary: string | undefined;
-	let originalArgv1: string | undefined;
 	let originalQueueEnv: string | undefined;
 
 	return {
 		get dir() {
 			return queueDir;
 		},
+		get sessions() {
+			return fakeSessions.sessions;
+		},
+		get disposeCalls() {
+			return fakeSessions.disposeCalls;
+		},
 		install() {
 			if (installed) return;
 			installed = true;
-			originalPath = process.env.PATH;
-			originalPiBinary = process.env.SELESAI_SUBAGENT_SELESAI_BINARY;
+			setChildSessionFactory(fakeSessions.factory);
+			setChildSessionFactoryModule(RUNNER_FACTORY_MODULE);
 			originalQueueEnv = process.env.MOCK_PI_QUEUE_DIR;
-			process.env.PATH = `${binDir}${path.delimiter}${originalPath ?? ""}`;
-			if (process.platform === "win32") {
-				delete process.env.SELESAI_SUBAGENT_SELESAI_BINARY;
-				originalArgv1 = process.argv[1];
-				process.argv[1] = cliScriptPath;
-			} else {
-				process.env.SELESAI_SUBAGENT_SELESAI_BINARY = shellScriptPath;
-			}
 			process.env.MOCK_PI_QUEUE_DIR = queueDir;
 		},
 		uninstall() {
 			if (!installed) return;
 			installed = false;
-			if (originalPath === undefined) delete process.env.PATH;
-			else process.env.PATH = originalPath;
-			if (originalPiBinary === undefined) delete process.env.SELESAI_SUBAGENT_SELESAI_BINARY;
-			else process.env.SELESAI_SUBAGENT_SELESAI_BINARY = originalPiBinary;
-			if (process.platform === "win32") {
-				if (originalArgv1 === undefined) delete process.argv[1];
-				else process.argv[1] = originalArgv1;
-			}
+			setChildSessionFactory(undefined);
+			setChildSessionFactoryModule(undefined);
 			if (originalQueueEnv === undefined) delete process.env.MOCK_PI_QUEUE_DIR;
 			else process.env.MOCK_PI_QUEUE_DIR = originalQueueEnv;
 			try {
@@ -147,6 +100,7 @@ export function createMockPi(): MockPi {
 		},
 		reset() {
 			nextSequence = 0;
+			fakeSessions.reset();
 			queueGeneration += 1;
 			queueDir = path.join(rootDir, `queue-${queueGeneration}`);
 			ensureDir(queueDir);
@@ -156,4 +110,4 @@ export function createMockPi(): MockPi {
 			return listQueueFiles(queueDir, CALL_PREFIX).length;
 		},
 	};
-}
+}

package/dist/extensions/pi-subagents/test/support/notify-diagnostics-fixture.ts

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import registerSubagentNotify, { type CompletionNotification } from "../../src/runs/background/notify.ts";
+
+const callbacks = new Map<number, () => void>();
+let timerId = 0;
+let now = 0;
+let failSend = false;
+const state = { currentSessionId: "session-a", completionOwnerId: "owner-a" };
+const sent: unknown[] = [];
+const pi = {
+	events: { on: () => () => {} },
+	sendMessage(message: unknown, options: unknown) {
+		if (failSend) throw new Error("PRIVATE_ERROR_CREDENTIAL");
+		sent.push({ message, options });
+	},
+};
+const notifier = registerSubagentNotify(pi as never, state, {
+	now: () => now,
+	timers: {
+		setTimeout(callback) { callbacks.set(++timerId, callback); return timerId; },
+		clearTimeout(handle) { callbacks.delete(handle as number); },
+	},
+});
+const result = (id: string, extra: Partial<CompletionNotification> = {}): CompletionNotification => ({
+	id, runId: id, sessionId: "session-a", completionOwnerId: "owner-a", success: true,
+	summary: "PRIVATE_OUTPUT", task: "PRIVATE_TASK", credential: "PRIVATE_CREDENTIAL",
+	sessionFile: "/PRIVATE_SESSION_PATH", ...extra,
+});
+const flush = () => { for (const callback of [...callbacks.values()]) callback(); };
+assert.equal(await notifier.deliver(result("missing", { sessionId: undefined })), false);
+assert.equal(await notifier.deliver(result("foreground-other", { source: "foreground", sessionId: "other" })), false);
+assert.equal(await notifier.deliver(result("foreign", { completionOwnerId: "other" })), false);
+assert.equal(await notifier.deliver(result("relayed", { intercomDelivered: true })), true);
+assert.equal(sent.length, 0);
+const first = result("first");
+const firstDelivery = notifier.deliver(first);
+assert.equal(notifier.deliver(first), firstDelivery);
+const secondDelivery = notifier.deliver(result("second"));
+assert.equal(sent.length, 0);
+assert.equal(notifier.hasPendingDelivery(), true);
+flush();
+assert.equal(await firstDelivery, true);
+assert.equal(await secondDelivery, true);
+assert.equal(sent.length, 1); // grouped, not dropped
+now = 600_000;
+assert.equal(await notifier.deliver(first), true); // inclusive TTL boundary
+assert.equal(sent.length, 1);
+now++;
+const expired = notifier.deliver(first);
+flush();
+assert.equal(await expired, true);
+assert.equal(sent.length, 2);
+const lostOwnership = notifier.deliver(result("owner-changed"));
+state.completionOwnerId = "other";
+flush();
+assert.equal(await lostOwnership, false);
+state.completionOwnerId = "owner-a";
+failSend = true;
+assert.equal(await notifier.deliver(result("retry", { success: false })), false);
+failSend = false;
+assert.equal(await notifier.deliver(result("retry", { success: false })), true);
+assert.equal(await notifier.deliver(result("foreground", { source: "foreground" })), true);
+// Attention still flushes held successes before its own immediate send.
+const held = notifier.deliver(result("held"));
+assert.equal(await notifier.deliver(result("attention", { success: false })), true);
+assert.equal(await held, true);
+const abandoned = notifier.deliver(result("abandoned"));
+notifier.dispose();
+assert.equal(await abandoned, false);
+assert.equal(notifier.hasPendingDelivery(), false);
+assert.equal(callbacks.size, 0);
+assert.equal(await notifier.deliver(result("after-dispose")), false);
+// Malformed/large identity cannot create multiline or unbounded trace records.
+await notifier.deliver(result("unsafe\n\u001b[31m" + "x".repeat(10_000)));
+// Disabled diagnostics must not even read diagnostic identity fields at a guard.
+if (!process.env.NODE_DEBUG) {
+	const unread = result("unread");
+	Object.defineProperty(unread, "runId", { get() { throw new Error("diagnostic metadata read while disabled"); } });
+	assert.equal(await notifier.deliver(unread), false);
+}
+const immediate = registerSubagentNotify(pi as never, state, { batchConfig: { enabled: false } });
+assert.equal(await immediate.deliver(result("unbatched", { triggerTurn: false })), true);
+immediate.dispose();
+console.log(JSON.stringify(sent));