@selesai/code 0.13.39 → 0.14.0

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

@@ -23,6 +23,8 @@ export interface FakeChildResponse {
 	waitForPath?: string;
 	keepAliveAfterFinalMessageMs?: number;
 	jsonl?: unknown[];
+	/** Leaves terminal lifecycle events to the scripted JSONL, for ordering-sensitive tests. */
+	omitImplicitFinalEvents?: boolean;
 	/** 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 }>;
@@ -42,6 +44,16 @@ export interface FakeChildResponse {
 	createError?: string;
 	/** Keeps the run open until the parent aborts it. */
 	hangUntilAbort?: boolean;
+	/** Rejects the first N `steer()` calls (a child that cannot take steering yet), then accepts them. */
+	failSteers?: number;
+	/** After draining a post-final steer/follow-up into pending (hasQueuedMessages false), delay before `turn_start`. */
+	queuedMessageTurnStartDelayMs?: number;
+	/** Assistant text emitted for that delayed queued-message turn. */
+	queuedMessageOutput?: string;
+	/** Accept input before any assistant/terminal event; consume it only after this path exists. */
+	queuedInputReleasePath?: string;
+	/** Keep post-final queued input pending until abort; do not emit user `message_end` or continue. */
+	holdQueuedMessagesUntilAbort?: boolean;
 }
 
 export interface FakeChildSessionRecord {
@@ -51,6 +63,7 @@ export interface FakeChildSessionRecord {
 	aborted: boolean;
 	disposed: boolean;
 	settled: boolean;
+	scriptedFinalEmitted: boolean;
 	session?: ChildSession;
 }
 
@@ -205,10 +218,13 @@ export function createFakeChildSessions(queueDir: () => string): FakeChildSessio
 	let disposeCalls = 0;
 	const factory: ChildSessionFactory = {
 		async create(launch) {
-			const record: FakeChildSessionRecord = { launch, task: undefined, steers: [], aborted: false, disposed: false, settled: false };
+			const record: FakeChildSessionRecord = { launch, task: undefined, steers: [], aborted: false, disposed: false, settled: false, scriptedFinalEmitted: false };
 			sessions.push(record);
 			const listeners = new Set<(event: ChildSessionEvent) => void>();
 			const messages: AgentMessage[] = [];
+			const queued: Array<{ text: string; mode: "steer" | "followUp" }> = [];
+			const queuedWaiters: Array<() => void> = [];
+			let boundaryOpen = false;
 			const model = reportedModel(launch.model);
 			let abortResolve: (() => void) | undefined;
 			const abortedPromise = new Promise<void>((resolve) => { abortResolve = resolve; });
@@ -230,6 +246,60 @@ export function createFakeChildSessions(queueDir: () => string): FakeChildSessio
 					// Observability for tests only.
 				}
 			};
+			const wakeQueuedWaiters = (): void => {
+				for (const resolve of queuedWaiters.splice(0)) resolve();
+			};
+			const recordQueuedState = (): void => {
+				try {
+					fs.writeFileSync(path.join(queueDir(), "queued-messages.json"), `${JSON.stringify({
+						count: queued.length,
+						modes: queued.map((item) => item.mode),
+					})}\n`, "utf-8");
+				} catch {
+					// Observability for tests only.
+				}
+			};
+			const enqueue = (text: string, mode: "steer" | "followUp"): void => {
+				record.steers.push({ text, mode });
+				recordSteer(text, mode);
+				if (!boundaryOpen) return;
+				queued.push({ text, mode });
+				recordQueuedState();
+				wakeQueuedWaiters();
+			};
+			const waitForQueuedMessage = (): Promise<void> => {
+				if (queued.length > 0 || record.aborted) return Promise.resolve();
+				return new Promise((resolve) => { queuedWaiters.push(resolve); });
+			};
+			const markScriptedFinal = (): void => {
+				record.scriptedFinalEmitted = true;
+				try {
+					fs.appendFileSync(path.join(queueDir(), "scripted-final.jsonl"), `${JSON.stringify({ sessionId })}\n`, "utf-8");
+				} catch {
+					// Observability for tests only.
+				}
+			};
+			const drainQueuedBoundary = async (response: FakeChildResponse, task: string): Promise<void> => {
+				while (queued.length > 0 && !record.aborted) {
+					const drained = queued.splice(0);
+					recordQueuedState();
+					for (const item of drained) {
+						emit({
+							type: "message_end",
+							message: { role: "user", content: [{ type: "text", text: item.text }] },
+						});
+					}
+					const delay = response.queuedMessageTurnStartDelayMs ?? 0;
+					if (delay > 0) await sleep(delay, abortedPromise);
+					if (record.aborted) return;
+					emit({ type: "turn_start" });
+					const output = response.queuedMessageOutput ?? drained[0]?.text ?? "continued after queued input";
+					await emitEntries([defaultAssistantMessage(output, model)], task);
+					if (record.aborted) return;
+					emit({ type: "agent_end", messages: [...messages], willRetry: false });
+					emit({ type: "agent_settled" });
+				}
+			};
 			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);
