@selesai/code 0.5.19 → 0.5.21

package/dist/extensions/pi-subagents/test/integration/slash-live-state.test.ts

@@ -63,6 +63,33 @@ describe("slash live state", { skip: !available ? "slash-live-state.ts not impor
 		assert.equal(snapshot.version > 0, true);
 	});
 
+	it("does not assign a parallel child update to another chain placeholder", () => {
+		clearSlashSnapshots!();
+		const details = buildSlashInitialResult!("req-parallel", {
+			chain: [{ parallel: [{ agent: "scout", task: "map" }, { agent: "context-builder", task: "analyze" }] }],
+		});
+
+		applySlashUpdate!("req-parallel", {
+			requestId: "req-parallel",
+			progress: [{
+				index: 1,
+				agent: "context-builder",
+				status: "running",
+				task: "analyze",
+				currentTool: "find",
+				recentTools: [],
+				recentOutput: [],
+				toolCount: 38,
+				tokens: 1_000,
+				durationMs: 1_000,
+			}],
+		});
+
+		const results = getSlashRenderableSnapshot!(details).result.details.results;
+		assert.equal(results[0]?.progress?.currentTool, undefined);
+		assert.equal(results[1]?.progress?.currentTool, "find");
+	});
+
 	it("creates stable placeholders for a 40-step worker/reviewer chain", () => {
 		clearSlashSnapshots!();
 		const chain = Array.from({ length: 40 }, (_, index) => ({

package/dist/extensions/pi-subagents/test/integration/top-level-async.test.ts

@@ -3,7 +3,7 @@ import { describe, it } from "node:test";
 import { tryImport } from "../support/helpers.ts";
 
 interface TopLevelAsyncModule {
-	applyForceTopLevelAsyncOverride<T extends { async?: boolean; clarify?: boolean }>(
+	applyForceTopLevelAsyncOverride<T extends { async?: boolean; clarify?: boolean; foregroundOnly?: boolean }>(
 		params: T,
 		depth: number,
 		forceTopLevelAsync: boolean,
@@ -23,6 +23,12 @@ describe("force top-level async helper", { skip: !available ? "pi packages not a
 		assert.equal(next.agent, "worker");
 	});
 
+	it("keeps bridge-owned foreground calls attached", () => {
+		const params = { async: false, clarify: false, foregroundOnly: true };
+		const next = mod!.applyForceTopLevelAsyncOverride(params, 0, true);
+		assert.equal(next, params);
+	});
+
 	it("leaves nested calls unchanged", () => {
 		const params = { async: false, clarify: true };
 		const next = mod!.applyForceTopLevelAsyncOverride(params, 1, true);

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

@@ -51,6 +51,8 @@ interface AgentConfig {
 	extensions?: string[];
 	subagentOnlyExtensions?: string[];
 	skills?: string[];
+	skillPath?: string[];
+	filePath?: string;
 	thinking?: string;
 	systemPromptMode?: string;
 	inheritProjectContext?: boolean;
@@ -59,6 +61,7 @@ interface AgentConfig {
 	output?: string | false;
 	reads?: string[] | false;
 	progress?: boolean;
+	toolBudget?: { soft?: number; hard: number; block?: string[] | "*" };
 	mcpDirectTools?: string[];
 	maxSubagentDepth?: number;
 	completionGuard?: boolean;
@@ -153,6 +156,8 @@ export async function tryImport<T>(specifier: string): Promise<T | null> {
 	}
 }
 
+let writeCallSeq = 0;
+
 export const events = {
 	assistantMessage(text: string, model = "mock/test-model"): object {
 		return {
@@ -167,6 +172,33 @@ export const events = {
 		};
 	},
 
+	/** Assistant write tool call plus its successful tool result, as one completed write. */
+	completedWrite(filePath: string, content: string, model = "mock/test-model"): object[] {
+		const id = `write-${++writeCallSeq}`;
+		return [
+			{
+				type: "message_end",
+				message: {
+					role: "assistant",
+					content: [{ type: "toolCall", id, name: "write", arguments: { path: filePath, content } }],
+					model,
+					stopReason: "toolUse",
+					usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: { total: 0.001 } },
+				},
+			},
+			{
+				type: "tool_result_end",
+				message: {
+					role: "toolResult",
+					toolCallId: id,
+					toolName: "write",
+					isError: false,
+					content: [{ type: "text", text: `Wrote ${filePath}` }],
+				},
+			},
+		];
+	},
+
 	toolStart(toolName: string, args: Record<string, unknown> = {}): object {
 		return { type: "tool_execution_start", toolName, args };
 	},

package/dist/extensions/pi-subagents/test/support/mock-pi-script.mjs

@@ -167,6 +167,40 @@ function defaultResponse() {
 	return { output: "ok", exitCode: 0 };
 }
 
+function writeDeclaredFiles(response) {
+	if (!Array.isArray(response.writeFiles)) return;
+	for (const file of response.writeFiles) {
+		if (!file || typeof file.path !== "string" || typeof file.content !== "string") continue;
+		const target = path.resolve(process.cwd(), file.path);
+		fs.mkdirSync(path.dirname(target), { recursive: true });
+		fs.writeFileSync(target, file.content, "utf-8");
+	}
+}
+
+function writeStructuredOutputCapture(response) {
+	if (!Object.prototype.hasOwnProperty.call(response, "structuredOutputCapture")) return;
+	const outputPath = process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE;
+	if (!outputPath) return;
+	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+	fs.writeFileSync(outputPath, JSON.stringify(response.structuredOutputCapture), "utf-8");
+}
+
+function writeToolDiagnostic(response) {
+	if (!Array.isArray(response.missingTools) || response.missingTools.length === 0) return;
+	const diagnosticPath = process.env.SELESAI_SUBAGENT_TOOL_DIAGNOSTIC_PATH;
+	const required = JSON.parse(process.env.SELESAI_SUBAGENT_REQUIRED_TOOLS ?? "[]");
+	if (!diagnosticPath || !Array.isArray(required)) return;
+	const missing = response.missingTools.filter((name) => typeof name === "string" && required.includes(name));
+	const available = required.filter((name) => !missing.includes(name));
+	fs.mkdirSync(path.dirname(diagnosticPath), { recursive: true });
+	fs.writeFileSync(diagnosticPath, JSON.stringify({
+		agent: process.env.SELESAI_SUBAGENT_CHILD_AGENT,
+		required,
+		available,
+		missing,
+	}), "utf-8");
+}
+
 function isJsonMode(args) {
 	for (let i = 0; i < args.length; i++) {
 		if (args[i] === "--mode") {
@@ -220,6 +254,15 @@ async function writeJsonlLine(entry) {
 	await writeStdout(`${line}\n`);
 }
 
+async function writeRawStdout(entry) {
+	if (Array.isArray(entry?.stdoutBase64Chunks)) {
+		for (const chunk of entry.stdoutBase64Chunks) {
+			if (typeof chunk === "string") await writeStdout(Buffer.from(chunk, "base64"));
+		}
+	}
+	if (typeof entry?.stdoutRaw === "string") await writeStdout(entry.stdoutRaw);
+}
+
 function extractPlainText(entry) {
 	if (!entry || typeof entry !== "object") return "";
 	if (entry.type === "message_end") {
@@ -283,6 +326,7 @@ async function main() {
 		process.on("SIGTERM", () => {});
 	}
 	writeSessionFile(args);
+	writeToolDiagnostic(response);
 	fs.writeFileSync(
 		path.join(queueDir, `call-${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.json`),
 		JSON.stringify({ args, systemPrompts: readSystemPromptRecords(args) }),
@@ -292,6 +336,16 @@ async function main() {
 	if (typeof response.delay === "number" && response.delay > 0) {
 		await new Promise((resolve) => setTimeout(resolve, response.delay));
 	}
+	if (typeof response.waitForPath === "string") {
+		const deadline = Date.now() + 30_000;
+		while (!fs.existsSync(response.waitForPath)) {
+			if (Date.now() >= deadline) fail(`Timed out waiting for mock release path: ${response.waitForPath}`);
+			await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+	}
+
+	writeDeclaredFiles(response);
+	writeStructuredOutputCapture(response);
 
 	if (Array.isArray(response.steps) && response.steps.length > 0) {
 		for (const step of response.steps) {
@@ -299,14 +353,17 @@ async function main() {
 				await new Promise((resolve) => setTimeout(resolve, step.delay));
 				}
 				if (Array.isArray(step?.jsonl) && step.jsonl.length > 0) {
-						await writeResponseEntries(step.jsonl, jsonMode, args);
+					await writeResponseEntries(step.jsonl, jsonMode, args);
 				}
+				await writeRawStdout(step);
 				if (typeof step?.stderr === "string" && step.stderr.length > 0) {
 					process.stderr.write(step.stderr);
 				}
 			}
 		} else if (Array.isArray(response.jsonl) && response.jsonl.length > 0) {
-				await writeResponseEntries(response.jsonl, jsonMode, args);
+			await writeResponseEntries(response.jsonl, jsonMode, args);
+		} else if (Array.isArray(response.stdoutBase64Chunks) || typeof response.stdoutRaw === "string") {
+			await writeRawStdout(response);
 		} else if (Array.isArray(response.echoEnv) && response.echoEnv.length > 0) {
 			const envSnapshot = Object.fromEntries(response.echoEnv.map((key) => [key, process.env[key] ?? null]));
 				const output = withAcceptanceReport(JSON.stringify(envSnapshot), args);

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

@@ -8,16 +8,26 @@ interface MockPiResponse {
 	stderr?: string;
 	exitCode?: number;
 	delay?: number;
+	waitForPath?: string;
 	keepAliveAfterFinalMessageMs?: number;
 	ignoreSigterm?: boolean;
 	jsonl?: unknown[];
+	stdoutRaw?: string;
+	stdoutBase64Chunks?: string[];
 	steps?: Array<{
 		delay?: number;
 		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;
 }
 
 export interface MockPi {
@@ -58,17 +68,27 @@ export function createMockPi(): MockPi {
 	const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-mock-cli-"));
 	const queueDir = path.join(rootDir, "queue");
 	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}" "${SCRIPT_PATH}" "$@"\n`);
-	writeExecutable(cmdScriptPath, `@echo off\r\n"${process.execPath}" "${SCRIPT_PATH}" %*\r\n`);
+	writeExecutable(shellScriptPath, `#!/bin/sh\nexec "${process.execPath}" "${cliScriptPath}" "$@"\n`);
+	writeExecutable(cmdScriptPath, `@echo off\r\n"${process.execPath}" "${cliScriptPath}" %*\r\n`);
 
 	let installed = false;
 	let nextSequence = 0;
 	let originalPath: string | undefined;
+	let originalPiBinary: string | undefined;
 	let originalArgv1: string | undefined;
 	let originalQueueEnv: string | undefined;
 
@@ -80,25 +100,31 @@ export function createMockPi(): MockPi {
 			if (installed) return;
 			installed = true;
 			originalPath = process.env.PATH;
+			originalPiBinary = process.env.SELESAI_SUBAGENT_PI_BINARY;
 			originalQueueEnv = process.env.MOCK_PI_QUEUE_DIR;
 			process.env.PATH = `${binDir}${path.delimiter}${originalPath ?? ""}`;
-			process.env.MOCK_PI_QUEUE_DIR = queueDir;
 			if (process.platform === "win32") {
+				delete process.env.SELESAI_SUBAGENT_PI_BINARY;
 				originalArgv1 = process.argv[1];
-				process.argv[1] = SCRIPT_PATH;
+				process.argv[1] = cliScriptPath;
+			} else {
+				process.env.SELESAI_SUBAGENT_PI_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 (originalQueueEnv === undefined) delete process.env.MOCK_PI_QUEUE_DIR;
-			else process.env.MOCK_PI_QUEUE_DIR = originalQueueEnv;
+			if (originalPiBinary === undefined) delete process.env.SELESAI_SUBAGENT_PI_BINARY;
+			else process.env.SELESAI_SUBAGENT_PI_BINARY = originalPiBinary;
 			if (process.platform === "win32") {
 				if (originalArgv1 === undefined) delete process.argv[1];
 				else process.argv[1] = originalArgv1;
 			}
+			if (originalQueueEnv === undefined) delete process.env.MOCK_PI_QUEUE_DIR;
+			else process.env.MOCK_PI_QUEUE_DIR = originalQueueEnv;
 			try {
 				fs.rmSync(rootDir, { recursive: true, force: true });
 			} catch {}

package/dist/extensions/pi-subagents/test/support/real-session-child-cli.mjs

@@ -3,14 +3,11 @@ import { mkdtempSync, rmSync } from "node:fs";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import {
-	fauxAssistantMessage,
-	fauxText,
-	registerFauxProvider,
-} from "@earendil-works/pi-ai";
+import { fauxAssistantMessage, fauxProvider, fauxText, fauxToolCall } from "@earendil-works/pi-ai/providers/faux";
 import {
 	createAgentSession,
 	DefaultResourceLoader,
+	ModelRuntime,
 	SessionManager,
 	SettingsManager,
 } from "@selesai/code";
@@ -85,19 +82,6 @@ function parseArgs(argv) {
 	return parsed;
 }
 
-function createModelRegistry(model) {
-	return {
-		find: (provider, id) => provider === model.provider && id === model.id ? model : undefined,
-		getAll: () => [model],
-		getAvailable: () => [model],
-		hasConfiguredAuth: () => true,
-		isUsingOAuth: () => false,
-		getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "faux", headers: {} }),
-		registerProvider: () => {},
-		unregisterProvider: () => {},
-	};
-}
-
 function createSessionManager(parsed, cwd) {
 	if (parsed.sessionFile) {
 		const sessionDir = parsed.sessionDir ?? path.dirname(parsed.sessionFile);
@@ -112,19 +96,36 @@ function createSessionManager(parsed, cwd) {
 async function main() {
 	const parsed = parseArgs(process.argv.slice(2));
 	const responseText = process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT ?? "CHILD_REAL_SESSION_OK";
+	const reportChildTools = process.env.SELESAI_SUBAGENTS_E2E_REPORT_CHILD_TOOLS === "1";
 	const cwd = process.cwd();
 	const ownedAgentDir = process.env.SELESAI_CODING_AGENT_DIR
 		? undefined
 		: mkdtempSync(path.join(os.tmpdir(), "pi-e2e-agent-dir-"));
 	const agentDir = process.env.SELESAI_CODING_AGENT_DIR ?? ownedAgentDir;
 
-	const faux = registerFauxProvider({
+	const faux = fauxProvider({
 		provider: "faux-e2e-child",
 		models: [{ id: "child", contextWindow: 200_000 }],
 	});
-	const model = faux.getModel();
+	const modelRuntime = await ModelRuntime.create({
+		authPath: path.join(agentDir, "auth.json"),
+		modelsPath: null,
+		allowModelNetwork: false,
+	});
+	modelRuntime.registerProvider(faux.provider.id, {
+		name: faux.provider.name,
+		api: faux.api,
+		apiKey: "faux",
+		streamSimple: faux.provider.streamSimple,
+		models: [...faux.models],
+	});
+	const model = modelRuntime.getModel(faux.provider.id, "child");
+	if (!model) throw new Error("faux child model was not registered");
+	let session;
 	faux.setResponses([
-		() => fauxAssistantMessage(fauxText(responseText), { stopReason: "stop" }),
+		() => process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE
+			? fauxAssistantMessage(fauxToolCall("structured_output", { value: { marker: "STRUCTURED_OUTPUT_OK" } }), { stopReason: "toolUse" })
+			: fauxAssistantMessage(fauxText(reportChildTools ? `ACTIVE_TOOLS:${session?.getActiveToolNames().sort().join(",") ?? ""}` : responseText), { stopReason: "stop" }),
 	]);
 
 	const settingsManager = SettingsManager.inMemory({
@@ -146,16 +147,17 @@ async function main() {
 
 	try {
 		await loader.reload();
-		const { session } = await createAgentSession({
+		const created = await createAgentSession({
 			cwd,
 			agentDir,
 			model,
-			modelRegistry: createModelRegistry(model),
+			modelRuntime,
 			resourceLoader: loader,
 			sessionManager: createSessionManager(parsed, cwd),
 			settingsManager,
 			tools: parsed.tools,
 		});
+		session = created.session;
 
 		session.subscribe((event) => {
 			if (
@@ -173,7 +175,6 @@ async function main() {
 		await session.extensionRunner.emit({ type: "session_shutdown", reason: "quit" });
 		session.dispose();
 	} finally {
-		faux.unregister();
 		if (ownedAgentDir) rmSync(ownedAgentDir, { recursive: true, force: true });
 	}
 }

package/dist/extensions/pi-subagents/test/support/real-session-runner.ts

@@ -1,23 +1,21 @@
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { type AssistantMessage, type Context, type ToolCall } from "@earendil-works/pi-ai";
 import {
-	type AssistantMessage,
-	type Context,
 	type FauxContentBlock,
 	type FauxResponseStep,
 	fauxAssistantMessage,
 	fauxText,
 	fauxToolCall,
-	registerFauxProvider,
-	type ToolCall,
-} from "@earendil-works/pi-ai";
+	fauxProvider,
+} from "@earendil-works/pi-ai/providers/faux";
 import {
 	type AgentSession,
 	type AgentSessionEvent,
-	type ModelRegistry,
 	createAgentSession,
+	ModelRuntime,
 	DefaultResourceLoader,
 	SessionManager,
 	SettingsManager,
@@ -34,6 +32,8 @@ export interface RealSessionRunOptions {
 	childText: string;
 	respond: FauxResponder;
 	timeoutMs?: number;
+	projectFiles?: Record<string, string>;
+	reportChildTools?: boolean;
 }
 
 export interface RealSessionRun {
@@ -98,51 +98,59 @@ function toAssistantMessage(reply: FauxReply): AssistantMessage {
 	return fauxAssistantMessage(content, { stopReason: hasToolCall ? "toolUse" : "stop" });
 }
 
-function createModelRegistry(model: { provider: string; id: string }) {
-	return {
-		find: (provider: string, id: string) => provider === model.provider && id === model.id ? model : undefined,
-		getAll: () => [model],
-		getAvailable: () => [model],
-		hasConfiguredAuth: () => true,
-		isUsingOAuth: () => false,
-		getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "faux", headers: {} }),
-		registerProvider: () => {},
-		unregisterProvider: () => {},
-	};
-}
-
-function installChildPiShim(childText: string): () => void {
+function installChildPiShim(childText: string, reportChildTools = false): () => void {
 	const rootDir = mkdtempSync(path.join(os.tmpdir(), "pi-real-session-cli-"));
 	const binDir = path.join(rootDir, "bin");
+	const piPackageDir = path.join(rootDir, "pi-package");
+	const childCliPath = path.join(piPackageDir, "dist", "cli.mjs");
 	const previousPath = process.env.PATH;
+	const previousPiBinary = process.env.SELESAI_SUBAGENT_PI_BINARY;
 	const previousChildText = process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT;
+	const previousReportTools = process.env.SELESAI_SUBAGENTS_E2E_REPORT_CHILD_TOOLS;
 	const previousArgv1 = process.argv[1];
 
 	writeFileSync(path.join(rootDir, ".keep"), "");
 	mkdirSync(binDir, { recursive: true });
+	mkdirSync(path.dirname(childCliPath), { recursive: true });
+	writeFileSync(childCliPath, `import ${JSON.stringify(pathToFileURL(CHILD_CLI_PATH).href)};\n`);
+	writeFileSync(
+		path.join(piPackageDir, "package.json"),
+		JSON.stringify({ name: "@selesai/code" }),
+	);
 	writeFileSync(
 		path.join(binDir, "pi"),
-		`#!/bin/sh\nexec "${process.execPath}" "${CHILD_CLI_PATH}" "$@"\n`,
+		`#!/bin/sh\nexec "${process.execPath}" "${childCliPath}" "$@"\n`,
 		{ mode: 0o755 },
 	);
 	writeFileSync(
 		path.join(binDir, "pi.cmd"),
-		`@echo off\r\n"${process.execPath}" "${CHILD_CLI_PATH}" %*\r\n`,
+		`@echo off\r\n"${process.execPath}" "${childCliPath}" %*\r\n`,
 	);
 
 	process.env.PATH = `${binDir}${path.delimiter}${previousPath ?? ""}`;
+	if (process.platform === "win32") {
+		delete process.env.SELESAI_SUBAGENT_PI_BINARY;
+		process.argv[1] = childCliPath;
+	} else {
+		process.env.SELESAI_SUBAGENT_PI_BINARY = path.join(binDir, "pi");
+	}
 	process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT = childText;
-	if (process.platform === "win32") process.argv[1] = CHILD_CLI_PATH;
+	if (reportChildTools) process.env.SELESAI_SUBAGENTS_E2E_REPORT_CHILD_TOOLS = "1";
+	else delete process.env.SELESAI_SUBAGENTS_E2E_REPORT_CHILD_TOOLS;
 
 	return () => {
 		if (previousPath === undefined) delete process.env.PATH;
 		else process.env.PATH = previousPath;
-		if (previousChildText === undefined) delete process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT;
-		else process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT = previousChildText;
+		if (previousPiBinary === undefined) delete process.env.SELESAI_SUBAGENT_PI_BINARY;
+		else process.env.SELESAI_SUBAGENT_PI_BINARY = previousPiBinary;
 		if (process.platform === "win32") {
 			if (previousArgv1 === undefined) delete process.argv[1];
 			else process.argv[1] = previousArgv1;
 		}
+		if (previousChildText === undefined) delete process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT;
+		else process.env.SELESAI_SUBAGENTS_E2E_CHILD_TEXT = previousChildText;
+		if (previousReportTools === undefined) delete process.env.SELESAI_SUBAGENTS_E2E_REPORT_CHILD_TOOLS;
+		else process.env.SELESAI_SUBAGENTS_E2E_REPORT_CHILD_TOOLS = previousReportTools;
 		rmSync(rootDir, { recursive: true, force: true });
 	};
 }
@@ -171,11 +179,10 @@ export async function runRealSubagentSession(options: RealSessionRunOptions): Pr
 		["SELESAI_SUBAGENT_MAX_DEPTH", process.env.SELESAI_SUBAGENT_MAX_DEPTH],
 		["SELESAI_SUBAGENT_PARENT_SESSION", process.env.SELESAI_SUBAGENT_PARENT_SESSION],
 		["SELESAI_SUBAGENT_PI_BINARY", process.env.SELESAI_SUBAGENT_PI_BINARY],
-		["SELESAI_SUBAGENTS_PI_CODING_AGENT_PACKAGE_ROOT", process.env.SELESAI_SUBAGENTS_PI_CODING_AGENT_PACKAGE_ROOT],
+		["SELESAI_SUBAGENTS_SELESAI_CODING_AGENT_PACKAGE_ROOT", process.env.SELESAI_SUBAGENTS_SELESAI_CODING_AGENT_PACKAGE_ROOT],
 	]);
-	const uninstallChildPi = installChildPiShim(options.childText);
+	const uninstallChildPi = installChildPiShim(options.childText, options.reportChildTools);
 	let session: AgentSession | undefined;
-	let faux: ReturnType<typeof registerFauxProvider> | undefined;
 	let disposed = false;
 
 	const dispose = async () => {
@@ -187,7 +194,6 @@ export async function runRealSubagentSession(options: RealSessionRunOptions): Pr
 		try {
 			session?.dispose();
 		} catch {}
-		faux?.unregister();
 		uninstallChildPi();
 		restoreEnv(envSnapshot);
 		try {
@@ -208,14 +214,32 @@ export async function runRealSubagentSession(options: RealSessionRunOptions): Pr
 		delete process.env.SELESAI_SUBAGENT_DEPTH;
 		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
 		delete process.env.SELESAI_SUBAGENT_PARENT_SESSION;
-		delete process.env.SELESAI_SUBAGENT_PI_BINARY;
-		delete process.env.SELESAI_SUBAGENTS_PI_CODING_AGENT_PACKAGE_ROOT;
+		delete process.env.SELESAI_SUBAGENTS_SELESAI_CODING_AGENT_PACKAGE_ROOT;
+		for (const [relativePath, content] of Object.entries(options.projectFiles ?? {})) {
+			const target = path.resolve(cwd, relativePath);
+			if (target !== cwd && !target.startsWith(`${cwd}${path.sep}`)) throw new Error(`E2E project file escapes cwd: ${relativePath}`);
+			mkdirSync(path.dirname(target), { recursive: true });
+			writeFileSync(target, content, "utf-8");
+		}
 
-		faux = registerFauxProvider({
+		const faux = fauxProvider({
 			provider: "faux-e2e-parent",
 			models: [{ id: "parent", contextWindow: 200_000 }],
 		});
-		const model = faux.getModel();
+		const modelRuntime = await ModelRuntime.create({
+			authPath: path.join(home, "auth.json"),
+			modelsPath: null,
+			allowModelNetwork: false,
+		});
+		modelRuntime.registerProvider(faux.provider.id, {
+			name: faux.provider.name,
+			api: faux.api,
+			apiKey: "faux",
+			streamSimple: faux.provider.streamSimple,
+			models: [...faux.models],
+		});
+		const model = modelRuntime.getModel(faux.provider.id, "parent");
+		if (!model) throw new Error("faux parent model was not registered");
 		const respond = options.respond;
 		const responseFactory: FauxResponseStep = async (context, _streamOptions, state) => toAssistantMessage(await respond(context, state));
 		faux.setResponses(Array.from({ length: 8 }, () => responseFactory));
@@ -241,7 +265,7 @@ export async function runRealSubagentSession(options: RealSessionRunOptions): Pr
 			cwd,
 			agentDir: home,
 			model,
-			modelRegistry: createModelRegistry(model) as unknown as ModelRegistry,
+			modelRuntime,
 			resourceLoader: loader,
 			sessionManager: SessionManager.create(cwd, path.join(home, "sessions")),
 			settingsManager,

package/dist/extensions/pi-subagents/test/support/session-lease-child.mjs

@@ -0,0 +1,42 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import { acquireSessionLease } from "../../src/runs/shared/session-lease.ts";
+
+const [sessionFile, rootDir, releaseSignal, mode = "hold"] = process.argv.slice(2);
+if (!sessionFile || !rootDir) throw new Error("sessionFile and rootDir are required");
+
+let lease;
+try {
+	lease = acquireSessionLease({
+		sessionFile,
+		runId: `child-${process.pid}`,
+		sourceRunId: "source-child",
+		parentSessionId: "parent-child",
+	}, { rootDir });
+} catch (error) {
+	process.stdout.write(`${JSON.stringify({ acquired: false, error: error instanceof Error ? error.message : String(error) })}\n`);
+	process.exit(2);
+}
+if (mode === "abandon-with-writer") {
+	lease.updateWriter({ state: "spawning" });
+	const writer = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], {
+		detached: true,
+		stdio: "ignore",
+	});
+	if (typeof writer.pid !== "number") throw new Error("writer pid is unavailable");
+	lease.updateWriter({ state: "running", pid: writer.pid });
+	writer.unref();
+	process.stdout.write(`${JSON.stringify({ acquired: true, owner: lease.owner, writerPid: writer.pid })}\n`);
+	process.exit(0);
+}
+
+process.stdout.write(`${JSON.stringify({ acquired: true, owner: lease.owner })}\n`);
+if (mode === "abandon") process.exit(0);
+if (!releaseSignal) throw new Error("releaseSignal is required in hold mode");
+
+const timer = setInterval(() => {
+	if (!fs.existsSync(releaseSignal)) return;
+	clearInterval(timer);
+	lease.release();
+	process.exit(0);
+}, 20);