@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/smoke/tool-activation.test.ts

@@ -0,0 +1,128 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { test } from "node:test";
+import {
+	fauxAssistantMessage,
+	fauxProvider,
+	fauxToolCall,
+	getCurrentSystemPrompt,
+	getCurrentTools,
+	type FauxResponseFactory,
+	type FauxResponseStep,
+} from "@earendil-works/pi-ai";
+import {
+	DefaultResourceLoader,
+	ModelRuntime,
+	SessionManager,
+	SettingsManager,
+	createAgentSession,
+} from "@selesai/code";
+import { createSubagentParamsSchema } from "../../src/extension/schemas.ts";
+
+const packageToolNames = new Set(["subagents_enable", "bg_wait", "subagent_supervisor", "subagent"]);
+
+function serializedCharacters(tools: ReturnType<typeof getCurrentTools>): number {
+	return tools.filter((tool) => packageToolNames.has(tool.name)).reduce((total, tool) => total + JSON.stringify(tool).length, 0);
+}
+
+async function runNativeSession(config: Record<string, unknown> | undefined, responses: FauxResponseStep[], prompts: string[]): Promise<void> {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-activation-"));
+	const cwd = path.join(root, "project");
+	const agentDir = path.join(root, "agent");
+	fs.mkdirSync(cwd);
+	fs.mkdirSync(agentDir);
+	if (config) {
+		fs.mkdirSync(path.join(agentDir, "extensions", "subagent"), { recursive: true });
+		fs.writeFileSync(path.join(agentDir, "extensions", "subagent", "config.json"), JSON.stringify(config));
+	}
+	const priorAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+	const priorChild = process.env.SELESAI_SUBAGENT_CHILD;
+	process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+	delete process.env.SELESAI_SUBAGENT_CHILD;
+	let session: Awaited<ReturnType<typeof createAgentSession>>["session"] | undefined;
+	try {
+		const { default: registerSubagentExtension } = await import(`../../index.ts?native-activation=${Date.now()}`);
+		const faux = fauxProvider({ provider: "tool-activation", models: [{ id: "local" }], tokensPerSecond: 100_000 });
+		faux.setResponses(responses);
+		const settingsManager = SettingsManager.inMemory({});
+		const resourceLoader = new DefaultResourceLoader({
+			cwd, agentDir, settingsManager,
+			noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true,
+			extensionFactories: [registerSubagentExtension, (pi) => pi.registerProvider(faux.provider)],
+		});
+		await resourceLoader.reload();
+		const modelRuntime = await ModelRuntime.create({ authPath: path.join(agentDir, "auth.json"), modelsPath: path.join(agentDir, "models.json"), allowModelNetwork: false });
+		({ session } = await createAgentSession({
+			cwd, agentDir, settingsManager, resourceLoader, modelRuntime,
+			model: faux.getModel("local"), sessionManager: SessionManager.inMemory(cwd), noTools: "builtin",
+		}));
+		await session.bindExtensions({});
+		for (const prompt of prompts) await session.prompt(prompt);
+	} finally {
+		if (session) {
+			await (session.extensionRunner as any).emit({ type: "session_shutdown", reason: "quit" });
+			session.dispose();
+		}
+		if (priorAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR; else process.env.SELESAI_CODING_AGENT_DIR = priorAgentDir;
+		if (priorChild === undefined) delete process.env.SELESAI_SUBAGENT_CHILD; else process.env.SELESAI_SUBAGENT_CHILD = priorChild;
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+}
+
+test("native Pi exposes the full subagent schema on the request immediately after activation", { timeout: 30_000 }, async () => {
+	const captured: number[] = [];
+	await runNativeSession({ toolActivation: "dynamic" }, [
+		(context) => {
+			const tools = getCurrentTools(context.messages);
+			const systemPrompt = getCurrentSystemPrompt(context.messages);
+			assert.match(systemPrompt, /pi-subagents is installed/i);
+			assert.match(systemPrompt, /complexity alone is not authorization/i);
+			captured.push(serializedCharacters(tools));
+			const loader = tools.find((tool) => tool.name === "subagents_enable");
+			const wait = tools.find((tool) => tool.name === "bg_wait");
+			const supervisor = tools.find((tool) => tool.name === "subagent_supervisor");
+			assert.ok(loader);
+			assert.ok(wait);
+			assert.ok(supervisor);
+			assert.ok(JSON.stringify(loader).length <= 800);
+			assert.ok(!tools.some((tool) => tool.name === "subagent"));
+			return fauxAssistantMessage(fauxToolCall("subagents_enable", {}), { stopReason: "toolUse" });
+		},
+		(context) => {
+			const tools = getCurrentTools(context.messages);
+			captured.push(serializedCharacters(tools));
+			// Replay on resume relies on the first declared tool set recording the loader.
+			const firstDeclared = context.messages.find((message) => message.role === "system" && message.toolsAdded?.length);
+			assert.ok(firstDeclared?.role === "system" && firstDeclared.toolsAdded?.some((tool) => tool.name === "subagents_enable"));
+			const subagent = tools.find((tool) => tool.name === "subagent");
+			assert.ok(subagent);
+			assert.deepEqual(subagent.parameters, createSubagentParamsSchema());
+			return fauxAssistantMessage("Activation verified.");
+		},
+	], ["Use the authorized delegation tools."]);
+
+	assert.equal(captured.length, 2);
+	assert.ok(captured[0]! <= 5_500, `cold package schemas exceeded budget: ${captured[0]}`);
+	// Selesai defaults toolDescriptionMode to "full" (upstream: split metadata), so the activated budget is larger.
+	assert.ok(captured[1]! <= 26_000, `activated package schemas exceeded budget: ${captured[1]}`);
+	assert.ok(captured[1]! - captured[0]! >= 17_500, "lazy activation should remove the full subagent schema from cold requests");
+	console.log(`schema characters cold=${captured[0]} activated=${captured[1]}`);
+});
+
+test("native Pi starts auto sessions with subagent and no loader when the model cannot add tools", { timeout: 30_000 }, async () => {
+	// The faux model sets no compat flags.
+	const requests: string[][] = [];
+	const record: FauxResponseFactory = (context) => {
+		// One tool declaration across both prompts: the tool list never changed.
+		assert.equal(context.messages.filter((message) => message.role === "system" && (message.toolsAdded?.length || message.toolsRemoved?.length)).length, 1);
+		requests.push(getCurrentTools(context.messages).map((tool) => tool.name));
+		return fauxAssistantMessage("ok");
+	};
+	await runNativeSession(undefined, [record, record], ["First prompt.", "Second prompt."]);
+
+	assert.equal(requests.length, 2);
+	assert.ok(requests[0]!.includes("subagent") && requests[0]!.includes("bg_wait"));
+	assert.equal(requests[0]!.includes("subagents_enable"), false);
+});

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

@@ -14,10 +14,10 @@ import { channel } from "node:diagnostics_channel";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { asyncResultTimeoutEvidence } from "./async-result-timeout-evidence.ts";
 import { createEventBus, createMockPi, createTempDir, makeAgent, removeTempDir, resolveMockPiCallArgs, tryImport } from "./helpers.ts";
 import type { MockPi } from "./helpers.ts";
 import { CHILD_WATCHDOG_STATUS_EVENT } from "../../src/watchdog/child-status.ts";
-import { clearExclusions } from "../../src/runs/shared/model-exclusions.ts";
 
 interface LaunchResolvedExtensions {
 	version?: number;
@@ -72,7 +72,7 @@ interface AsyncResultPayload {
 	totalTokens?: { input: number; output: number; total: number };
 	totalCost?: { inputTokens: number; outputTokens: number; costUsd: number };
 	usageBudget?: UsageBudgetState;
-	results: Array<{ agent?: string; sessionName?: string; launchContractDigest?: string; launchResolvedExtensions?: LaunchResolvedExtensions; runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions; output?: string; outputState?: "present" | "absent" | "unknown"; success?: boolean; error?: string; timedOut?: boolean; timeoutRecovery?: { changedFiles?: string[]; message?: string; warning?: string; recoveryNeeded?: boolean; reason?: string; reportStatus?: string }; stopped?: boolean; turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; terminationDeferredAtTurn?: number; exceededAtTurn?: number }; turnBudgetExceeded?: boolean; wrapUpRequested?: boolean; model?: string; thinking?: string; attemptedModels?: string[]; modelAttempts?: Array<{ success?: boolean; error?: string }>; totalCost?: { inputTokens: number; outputTokens: number; costUsd: number }; usage?: { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number; turns: number }; structuredOutput?: unknown; agentContract?: { version: 1 }; execution?: { status?: string; success?: boolean; exitCode?: number }; effects?: { fileMutation?: { status?: string; expected?: boolean; attempted?: boolean; message?: string }; settlementDiagnostic?: { finalTextPresent?: boolean; mutation?: { expected?: boolean; attempted?: boolean; observed?: boolean }; requiredOutput?: { kind?: string; path?: string; missing?: boolean }; afterCompactionSettlement?: boolean } }; intercomTarget?: string; acceptance?: { status?: string; effectiveAcceptance?: { level?: string }; childReport?: unknown; runtimeChecks?: Array<{ id?: string; status?: string; message?: string }> }; artifactPaths?: { outputPath?: string; inputPath?: string; metadataPath?: string; transcriptPath?: string }; outputSaveError?: string; metadataSaveError?: string; capabilityCeiling?: { version?: number; allowedTools?: string[]; denyExtensions?: boolean; sources?: string[] }; capabilityAudit?: { effectiveTools?: string[]; removedTools?: string[]; extensionsDenied?: boolean } }>;
+	results: Array<{ agent?: string; sessionName?: string; launchContractDigest?: string; launchResolvedExtensions?: LaunchResolvedExtensions; runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions; output?: string; outputState?: "present" | "absent" | "unknown"; success?: boolean; error?: string; timedOut?: boolean; timeoutRecovery?: { changedFiles?: string[]; message?: string; warning?: string; recoveryNeeded?: boolean; reason?: string; reportStatus?: string }; stopped?: boolean; turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; terminationDeferredAtTurn?: number; exceededAtTurn?: number }; turnBudgetExceeded?: boolean; wrapUpRequested?: boolean; model?: string; thinking?: string; totalCost?: { inputTokens: number; outputTokens: number; costUsd: number }; usage?: { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number; turns: number }; structuredOutput?: unknown; agentContract?: { version: 1 }; execution?: { status?: string; success?: boolean; exitCode?: number }; effects?: { fileMutation?: { status?: string; attempted?: boolean }; settlementDiagnostic?: { finalTextPresent?: boolean; mutation?: { attempted?: boolean; observed?: boolean }; requiredOutput?: { kind?: string; path?: string; missing?: boolean }; afterCompactionSettlement?: boolean } }; intercomTarget?: string; acceptance?: { status?: string; effectiveAcceptance?: { level?: string }; childReport?: unknown; runtimeChecks?: Array<{ id?: string; status?: string; message?: string }> }; artifactPaths?: { outputPath?: string; inputPath?: string; metadataPath?: string; transcriptPath?: string }; outputSaveError?: string; artifactOutputSaveFailed?: true; metadataSaveError?: string; capabilityCeiling?: { version?: number; allowedTools?: string[]; denyExtensions?: boolean; sources?: string[] }; capabilityAudit?: { effectiveTools?: string[]; removedTools?: string[]; extensionsDenied?: boolean } }>;
 	outputs?: Record<string, { text?: string; structured?: unknown }>;
 	workflowGraph?: { nodes?: Array<{ kind?: string; label?: string; phase?: string; status?: string; acceptanceStatus?: string; error?: string; outputName?: string; structured?: boolean; children?: Array<{ label?: string; outputName?: string; itemKey?: string; status?: string; acceptanceStatus?: string; error?: string }> }> };
 	parallelHandoff?: { version?: number; path?: string; groupCount?: number; childCount?: number; changedPatches?: number; cleanupState?: string };
@@ -131,7 +131,7 @@ interface AsyncStatusPayload {
 		launchResolvedExtensions?: LaunchResolvedExtensions;
 		runtimeAcknowledgedExtensions?: RuntimeAcknowledgedExtensions;
 		execution?: { status?: string; success?: boolean; exitCode?: number };
-		effects?: { fileMutation?: { status?: string; expected?: boolean; attempted?: boolean }; settlementDiagnostic?: { finalTextPresent?: boolean; mutation?: { expected?: boolean; attempted?: boolean; observed?: boolean }; requiredOutput?: { kind?: string; path?: string; missing?: boolean }; afterCompactionSettlement?: boolean } };
+		effects?: { fileMutation?: { status?: string; attempted?: boolean }; settlementDiagnostic?: { finalTextPresent?: boolean; mutation?: { attempted?: boolean; observed?: boolean }; requiredOutput?: { kind?: string; path?: string; missing?: boolean }; afterCompactionSettlement?: boolean } };
 		acceptance?: { status?: string };
 		contextLimit?: number;
 		turnBudget?: { maxTurns: number; graceTurns: number; outcome: string; turnCount: number; wrapUpRequestedAtTurn?: number; terminationDeferredAtTurn?: number; exceededAtTurn?: number };
@@ -147,6 +147,7 @@ interface MockPiCallRecord {
 	effectiveArgs?: string[];
 	systemPrompts?: Array<{ mode?: string; path?: string; text?: string; error?: string }>;
 	requiredChildTools?: string[];
+	launch?: { tools?: string[]; builtinMcpTools?: Array<{ name: string; selector: string }>; ambientExtensions?: boolean; processEnv?: Record<string, string> };
 	/** The `ChildRuntimeConfig` the scripted child session was launched with. */
 	runtime?: Record<string, unknown>;
 }
@@ -339,25 +340,7 @@ async function waitForAsyncResultFile(id: string, timeoutMs = 15_000): Promise<s
 		if (Date.now() > deadline) {
 			const asyncDir = path.join(ASYNC_DIR, id);
 			// Summarize before teardown; never print free-form output, prompts or tokens.
-			const evidence = ["status.json", "runner-startup-proceed.json", "process-terminal.json", "events.jsonl", "runner.stdout.log", "runner.stderr.log"].map((name) => {
-				let text: string;
-				try {
-					text = fs.readFileSync(path.join(asyncDir, name), "utf-8");
-				} catch (error) {
-					const code = (error as NodeJS.ErrnoException).code;
-					return `${name}: ${code === "ENOENT" ? "absent" : `unreadable (${code ?? "unknown"})`}`;
-				}
-				if (!text.length) return `${name}: empty`;
-				const size = `${Buffer.byteLength(text)} bytes (contents withheld)`;
-				if (name !== "status.json") return `${name}: readable, ${size}`;
-				try {
-					const status = JSON.parse(text) as AsyncStatusPayload;
-					const knownState = (value: unknown) => ["pending", "running", "complete", "failed", "cancelled"].includes(String(value)) ? value : "other/absent";
-					return `${name}: ${JSON.stringify({ state: knownState(status.state), steps: status.steps?.map((step) => knownState(step.status)), endedAtPresent: typeof status.endedAt === "number" })}`;
-				} catch {
-					return `${name}: invalid status JSON, ${size}`;
-				}
-			});
+			const evidence = asyncResultTimeoutEvidence(asyncDir, id);
 			// The current fixture queue proves prompt entry, not per-run identity or settlement.
 			const queueDir = process.env.MOCK_PI_QUEUE_DIR;
 			let mockEvidence = "mock queue: not configured";
@@ -636,11 +619,9 @@ export function installAsyncExecutionHooks(): void {
 	beforeEach(() => {
 		tempDir = createTempDir();
 		mockPi.reset();
-		clearExclusions();
 	});
 
 	afterEach(() => {
-		clearExclusions();
 		removeTempDir(tempDir);
 	});
 }
@@ -671,7 +652,7 @@ export function installAsyncExecutionHooks(): void {
 		const receipt = executeAsyncSingle(id, {
 			agent: "worker",
 			task: "Exercise child protocol",
-			agentConfig: makeAgent("worker", { completionGuard: false }),
+			agentConfig: makeAgent("worker"),
 			ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
 			artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
 			shareEnabled: false,

package/dist/extensions/pi-subagents/test/support/async-result-timeout-evidence.ts

@@ -0,0 +1,61 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// Failure-only observations, not terminality predicates. Never expose free-form fields.
+export function asyncResultTimeoutEvidence(asyncDir: string, id: string): string[] {
+	const record = (value: unknown): Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+	const number = (value: unknown) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+	const known = (value: unknown, choices: string[]) => typeof value === "string" && choices.includes(value) ? value : "other/absent";
+	const states = ["pending", "queued", "running", "complete", "completed", "failed", "cancelled", "paused", "stopped", "partial", "rejected", "observed", "unknown", "not-started"];
+	let runnerId: string | undefined;
+	const identity = (raw: Record<string, unknown>) => ({
+		runIdMatches: raw.runId === id,
+		runnerIdMatches: runnerId === undefined ? "unavailable" : raw.runnerProcessInstanceId === runnerId,
+	});
+	const proof = (raw: Record<string, unknown>) => ({
+		...identity(raw), state: known(raw.state, states), observedAt: number(raw.observedAt),
+		reason: known(raw.reason, ["observer-unavailable", "runner-candidate-missing", "runner-instance-mismatch", "writer-close-unverified", "process-tree-unverified", "canonical-session-unavailable", "canonical-session-lease-active", "canonical-session-release-unverified", "proof-write-failed", "stale-repair"]),
+		runner: Array.isArray(raw.instances) ? raw.instances.slice(0, 16).map(record).filter((entry) => entry.kind === "runner").map((entry) => ({
+			instanceMatches: runnerId === undefined ? "unavailable" : entry.processInstanceId === runnerId, closeObservedAt: number(entry.closeObservedAt),
+			exitCode: entry.exitCode === null ? null : number(entry.exitCode), signal: entry.signal === null ? null : known(entry.signal, ["SIGTERM", "SIGKILL", "SIGINT", "SIGABRT", "SIGSEGV"]),
+		})) : undefined,
+	});
+	return ["status.json", "runner-startup-proceed.json", "process-terminal.json", "process-terminal-candidate.json", "events.jsonl", "runner.stdout.log", "runner.stderr.log"].map((name) => {
+		let fd: number | undefined;
+		try {
+			fd = fs.openSync(path.join(asyncDir, name), "r");
+			const bytes = fs.fstatSync(fd).size;
+			const base = { bytes, readAt: Date.now() };
+			if (!bytes || name.endsWith(".log") || name === "runner-startup-proceed.json") return `${name}: ${JSON.stringify(base)} (contents withheld)`;
+			const limit = 16_384;
+			const offset = name === "events.jsonl" ? Math.max(0, bytes - limit) : 0;
+			if (bytes > limit && name !== "events.jsonl") return `${name}: ${JSON.stringify(base)} (oversize, contents withheld)`;
+			const buffer = Buffer.alloc(Math.min(bytes, limit));
+			const text = buffer.subarray(0, fs.readSync(fd, buffer, 0, buffer.length, offset)).toString("utf-8");
+			if (name === "events.jsonl") {
+				let invalidLines = 0;
+				let mismatchedRunEvents = 0;
+				const events = [];
+				for (const line of text.split("\n").slice(offset ? 1 : 0).filter(Boolean)) {
+					try {
+						const raw = record(JSON.parse(line));
+						if (typeof raw.type !== "string" || !["subagent.run.started", "subagent.step.completed", "subagent.step.failed", "subagent.parallel.completed", "subagent.run.completed", "subagent.run.process_terminal"].includes(raw.type)) continue;
+						if (raw.runId !== id) { mismatchedRunEvents++; continue; }
+						events.push({ type: raw.type, ts: number(raw.ts), stepIndex: number(raw.stepIndex), pid: number(raw.pid), status: known(raw.status, states), exitCode: number(raw.exitCode), ...(raw.processTerminal ? { proof: proof(record(raw.processTerminal)) } : {}) });
+					} catch { invalidLines++; }
+				}
+				return `${name}: ${JSON.stringify({ ...base, tailOnly: offset > 0, invalidLines, mismatchedRunEvents, events: events.slice(-16) })}`;
+			}
+			const raw = record(JSON.parse(text));
+			if (name === "status.json") {
+				const terminal = record(raw.processTerminal);
+				if (raw.runId === id && terminal.runId === id && typeof terminal.runnerProcessInstanceId === "string") runnerId = terminal.runnerProcessInstanceId;
+				return `${name}: ${JSON.stringify({ ...base, runIdMatches: raw.runId === id, pid: number(raw.pid), state: known(raw.state, states), lastUpdate: number(raw.lastUpdate), endedAt: number(raw.endedAt), steps: Array.isArray(raw.steps) ? raw.steps.slice(0, 16).map((step) => known(record(step).status, states)) : undefined, proof: proof(terminal) })}`;
+			}
+			if (name === "process-terminal-candidate.json") return `${name}: ${JSON.stringify({ ...base, ...identity(raw), writers: ["0", "1"].map((index) => ({ index, count: Array.isArray(record(raw.writers)[index]) ? (record(raw.writers)[index] as unknown[]).length : undefined, expected: number(record(raw.expectedWriters)[index]) })) })}`;
+			return `${name}: ${JSON.stringify({ ...base, ...proof(raw) })}`;
+		} catch (error) {
+			return `${name}: ${error instanceof SyntaxError ? "invalid JSON" : known(record(error).code, ["ENOENT", "EACCES", "EPERM", "EBUSY", "EIO", "EMFILE", "ENFILE", "ENOSPC"])}`;
+		} finally { if (fd !== undefined) fs.closeSync(fd); }
+	});
+}

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 }>;
@@ -44,6 +46,14 @@ export interface FakeChildResponse {
 	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 {
@@ -53,6 +63,7 @@ export interface FakeChildSessionRecord {
 	aborted: boolean;
 	disposed: boolean;
 	settled: boolean;
+	scriptedFinalEmitted: boolean;
 	session?: ChildSession;
 }
 
@@ -207,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; });
@@ -232,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);
@@ -300,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);
@@ -324,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}`);
@@ -362,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,
@@ -369,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");
@@ -384,16 +495,18 @@ export function createFakeChildSessions(queueDir: () => string): FakeChildSessio
 						failingSteers--;
 						throw new Error("mock child cannot accept steering");
 					}
-					record.steers.push({ text, mode: "steer" });
-					recordSteer(text, "steer");
+					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);
+} });