@@ -262,7 +332,9 @@ export function createFakeChildSessions(queueDir: () => string): FakeChildSessio
 					await sleep(20, abortedPromise);
 				}
 			};
+			let failingSteers = 0;
 			const runScript = async (response: FakeChildResponse, task: string): Promise<void> => {
+				failingSteers = typeof response.failSteers === "number" ? response.failSteers : 0;
 				if (typeof response.delay === "number" && response.delay > 0) await sleep(response.delay, abortedPromise);
 				await waitForReleasePath(response.waitForPath);
 				if (record.aborted) return;
@@ -296,6 +368,18 @@ export function createFakeChildSessions(queueDir: () => string): FakeChildSessio
 					}
 				}
 				emit({ type: "agent_start" });
+				if (response.queuedInputReleasePath) {
+					boundaryOpen = true;
+					const keepAlive = setInterval(() => {}, 1_000);
+					try {
+						await waitForQueuedMessage();
+						await waitForReleasePath(response.queuedInputReleasePath);
+						await drainQueuedBoundary(response, task);
+					} finally {
+						clearInterval(keepAlive);
+					}
+					return;
+				}
 				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);
@@ -320,11 +404,40 @@ export function createFakeChildSessions(queueDir: () => string): FakeChildSessio
 					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.omitImplicitFinalEvents) {
+					emit({ type: "agent_end", messages: [...messages], willRetry: false });
+					emit({ type: "agent_settled" });
+				}
+				boundaryOpen = true;
+				markScriptedFinal();
+				if (response.holdQueuedMessagesUntilAbort) {
+					const keepAlive = setInterval(() => {}, 1_000);
+					try {
+						if (queued.length === 0 && !record.aborted) await waitForQueuedMessage();
+						if (!record.aborted) await abortedPromise;
+					} finally {
+						clearInterval(keepAlive);
+					}
+					return;
+				}
+				const keepAliveMs = typeof response.keepAliveAfterFinalMessageMs === "number" && response.keepAliveAfterFinalMessageMs > 0
+					? response.keepAliveAfterFinalMessageMs
+					: 0;
+				if (!record.aborted && queued.length === 0 && (keepAliveMs > 0 || response.hangUntilAbort)) {
+					await Promise.race([
+						...(keepAliveMs > 0 ? [sleep(keepAliveMs, abortedPromise)] : []),
+						...(response.hangUntilAbort ? [abortedPromise] : []),
+						waitForQueuedMessage(),
+					]);
+				}
+				const coalesceDeadline = Date.now() + 200;
+				let lastQueued = -1;
+				while (!record.aborted && queued.length > 0 && queued.length !== lastQueued && Date.now() < coalesceDeadline) {
+					lastQueued = queued.length;
+					await sleep(20, abortedPromise);
 				}
