@selesai/code 0.9.11 → 0.9.12

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

@@ -5,8 +5,11 @@ import * as path from "node:path";
 import { beforeEach, describe, it } from "node:test";
 import { visibleWidth } from "@earendil-works/pi-tui";
 
+import { registerAgent } from "../../src/api/agents.ts";
+import { clearRuntimeAgentsForPi } from "../../src/agents/runtime-agent-registry.ts";
+import { scheduledRunStorePath } from "../../src/runs/background/scheduled-runs.ts";
 import { SUBAGENT_FANOUT_CHILD_ENV } from "../../src/runs/shared/pi-args.ts";
-import { ASYNC_DIR } from "../../src/shared/types.ts";
+import { ASYNC_DIR, DIRS } from "../../src/shared/types.ts";
 import type { WatchdogReviewFunction } from "../../src/watchdog/runtime.ts";
 
 const SLASH_RESULT_TYPE = "subagent-slash-result";
@@ -19,6 +22,15 @@ interface EventBus {
 	emit(event: string, data: unknown): void;
 }
 
+interface RuntimeSlashPi {
+	events: EventBus;
+	on(event: string, handler: (data: unknown) => void): () => void;
+	registerTool(tool: unknown): void;
+	registerCommand(name: string, spec: RegisteredSlashCommand): void;
+	registerShortcut(key: string, spec: { handler(ctx: unknown): Promise<void> }): void;
+	sendMessage(message: unknown): void;
+}
+
 type RegisteredSlashCommand = { handler(args: string, ctx: unknown): Promise<void>; getArgumentCompletions?: (prefix: string) => unknown };
 
 interface RegisterSlashCommandsModule {
@@ -116,17 +128,17 @@ function createState(cwd: string) {
 
 async function withIsolatedHome<T>(fn: () => Promise<T>): Promise<T> {
 	const home = fs.mkdtempSync(path.join(os.tmpdir(), "pi-slash-home-"));
-	const previousAgentDir = process.env.PI_CODING_AGENT_DIR;
+	const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
 	const previousHome = process.env.HOME;
 	const previousUserProfile = process.env.USERPROFILE;
-	process.env.PI_CODING_AGENT_DIR = path.join(home, ".selesai", "agent");
+	process.env.SELESAI_CODING_AGENT_DIR = path.join(home, ".selesai", "agent");
 	process.env.HOME = home;
 	process.env.USERPROFILE = home;
 	try {
 		return await fn();
 	} finally {
-		if (previousAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR;
-		else process.env.PI_CODING_AGENT_DIR = previousAgentDir;
+		if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
 		if (previousHome === undefined) delete process.env.HOME;
 		else process.env.HOME = previousHome;
 		if (previousUserProfile === undefined) delete process.env.USERPROFILE;
@@ -219,10 +231,9 @@ async function captureSlashCommandParams(
 	commandName: string,
 	args: string,
 	cwd: string,
-	setup?: () => void,
+	setup?: (pi: RuntimeSlashPi) => void,
 ): Promise<{ params: unknown; notifications: string[] }> {
 	return withIsolatedHome(async () => {
-		setup?.();
 		const commands = new Map<string, RegisteredSlashCommand>();
 		const events = createEventBus();
 		let requestedParams: unknown;
@@ -243,7 +254,8 @@ async function captureSlashCommandParams(
 
 		const pi = {
 			events,
-			on() {},
+			on() { return () => {}; },
+			registerTool() {},
 			registerCommand(name: string, spec: RegisteredSlashCommand) {
 				commands.set(name, spec);
 			},
@@ -251,14 +263,19 @@ async function captureSlashCommandParams(
 			sendMessage(_message: unknown) {},
 		};
 
-		registerSlashCommands!(pi, createState(cwd));
-		await commands.get(commandName)!.handler(args, createCommandContext({
-			cwd,
-			notify: (message) => {
-				notifications.push(message);
-			},
-		}));
-		return { params: requestedParams, notifications };
+		try {
+			setup?.(pi);
+			registerSlashCommands!(pi, createState(cwd));
+			await commands.get(commandName)!.handler(args, createCommandContext({
+				cwd,
+				notify: (message) => {
+					notifications.push(message);
+				},
+			}));
+			return { params: requestedParams, notifications };
+		} finally {
+			clearRuntimeAgentsForPi(pi as never);
+		}
 	});
 }
 
@@ -279,6 +296,35 @@ describe("subagents watchdog slash command", { skip: !available ? "watchdog comm
 		});
 	});
 
+	it("recommends and saves a strong complementary watchdog model", async () => {
+		await withIsolatedHome(async () => {
+			await withTempProject("pi-watchdog-model-", async (root) => {
+				const gpt = { provider: "openai-codex", id: "gpt-5.5", reasoning: true };
+				const opus = { provider: "anthropic", id: "claude-opus-4-8", reasoning: true };
+				const models = [gpt, opus];
+				const modelRegistry = {
+					getAvailable: () => models,
+					find: (provider: string, id: string) => models.find((entry) => entry.provider === provider && entry.id === id),
+					hasConfiguredAuth: (model: unknown) => Boolean(model),
+				};
+				const ctx = createCommandContext({ cwd: root, model: gpt, modelRegistry });
+				const { commands, sent } = createWatchdogHarness();
+
+				await commands.get("subagents-watchdog")!.handler("recommend-model", ctx);
+				await commands.get("subagents-watchdog")!.handler("model recommended", ctx);
+
+				const recommendation = String((sent[0] as { content?: unknown }).content ?? "");
+				assert.match(recommendation, /Recommended: anthropic\/claude-opus-4-8:high/);
+				const settingsPath = path.join(process.env.HOME!, ".selesai", "agent", "settings.json");
+				const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+				assert.equal(settings.subagents.watchdog.main.model, "anthropic/claude-opus-4-8");
+				assert.equal(settings.subagents.watchdog.main.thinking, "high");
+				assert.equal(settings.subagents.watchdog.enabled, undefined);
+				assert.match(String((sent[1] as { content?: unknown }).content ?? ""), /Run \/subagents-watchdog on if the watchdog is still off/);
+			});
+		});
+	});
+
 	it("supports session-scoped recommended watchdog models without writing settings", async () => {
 		await withIsolatedHome(async () => {
 			await withTempProject("pi-watchdog-session-model-", async (root) => {
@@ -469,8 +515,6 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 
 		registerSlashCommands!({
 			events: createEventBus(),
-			on() {},
-			on() {},
 			registerCommand() {},
 			registerShortcut(key: string, spec: { handler(ctx: unknown): Promise<void> }) {
 				shortcuts.set(key, spec);
@@ -488,8 +532,6 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 		const shortcuts = new Map<string, unknown>();
 		registerSlashCommands!({
 			events: createEventBus(),
-			on() {},
-			on() {},
 			registerCommand() {},
 			registerShortcut(key: string, spec: unknown) { shortcuts.set(key, spec); },
 			sendMessage() {},
@@ -499,11 +541,27 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 
 	it("/subagents-stop keeps the selector within its allocated width", async () => {
 		await withTempProject("pi-stop-selector-width-", async (root) => {
+			const id = "scheduled-width-check";
+			const nextRunAt = "2099-01-01T00:00:00.000Z";
+			const scheduleDir = path.join(scheduledRunStorePath(root), id);
+			fs.mkdirSync(scheduleDir, { recursive: true });
+			fs.writeFileSync(path.join(scheduleDir, "schedule.json"), JSON.stringify({
+				schemaVersion: 1,
+				id,
+				name: "A very long scheduled run name with wide characters 中文🙂",
+				cwd: root,
+				trigger: { kind: "once", at: nextRunAt, nextRunAt },
+				target: { agent: "scout", task: "Inspect" },
+				overlap: "skip",
+				catchUp: "latest",
+				paused: false,
+				createdAt: "2026-08-06T00:00:00.000Z",
+				updatedAt: "2026-08-06T00:00:00.000Z",
+			}), "utf-8");
 
 			const commands = new Map<string, RegisteredSlashCommand>();
 			const pi = {
 				events: createEventBus(),
-				on() {},
 				registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
 				registerShortcut() {},
 				sendMessage() {},
@@ -570,7 +628,6 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 
 		const pi = {
 			events,
-			on() {},
 			registerCommand(name: string, spec: { handler(args: string, ctx: unknown): Promise<void> }) {
 				commands.set(name, spec);
 			},
@@ -589,13 +646,60 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 		assert.equal(requestedCtx, ctx);
 		assert.equal(sent.length, 2);
 		assert.equal((sent[0] as { display?: boolean }).display, true);
-		assert.equal((sent[0] as { content?: string }).content, "Workflow running.");
+		assert.equal((sent[0] as { content?: string }).content, "Running subagent...");
 		assert.equal((sent[1] as { display?: boolean }).display, true);
 		assert.match((sent[1] as { content?: string }).content ?? "", /Commit finished/);
 		assert.equal(sessionManager.rewrites, 2);
 		assert.equal(sessionManager.flushed, true);
 	});
 
+	it("/run reports malformed agent configuration", async () => {
+		await withTempProject("pi-slash-invalid-agent-", async (root) => {
+			fs.writeFileSync(path.join(root, ".selesai", "agents", "broken.md"), "---\nname: broken\ndescription: Broken\nrunner:\n  type: unknown\n---\nBroken agent.\n");
+
+			const run = await captureSlashCommandParams("run", "broken", root);
+			assert.equal(run.params, undefined);
+			assert.match(run.notifications[0] ?? "", /Agent 'broken' has invalid configuration: Agent 'broken' has invalid runner\.type/);
+		});
+	});
+
+	it("/run blocks a malformed project agent from falling back to builtin", async () => {
+		await withTempProject("pi-slash-invalid-agent-shadow-", async (root) => {
+			fs.writeFileSync(path.join(root, ".selesai", "agents", "reviewer.md"), "---\nname: reviewer\ndescription: Broken reviewer\nrunner:\n  type: unknown\n---\nBroken agent.\n");
+
+			const run = await captureSlashCommandParams("run", "reviewer", root);
+			assert.equal(run.params, undefined);
+			assert.match(run.notifications[0] ?? "", /Agent 'reviewer' has invalid configuration: Agent 'reviewer' has invalid runner\.type/);
+		});
+	});
+
+	it("/run reports malformed packaged agent configuration by runtime name", async () => {
+		await withTempProject("pi-slash-invalid-packaged-agent-", async (root) => {
+			fs.writeFileSync(path.join(root, ".selesai", "agents", "code-analysis.zeta-worker.md"), "---\nname: zeta-worker\npackage: code-analysis\ndescription: Broken packaged worker\nrunner:\n  type: unknown\n---\nBroken agent.\n");
+
+			const run = await captureSlashCommandParams("run", "code-analysis.zeta-worker", root);
+			assert.equal(run.params, undefined);
+			assert.match(run.notifications[0] ?? "", /Agent 'code-analysis\.zeta-worker' has invalid configuration: Agent 'zeta-worker' has invalid runner\.type/);
+		});
+	});
+
+	it("/run accepts runtime-registered agents", async () => {
+		await withTempProject("pi-slash-runtime-agent-", async (root) => {
+			const run = await captureSlashCommandParams("run", "runtime-helper Inspect", root, (pi) => {
+				registerAgent({
+					pi: pi as never,
+					name: "runtime-helper",
+					definition: { description: "Runtime helper", systemPrompt: "Help at runtime." },
+				});
+			});
+
+			assert.deepEqual(run.params, {
+				workflowScript: "return runs.run(\"run\", {\"agent\":\"runtime-helper\",\"task\":\"Inspect\",\"agentScope\":\"both\"})",
+				async: false,
+			});
+		});
+	});
+
 	it("/run preserves existing relative reads and omits missing reads", async () => {
 		await withTempProject("pi-slash-reads-", async (root) => {
 			fs.writeFileSync(path.join(root, ".selesai", "agents", "scout.md"), `---
@@ -635,8 +739,6 @@ Inspect
 
 		const pi = {
 			events,
-			on() {},
-			on() {},
 			registerCommand(name: string, spec: { handler(args: string, ctx: unknown): Promise<void> }) {
 				commands.set(name, spec);
 			},
@@ -688,7 +790,6 @@ Inspect
 
 		const pi = {
 			events,
-			on() {},
 			registerCommand(name: string, spec: { handler(args: string, ctx: unknown): Promise<void> }) {
 				commands.set(name, spec);
 			},
@@ -728,7 +829,6 @@ Inspect
 
 		const pi = {
 			events,
-			on() {},
 			registerCommand(name: string, spec: { handler(args: string, ctx: unknown): Promise<void> }) {
 				commands.set(name, spec);
 			},
@@ -781,7 +881,6 @@ Inspect
 				const commands = new Map<string, RegisteredSlashCommand>();
 				registerSlashCommands!({
 					events: createEventBus(),
-					on() {},
 					registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
 					registerShortcut() {},
 					sendMessage() {},
@@ -792,18 +891,159 @@ Inspect
 		});
 	});
 
-	it("registers the Selesai-native chain/parallel orchestration commands", async () => {
+	it("/run reports malformed packaged local-name fallback configuration", async () => {
+		await withTempProject("pi-packaged-agent-local-slash-", async (root) => {
+			const highPackage = path.join(root, "high-package");
+			const lowPackage = path.join(root, "low-package");
+			for (const packageRoot of [highPackage, lowPackage]) {
+				fs.mkdirSync(path.join(packageRoot, "agents"), { recursive: true });
+				fs.writeFileSync(path.join(packageRoot, "package.json"), JSON.stringify({ "pi-subagents": { agents: ["agents"] } }));
+			}
+			fs.writeFileSync(path.join(highPackage, "agents", "foo.md"), `---
+name: foo
+package: acme
+description: Broken high package foo
+runner:
+  type: unknown
+---
+Broken foo.
+`, "utf-8");
+			fs.writeFileSync(path.join(lowPackage, "agents", "foo.md"), `---
+name: foo
+package: acme
+description: Valid low package foo
+---
+Valid foo.
+`, "utf-8");
+			fs.writeFileSync(path.join(root, ".selesai", "settings.json"), JSON.stringify({ packages: [highPackage, lowPackage] }));
+
+			const run = await captureSlashCommandParams("run", "foo Investigate", root);
+			assert.equal(run.params, undefined);
+			assert.match(run.notifications[0] ?? "", /Agent 'foo' has invalid configuration: Agent 'foo' has invalid runner\.type/);
+		});
+	});
+
+	it("does not register legacy orchestration commands", async () => {
 		const commands = new Map<string, unknown>();
 		registerSlashCommands!({
-			on() {},
 			registerCommand(name: string, command: unknown) { commands.set(name, command); },
 			registerShortcut() {},
 			events: createEventBus(),
 		} as never, { baseCwd: process.cwd() } as never);
 		assert.equal(commands.has("run"), true);
-		assert.equal(commands.has("chain"), true);
-		assert.equal(commands.has("parallel"), true);
-		assert.equal(commands.has("run-chain"), true);
-		assert.equal(commands.has("chain-prompts"), true);
+		assert.equal(commands.has("chain"), false);
+		assert.equal(commands.has("parallel"), false);
+		assert.equal(commands.has("run-chain"), false);
+	});
+});
+
+describe("subagents-inspect-rpc command", { skip: !available ? "slash-commands.ts not importable" : undefined }, () => {
+	function writeInspectableRun(runId: string, sessionId: string) {
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		fs.mkdirSync(asyncDir, { recursive: true });
+		fs.mkdirSync(DIRS.results, { recursive: true });
+		const sessionRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-inspect-itest-session-"));
+		const sessionFile = path.join(sessionRoot, "session.jsonl");
+		fs.writeFileSync(sessionFile, [
+			JSON.stringify({ message: { role: "user", content: "inspect me" } }),
+			JSON.stringify({ message: { role: "assistant", content: [{ type: "text", text: "inspected" }] } }),
+		].join("\n") + "\n", "utf-8");
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+			runId,
+			sessionId,
+			mode: "single",
+			state: "complete",
+			startedAt: 100,
+			endedAt: 200,
+			lastUpdate: 200,
+			sessionFile,
+			sessionRoot,
+			steps: [{ agent: "worker", status: "complete", startedAt: 100, endedAt: 150, sessionFile }],
+		}, null, 2), "utf-8");
+		return { asyncDir, sessionRoot };
+	}
+
+	function makeInspectCtx(mode: string) {
+		const widgetCalls: Array<{ key: string; value: unknown }> = [];
+		const notifications: string[] = [];
+		const ctx = {
+			mode,
+			hasUI: true,
+			cwd: process.cwd(),
+			ui: {
+				setWidget: (key: string, value: unknown) => { widgetCalls.push({ key, value }); },
+				notify: (message: string) => { notifications.push(message); },
+				setStatus: () => {},
+				setToolsExpanded: () => {},
+			},
+			sessionManager: { getSessionFile: () => null, getSessionId: () => "session-itest" },
+		};
+		return { ctx, widgetCalls, notifications };
+	}
+
+	function registerWithState(sessionId: string | null, trustedSessionRoots: string[] = []) {
+		const commands = new Map<string, RegisteredSlashCommand>();
+		const pi = {
+			events: createEventBus(),
+			registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
+			registerShortcut() {},
+			sendMessage() {},
+		};
+		const state = { ...createState(process.cwd()), currentSessionId: sessionId, trustedSessionRoots };
+		registerSlashCommands!(pi as never, state as never);
+		return commands;
+	}
+
+	it("emits a correlated payload widget then retracts it on RPC surfaces", async () => {
+		writeInspectableRun("run-itest", "session-itest");
+		const commands = registerWithState("session-itest");
+		const { ctx, widgetCalls, notifications } = makeInspectCtx("rpc");
+		await commands.get("subagents-inspect-rpc")!.handler("req-itest run-itest", ctx);
+
+		assert.deepEqual(widgetCalls.map((call) => call.key), ["subagent-inspect", "subagent-inspect"]);
+		const [set, clear] = widgetCalls;
+		assert.equal(clear!.value, undefined);
+		const lines = set!.value as string[];
+		assert.equal(lines.length, 1);
+		assert.ok(lines[0]!.startsWith("SELESAI_SUBAGENT_INSPECT_JSON:"));
+		const reply = JSON.parse(lines[0]!.slice("SELESAI_SUBAGENT_INSPECT_JSON:".length));
+		assert.equal(reply.kind, "pi-subagents.inspect-reply");
+		assert.equal(reply.version, 1);
+		assert.equal(reply.requestId, "req-itest");
+		assert.equal(reply.status, "complete");
+		assert.equal(reply.task, "inspect me");
+		assert.equal(reply.error, undefined);
+		assert.equal(JSON.stringify(reply).includes("session.jsonl"), false);
+		assert.equal(notifications.length, 0);
+	});
+
+	it("answers foreign_session for runs owned by another session", async () => {
+		writeInspectableRun("run-itest-foreign", "session-other");
+		const commands = registerWithState("session-itest");
+		const { ctx, widgetCalls } = makeInspectCtx("rpc");
+		await commands.get("subagents-inspect-rpc")!.handler("req-foreign run-itest-foreign", ctx);
+		const lines = widgetCalls[0]!.value as string[];
+		const reply = JSON.parse(lines[0]!.slice("SELESAI_SUBAGENT_INSPECT_JSON:".length));
+		assert.equal(reply.error?.code, "foreign_session");
+		assert.equal(reply.messages, undefined);
+	});
+
+	it("answers invalid_request with the echoed requestId for malformed args", async () => {
+		const commands = registerWithState("session-itest");
+		const { ctx, widgetCalls } = makeInspectCtx("rpc");
+		await commands.get("subagents-inspect-rpc")!.handler("req-bad", ctx);
+		const lines = widgetCalls[0]!.value as string[];
+		const reply = JSON.parse(lines[0]!.slice("SELESAI_SUBAGENT_INSPECT_JSON:".length));
+		assert.equal(reply.error?.code, "invalid_request");
+		assert.equal(reply.requestId, "req-bad");
+	});
+
+	it("degrades to a notification in TUI mode without emitting widgets", async () => {
+		writeInspectableRun("run-itest-tui", "session-itest");
+		const commands = registerWithState("session-itest");
+		const { ctx, widgetCalls, notifications } = makeInspectCtx("tui");
+		await commands.get("subagents-inspect-rpc")!.handler("req-tui run-itest-tui", ctx);
+		assert.equal(widgetCalls.length, 0);
+		assert.match(notifications[0] ?? "", /RPC surfaces/);
 	});
 });

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

@@ -70,7 +70,7 @@ describe("slash live state", { skip: !available ? "slash-live-state.ts not impor
 			async: true,
 		});
 
-		assert.equal(details.result.details.mode, "workflow");
+		assert.equal(details.result.details.mode, "single");
 		assert.equal(details.result.details.background, true);
 		assert.equal(details.result.details.asyncId, undefined);
 	});

package/dist/extensions/pi-subagents/test/integration/template-resolution.test.ts

@@ -151,12 +151,13 @@ describe("resolveStepBehavior", { skip: !available ? "pi packages not available"
 		assert.equal(behavior.output, "custom.md");
 	});
 
-	it("defaults outputMode to inline unless a step overrides it", () => {
+	it("uses agent outputMode defaults unless a step overrides them", () => {
 		const inlineBehavior = resolveStepBehavior({ name: "test", output: "report.md" }, {});
 		assert.equal(inlineBehavior.outputMode, "inline");
+		assert.equal(resolveStepBehavior({ name: "test", output: "report.md", outputMode: "file-only" }, {}).outputMode, "file-only");
 
-		const stepOverrideBehavior = resolveStepBehavior({ name: "test", output: "report.md" }, { outputMode: "file-only" });
-		assert.equal(stepOverrideBehavior.outputMode, "file-only");
+		const stepOverrideBehavior = resolveStepBehavior({ name: "test", output: "report.md", outputMode: "file-only" }, { outputMode: "inline" });
+		assert.equal(stepOverrideBehavior.outputMode, "inline");
 	});
 
 	it("false disables output", () => {
@@ -189,6 +190,22 @@ describe("resolveStepBehavior", { skip: !available ? "pi packages not available"
 });
 
 describe("resolveParallelBehaviors", { skip: !available ? "pi packages not available" : undefined }, () => {
+	it("uses agent outputMode defaults unless a parallel task overrides them", () => {
+		const [defaultBehavior] = resolveParallelBehaviors(
+			[{ agent: "reviewer", task: "Review" }],
+			[{ name: "reviewer", output: "report.md", outputMode: "file-only" }],
+			0,
+		);
+		assert.equal(defaultBehavior?.outputMode, "file-only");
+
+		const [overrideBehavior] = resolveParallelBehaviors(
+			[{ agent: "reviewer", task: "Review", outputMode: "inline" }],
+			[{ name: "reviewer", output: "report.md", outputMode: "file-only" }],
+			0,
+		);
+		assert.equal(overrideBehavior?.outputMode, "inline");
+	});
+
 	it("string false agent default disables output in chain parallel tasks", () => {
 		const behaviors = resolveParallelBehaviors(
 			[{ agent: "reviewer", task: "Review" }],

package/dist/extensions/pi-subagents/test/support/isolated-temp-root.mjs

@@ -0,0 +1,9 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+if (!process.env.SELESAI_SUBAGENTS_TEMP_ROOT) {
+	const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-test-root-"));
+	process.env.SELESAI_SUBAGENTS_TEMP_ROOT = tempRoot;
+	process.on("exit", () => fs.rmSync(tempRoot, { recursive: true, force: true }));
+}

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

@@ -103,13 +103,20 @@ function claimNextResponse(dir, args) {
 	return responseMatchesArgs(fallback, args) ? fallback : undefined;
 }
 
-function defaultAssistantMessage(output) {
+function requestedModelArg(args) {
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === "--model" && typeof args[i + 1] === "string") return args[i + 1];
+	}
+	return "mock/test-model";
+}
+
+function defaultAssistantMessage(output, args) {
 	return {
 		type: "message_end",
 		message: {
 			role: "assistant",
 			content: [{ type: "text", text: output }],
-			model: "mock/test-model",
+			model: requestedModelArg(args),
 			stopReason: "stop",
 			usage: {
 				input: 100,
@@ -183,6 +190,14 @@ function writeStructuredOutputCapture(response) {
 	if (!outputPath) return;
 	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
 	fs.writeFileSync(outputPath, JSON.stringify(response.structuredOutputCapture), "utf-8");
+	if (Object.prototype.hasOwnProperty.call(response, "structuredOutputAcceptanceReport")) {
+		const acceptancePath = process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE;
+		if (acceptancePath) fs.writeFileSync(acceptancePath, JSON.stringify(response.structuredOutputAcceptanceReport), "utf-8");
+	}
+	if (Object.prototype.hasOwnProperty.call(response, "structuredOutputAcceptanceReportRaw")) {
+		const acceptancePath = process.env.SELESAI_SUBAGENT_STRUCTURED_OUTPUT_ACCEPTANCE_CAPTURE;
+		if (acceptancePath) fs.writeFileSync(acceptancePath, response.structuredOutputAcceptanceReportRaw, "utf-8");
+	}
 }
 
 function writeRuntimeAcknowledgedExtensions(response) {
@@ -209,6 +224,16 @@ function writeToolDiagnostic(response) {
 	}), "utf-8");
 }
 
+function readRequiredToolsEnv() {
+	try {
+		const encoded = process.env.SELESAI_SUBAGENT_REQUIRED_TOOLS;
+		const parsed = encoded === undefined ? [] : JSON.parse(encoded);
+		return Array.isArray(parsed) ? parsed : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 function isJsonMode(args) {
 	for (let i = 0; i < args.length; i++) {
 		if (args[i] === "--mode") {
@@ -337,7 +362,7 @@ async function main() {
 	writeToolDiagnostic(response);
 	const callPath = path.join(queueDir, `call-${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.json`);
 	const callTempPath = `${callPath}.tmp-${process.pid}-${Date.now()}`;
-	fs.writeFileSync(callTempPath, JSON.stringify({ args, cwd: process.cwd(), systemPrompts: readSystemPromptRecords(args) }), "utf-8");
+	fs.writeFileSync(callTempPath, JSON.stringify({ args, cwd: process.cwd(), systemPrompts: readSystemPromptRecords(args), requiredChildTools: readRequiredToolsEnv() }), "utf-8");
 	fs.renameSync(callTempPath, callPath);
 
 	if (typeof response.delay === "number" && response.delay > 0) {
@@ -378,11 +403,11 @@ async function main() {
 		} 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);
-				if (jsonMode) await writeJsonlLine(defaultAssistantMessage(output));
+				if (jsonMode) await writeJsonlLine(defaultAssistantMessage(output, args));
 				else await writeStdout(`${output}\n`);
 			} else if (typeof response.output === "string") {
 				const output = withAcceptanceReport(response.output, args);
-				if (jsonMode) await writeJsonlLine(defaultAssistantMessage(output));
+				if (jsonMode) await writeJsonlLine(defaultAssistantMessage(output, args));
 				else await writeStdout(`${output}\n`);
 			}
 		await maybeWriteStructuredOutput(response, jsonMode);

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

@@ -30,6 +30,8 @@ interface MockPiResponse {
 	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;
 }
 

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

@@ -171,6 +171,7 @@ export async function runRealSubagentSession(options: RealSessionRunOptions): Pr
 	const envSnapshot = new Map([
 		["HOME", process.env.HOME],
 		["USERPROFILE", process.env.USERPROFILE],
+		["SELESAI_SUBAGENTS_TEMP_ROOT", process.env.SELESAI_SUBAGENTS_TEMP_ROOT],
 		["SELESAI_CODING_AGENT_DIR", process.env.SELESAI_CODING_AGENT_DIR],
 		["SELESAI_SUBAGENT_EXTRA_AGENT_DIRS", process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS],
 		["SELESAI_SUBAGENT_CHILD", process.env.SELESAI_SUBAGENT_CHILD],
@@ -179,7 +180,7 @@ 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_SELESAI_PACKAGE_ROOT", process.env.SELESAI_SUBAGENTS_SELESAI_PACKAGE_ROOT],
+		["SELESAI_SUBAGENTS_CODING_AGENT_PACKAGE_ROOT", process.env.SELESAI_SUBAGENTS_CODING_AGENT_PACKAGE_ROOT],
 	]);
 	const uninstallChildPi = installChildPiShim(options.childText, options.reportChildTools);
 	let session: AgentSession | undefined;
@@ -207,6 +208,7 @@ export async function runRealSubagentSession(options: RealSessionRunOptions): Pr
 		process.chdir(cwd);
 		process.env.HOME = home;
 		process.env.USERPROFILE = home;
+		process.env.SELESAI_SUBAGENTS_TEMP_ROOT ??= path.join(home, "pi-subagents-temp");
 		process.env.SELESAI_CODING_AGENT_DIR = home;
 		delete process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
 		delete process.env.SELESAI_SUBAGENT_CHILD;
@@ -214,7 +216,7 @@ 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_SUBAGENTS_SELESAI_PACKAGE_ROOT;
+		delete process.env.SELESAI_SUBAGENTS_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}`);

package/dist/extensions/pi-subagents/test/support/register-loader.mjs

@@ -11,5 +11,6 @@
  */
 
 import { register } from "node:module";
+import "./isolated-temp-root.mjs";
 
 register(new URL("./ts-loader.mjs", import.meta.url));