+				await drainQueuedBoundary(response, task);
+				if (record.aborted) return;
 				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}`);
@@ -358,6 +471,7 @@ export function createFakeChildSessions(queueDir: () => string): FakeChildSessio
 							storage: launch.storage,
 							model: launch.model,
 							tools: launch.tools,
+							builtinMcpTools: launch.builtinMcpTools,
 							excludeTools: launch.excludeTools,
 							extensionPaths: launch.extensionPaths,
 							ambientExtensions: launch.ambientExtensions,
@@ -365,6 +479,7 @@ export function createFakeChildSessions(queueDir: () => string): FakeChildSessio
 							noSkills: launch.noSkills,
 							noContextFiles: launch.noContextFiles,
 							processEnv: launch.processEnv,
+							projectTrusted: launch.projectTrusted,
 						},
 						runtime: { ...launch.runtime, structuredOutput: launch.runtime.structuredOutput ? { schema: launch.runtime.structuredOutput.schema, acceptanceReport: launch.runtime.structuredOutput.acceptanceReport } : undefined },
 					}), "utf-8");
@@ -376,16 +491,22 @@ export function createFakeChildSessions(queueDir: () => string): FakeChildSessio
 					}
 				},
 				async steer(text) {
-					record.steers.push({ text, mode: "steer" });
-					recordSteer(text, "steer");
+					if (failingSteers > 0) {
+						failingSteers--;
+						throw new Error("mock child cannot accept steering");
+					}
+					enqueue(text, "steer");
 				},
 				async followUp(text) {
-					record.steers.push({ text, mode: "followUp" });
-					recordSteer(text, "followUp");
+					enqueue(text, "followUp");
+				},
+				hasQueuedMessages() {
+					return queued.length > 0;
 				},
 				async abort() {
 					record.aborted = true;
 					abortResolve?.();
+					wakeQueuedWaiters();
 				},
 				async dispose() {
 					record.disposed = true;

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

@@ -3,11 +3,19 @@ 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";
+import { steerRequestsDir } from "../../src/runs/background/control-channel.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 }));
+const input = JSON.parse(paramsJson);
+const requests = Array.isArray(input) ? input : [{ params: input, policy }];
+const results = [];
+for (const request of requests) {
+	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: request.policy ?? 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", ...request.params }, new AbortController().signal, undefined, ctx);
+	const requestDir = typeof request.params.dir === "string" ? steerRequestsDir(request.params.dir) : undefined;
+	results.push({ pid: process.pid, sessionId: state.currentSessionId, completionOwnerId: currentCompletionOwnerId(), controllers: state.workflowControllers?.size ?? 0, controls: state.foregroundControls.size, requestCount: requestDir && fs.existsSync(requestDir) ? fs.readdirSync(requestDir).length : 0, result });
+}
+fs.writeFileSync(output, JSON.stringify(Array.isArray(input) ? results : results[0]));

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

@@ -52,7 +52,6 @@ interface AgentConfig {
 	defaultContext?: "fresh" | "fork";
 	systemPrompt?: string;
 	model?: string;
-	fallbackModels?: string[];
 	tools?: string[];
 	extensions?: string[];
 	subagentOnlyExtensions?: string[];
@@ -70,7 +69,6 @@ interface AgentConfig {
 	toolBudget?: { soft?: number; hard: number; block?: string[] | "*" };
 	mcpDirectTools?: string[];
 	maxSubagentDepth?: number;
-	completionGuard?: boolean;
 }
 
 export function makeAgentConfigs(names: string[]): AgentConfig[] {
@@ -186,18 +184,17 @@ export const events = {
 		return events.assistantMessage(["done", "```acceptance-report", JSON.stringify(report), "```"].join("\n"));
 	},
 
-	/** A child watchdog warning custom message as the child watchdog writes it into the child JSONL. */
-	watchdogWarning(severity: "concern" | "blocker", summary: string, overrides: Record<string, unknown> = {}): object {
+	watchdogStatusWarning(severity: "concern" | "blocker", summary: string, overrides: Record<string, unknown> = {}): object {
+		const { seq = 1, runId, agent, childIndex, ...warning } = overrides;
 		return {
-			type: "message_end",
-			message: {
-				role: "custom",
-				customType: "subagent_watchdog_warning",
-				content: `<subagent_watchdog severity="${severity}">${summary}</subagent_watchdog>`,
-				display: true,
-				details: { severity, category: "test-gap", source: "child", agent: "worker", summary, evidence: "The transcript claims tests passed but no test command ran.", recommendedAction: "Run the focused test before finishing.", state: "displayed", displayedAt: new Date().toISOString(), ...overrides },
-				timestamp: Date.now(),
-			},
+			type: "subagent.watchdog.status",
+			seq,
+			phase: "idle",
+			ts: Date.now(),
+			...(runId ? { runId } : {}),
+			...(agent ? { agent } : {}),
+			...(childIndex !== undefined ? { childIndex, stepIndex: childIndex } : {}),
+			warning: { severity, importance: "high", category: "test-gap", summary, evidence: "The transcript claims tests passed but no test command ran.", recommendedAction: "Run the focused test before finishing.", addressed: false, stalemate: false, ...warning },
 		};
 	},
 
@@ -247,4 +244,4 @@ export const events = {
 			},
 		};
 	},
-};
+};

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

@@ -6,15 +6,33 @@ const configuredTempRoot = process.env.SELESAI_SUBAGENTS_TEMP_ROOT?.trim();
 const tempRoot = configuredTempRoot
 	? path.resolve(configuredTempRoot)
 	: fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-test-root-"));
+fs.mkdirSync(tempRoot, { recursive: true });
+if (process.platform === "darwin") fs.closeSync(fs.openSync(path.join(tempRoot, ".metadata_never_index"), "a"));
 process.env.SELESAI_SUBAGENTS_TEMP_ROOT = tempRoot;
+process.env.TMPDIR = tempRoot;
+process.env.TMP = tempRoot;
+process.env.TEMP = tempRoot;
 
-const nestedTestProcess = process.env.SELESAI_SUBAGENTS_TEST_LOADER === "1";
+const loaderState = process.env.SELESAI_SUBAGENTS_TEST_LOADER;
+const nestedTestProcess = loaderState !== undefined;
+const testFileProcess = process.env.NODE_TEST_CONTEXT !== undefined && loaderState !== "test-file";
+if (!nestedTestProcess || testFileProcess) process.env.SELESAI_SUBAGENTS_TEST_PARENT_PID = String(process.pid);
 const isolatedHome = path.join(tempRoot, "home");
 process.env.HOME = isolatedHome;
 process.env.USERPROFILE = isolatedHome;
 if (!nestedTestProcess) delete process.env.SELESAI_CODING_AGENT_DIR;
-process.env.SELESAI_SUBAGENTS_TEST_LOADER = "1";
+process.env.SELESAI_SUBAGENTS_TEST_LOADER = testFileProcess ? "test-file" : "loaded";
 
 if (!configuredTempRoot) {
-	process.on("exit", () => fs.rmSync(tempRoot, { recursive: true, force: true }));
+	// Housekeeping for a root no other process shares: a Windows handle or a leftover
+	// descendant must not turn a test file whose tests all passed into a failed file.
+	process.on("exit", () => {
+		try {
+			fs.rmSync(tempRoot, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+		} catch (error) {
+			try {
+				fs.writeSync(2, `warning: test temp root not removed: ${tempRoot} (${error?.code ?? error})\n`);
+			} catch {}
+		}
+	});
 }

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

@@ -0,0 +1,15 @@
+// Opt-in native SDK tests use one installed Pi package and its own peer modules.
+import { registerHooks } from "node:module";
+import { pathToFileURL } from "node:url";
+import { resolveHostPeerAliases } from "../../src/runs/background/runner-aliases.ts";
+
+const root = process.env.SELESAI_SUBAGENTS_NATIVE_PI_ROOT;
+if (!root) throw new Error("SELESAI_SUBAGENTS_NATIVE_PI_ROOT is required for the native SDK tests.");
+const { aliases, missing } = resolveHostPeerAliases(root);
+if (missing.length) throw new Error(`Native host lacks: ${missing.join(", ")}`);
+process.env.SELESAI_SUBAGENTS_CODING_AGENT_PACKAGE_ROOT = root;
+registerHooks({ resolve(specifier, context, nextResolve) {
+	return aliases[specifier]
+		? { url: pathToFileURL(aliases[specifier]).href, shortCircuit: true }
+		: nextResolve(specifier, context);
+} });

package/dist/extensions/pi-subagents/test/support/node-command.ts

@@ -1,15 +1,38 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 
+/** Writes `<name>.cmd` exactly as npm's cmd-shim does for a `#!/usr/bin/env node` bin at `target` (relative, backslashes). */
+export function writeNpmNodeShim(directory: string, name: string, target: string): string {
+	const commandPath = path.join(directory, `${name}.cmd`);
+	fs.writeFileSync(commandPath, [
+		"@ECHO off",
+		"GOTO start",
+		":find_dp0",
+		"SET dp0=%~dp0",
+		"EXIT /b",
+		":start",
+		"SETLOCAL",
+		"CALL :find_dp0",
+		"",
+		'IF EXIST "%dp0%\\node.exe" (',
+		'  SET "_prog=%dp0%\\node.exe"',
+		") ELSE (",
+		'  SET "_prog=node"',
+		"  SET PATHEXT=%PATHEXT:;.JS;=;%",
+		")",
+		"",
+		`endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\\${target}" %*`,
+		"",
+	].join("\r\n"), { encoding: "utf-8", mode: 0o755 });
+	return commandPath;
+}
+
 export function writeNodeCommand(directory: string, name: string, source: string): string {
 	if (process.platform === "win32") {
-		const scriptPath = path.join(directory, `${name}.cjs`);
-		const commandPath = path.join(directory, `${name}.cmd`);
-		fs.writeFileSync(scriptPath, source, "utf-8");
-		fs.writeFileSync(commandPath, `@echo off\r\n"${process.execPath}" "${scriptPath}" %*\r\n`, "utf-8");
-		return commandPath;
+		fs.writeFileSync(path.join(directory, `${name}.cjs`), source, "utf-8");
+		return writeNpmNodeShim(directory, name, `${name}.cjs`);
 	}
 	const commandPath = path.join(directory, name);
 	fs.writeFileSync(commandPath, `#!/usr/bin/env node\n${source}\n`, { encoding: "utf-8", mode: 0o755 });
 	return commandPath;
-}
+}

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

@@ -6,10 +6,10 @@ let timerId = 0;
 let now = 0;
 let failSend = false;
 const state = { currentSessionId: "session-a", completionOwnerId: "owner-a" };
-const sent: unknown[] = [];
+const sent: Array<{ message: Record<string, unknown>; options: unknown }> = [];
 const pi = {
 	events: { on: () => () => {} },
-	sendMessage(message: unknown, options: unknown) {
+	sendMessage(message: Record<string, unknown>, options: unknown) {
 		if (failSend) throw new Error("PRIVATE_ERROR_CREDENTIAL");
 		sent.push({ message, options });
 	},
@@ -67,7 +67,9 @@ 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(notifier.hasPendingDelivery(), true); // Accepted wakes survive notifier disposal for reload.
+for (const { message } of sent) notifier.messageStarted({ role: "custom", ...message });
+assert.equal(notifier.hasPendingDelivery(), false); // Pi has now started every accepted wake.
 assert.equal(callbacks.size, 0);
 assert.equal(await notifier.deliver(result("after-dispose")), false);
 // Malformed/large identity cannot create multiline or unbounded trace records.

package/dist/extensions/pi-subagents/test/support/single-execution-fixture.ts

@@ -27,13 +27,6 @@ import {
 import type { ChildWatchdogProgress, SubagentState } from "../../src/shared/types.ts";
 import { CHILD_WATCHDOG_STATUS_EVENT } from "../../src/watchdog/child-status.ts";
 import type { ChildRuntimeConfig } from "../../src/runs/shared/child-runtime-config.ts";
-import { clearExclusions } from "../../src/runs/shared/model-exclusions.ts";
-
-interface ModelAttempt {
-	success?: boolean;
-	exitCode?: number;
-	error?: string;
-}
 
 interface ProgressSummary {
 	agent: string;
@@ -65,6 +58,7 @@ interface LaunchResolvedExtensions {
 	disableAmbientExtensions?: boolean;
 	runtime?: string[];
 	configured?: string[];
+	required?: string[];
 	effective?: string[];
 }
 
@@ -84,8 +78,6 @@ interface RunSyncResult {
 	model?: string;
 	skills?: string[];
 	skillsWarning?: string;
-	attemptedModels?: string[];
-	modelAttempts?: ModelAttempt[];
 	contextOverflow?: boolean;
 	usage: { turns: number; input: number; output: number };
 	progress: ProgressSummary;
@@ -112,7 +104,7 @@ interface RunSyncResult {
 	agentContract?: { version: 1 };
 	execution?: { status?: string; success?: boolean; exitCode?: number; error?: string };
 	review?: { status?: string };
-	effects?: { fileMutation?: { status?: string; expected?: boolean; attempted?: boolean; message?: string } };
+	effects?: { fileMutation?: { status?: string; attempted?: boolean } };
 	acceptance?: {
 		status?: string;
 		verifyRuns?: Array<{ status?: string }>;
@@ -223,6 +215,7 @@ interface ExecutorToolResult {
 	isError?: boolean;
 	details?: {
 		totalCost?: { inputTokens: number; outputTokens: number; costUsd: number };
+		results?: Array<{ launchResolvedExtensions?: LaunchResolvedExtensions }>;
 		controlEvents?: Array<{ type?: string }>;
 		asyncId?: string;
 		timeoutMs?: number;
@@ -303,11 +296,9 @@ export function installSingleExecutionHooks() {
 		previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
 		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
 		mockPi.reset();
-		clearExclusions();
 	});
 
 	afterEach(() => {
-		clearExclusions();
 		if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
 		else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
 		removeTempDir(agentDir);
@@ -351,11 +342,12 @@ export function installSingleExecutionHooks() {
 		workflowControllers?: Map<string, AbortController>,
 		handleScheduledRunAction?: Parameters<typeof createSubagentExecutor>[0]["handleScheduledRunAction"],
 		piEvents = createEventBus(),
-		discoverAgentsForCwd?: (cwd: string) => typeof agents,
+		discoverAgentsForCwd?: (cwd: string, preferredModelProvider?: string) => typeof agents,
 		childRuntime?: ChildRuntimeConfig,
+		sendMessage?: (message: unknown, options: unknown) => void,
 	) {
 		return createSubagentExecutor!({
-			pi: { events: piEvents, getSessionName: () => undefined },
+			pi: { events: piEvents, getSessionName: () => undefined, ...(sendMessage ? { sendMessage } : {}) },
 			...(childRuntime ? { childRuntime } : {}),
 			state: {
 				baseCwd: tempDir,
@@ -371,7 +363,7 @@ export function installSingleExecutionHooks() {
 			tempArtifactsDir: tempDir,
 			getSubagentSessionRoot: () => path.join(tempDir, ".pi-subagents", "sessions"),
 			expandTilde: (value: string) => value,
-			discoverAgents: (cwd: string) => ({ agents: discoverAgentsForCwd ? discoverAgentsForCwd(cwd) : agents }),
+			discoverAgents: (cwd: string, _scope: unknown, preferredModelProvider?: string) => ({ agents: discoverAgentsForCwd ? discoverAgentsForCwd(cwd, preferredModelProvider) : agents }),
 			allowMutatingManagementActions,
 			...(handleScheduledRunAction ? { handleScheduledRunAction } : {}),
 		});

package/dist/extensions/pi-subagents/test/support/watchdog-stable-host-loader.mjs

@@ -0,0 +1,23 @@
+const modules = {
+	"@earendil-works/pi-agent-core": `
+		export class Agent {}
+	`,
+	"@selesai/code": `
+		export function createReadOnlyTools() { return []; }
+		export function convertToLlm(messages) { return messages; }
+	`,
+	"@earendil-works/pi-ai": `
+		export const stableHostSurface = true;
+	`,
+	"@earendil-works/pi-ai/compat": `
+		export function streamSimple() { throw new Error("not invoked by the linking smoke test"); }
+	`,
+};
+
+export function resolve(specifier, context, nextResolve) {
+	const source = modules[specifier];
+	if (source !== undefined) {
+		return { url: `data:text/javascript,${encodeURIComponent(source)}`, shortCircuit: true };
+	}
+	return nextResolve(specifier, context);
+}

package/dist/extensions/pi-subagents/test/unit/acceptance-compaction.test.ts

@@ -16,10 +16,10 @@ import { createStructuredOutputRuntime } from "../../src/runs/shared/structured-
 const sdkRoot = process.env.SELESAI_SUBAGENTS_NATIVE_SDK;
 for (const host of ["foreground", "runner"] as const) {
 	for (const [systemPromptMode, structured] of [["append", false], ["replace", false], ["append", true], ["replace", true]] as const) {
-		it(`exact acceptance survives actual SDK split-turn compaction: ${host}/${systemPromptMode}/${structured ? "structured" : "fenced"}`, { skip: !sdkRoot && "Set SELESAI_SUBAGENTS_NATIVE_SDK to the isolated 0.85.1 SDK root" }, async () => {
+		it(`exact acceptance survives actual SDK split-turn compaction: ${host}/${systemPromptMode}/${structured ? "structured" : "fenced"}`, { skip: !sdkRoot && "Set SELESAI_SUBAGENTS_NATIVE_SDK to the isolated 0.86.1 SDK root" }, async () => {
 			const entry = execFileSync(process.execPath, ["--input-type=module", "-e", "console.log(import.meta.resolve('@selesai/code'))"], { cwd: sdkRoot, encoding: "utf8" }).trim();
 			const pi: PiCodingAgentModule = await import(entry);
-			assert.equal(pi.VERSION, "0.85.1");
+			assert.equal(pi.VERSION, "0.86.1");
 			const cwd = mkdtempSync(join(tmpdir(), "acceptance-compaction-"));
 			const agentDir = join(cwd, "agent"); mkdirSync(agentDir);
 			const oldDir = process.env.SELESAI_CODING_AGENT_DIR;
@@ -86,7 +86,7 @@ for (const host of ["foreground", "runner"] as const) {
 			try {
 				const result = host === "foreground"
 					? await runSync(cwd, [agent], agent.name, task, { acceptance: explicit, structuredOutput, waitToolEnabled: false, childSessionFactory: observedFactory })
-					: await runSingleStepInner({ ...agent, agent: agent.name, task, context: "fresh", effectiveAcceptance: acceptance, structuredOutput, modelCandidates: [agent.model!], waitToolEnabled: false }, { cwd, id: "compact-runner", flatIndex: 0, flatStepCount: 1, previousOutput: "", placeholder: "{previous}", outputFile: join(cwd, "output.log"), sessionEnabled: false, childSessions: observedFactory });
+					: await runSingleStepInner({ ...agent, agent: agent.name, task, context: "fresh", effectiveAcceptance: acceptance, structuredOutput, waitToolEnabled: false }, { cwd, id: "compact-runner", flatIndex: 0, flatStepCount: 1, previousOutput: "", placeholder: "{previous}", outputFile: join(cwd, "output.log"), sessionEnabled: false, childSessions: observedFactory });
 				assert.equal(result.exitCode, 0, `${result.error}; ${JSON.stringify(events.filter((e) => e.type.includes("compact") || (e.type === "message_end" && e.message.role === "assistant" && e.message.stopReason === "error")))}`);
 				assert.equal(result.acceptance?.status, "checked");
 				if (structured) assert.deepEqual(result.structuredOutput, { ok: true });