@selesai/code 0.13.39 → 0.14.0

package/dist/extensions/pi-subagents/test/smoke/standalone-revival.ts

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
+import { inspectSessionLease } from "../../src/runs/shared/session-lease.js";
+
+type Run = { asyncId: string; asyncDir: string };
+
+export async function verifyRevival(
+	tool: Parameters<ExtensionAPI["registerTool"]>[0],
+	ctx: ExtensionContext,
+	source: Run,
+	waitForFile: (file: string, predicate: (text: string) => boolean) => Promise<void>,
+	nextCompletion: (text: string) => Promise<void>,
+): Promise<void> {
+	assert.equal(JSON.parse(fs.readFileSync("/stage/startup-hook-ready.json", "utf8")).mode, "revival");
+	const sourceStatus = JSON.parse(fs.readFileSync(`${source.asyncDir}/status.json`, "utf8"));
+	const sessionFile: string = sourceStatus.steps[0].sessionFile;
+	assert.ok(fs.existsSync(sessionFile));
+	const initialLease = inspectSessionLease(sessionFile);
+	assert.equal(initialLease.state, "free");
+	const { canonicalSessionFile, canonicalSessionId } = initialLease;
+	const root = path.dirname(source.asyncDir);
+	const before = new Set(fs.readdirSync(root));
+	const completed = nextCompletion("standalone child response verified REVIVAL_");
+	// Establish a real owner first, then challenge it while its provider call holds the lease.
+	const winnerLaunch = await tool.execute(
+		"REVIVAL_A", { action: "resume", id: source.asyncId, message: "REVIVAL_A", acceptance: false, timeoutMs: 20000 },
+		new AbortController().signal, undefined, ctx,
+	);
+	const winner = winnerLaunch.details as Run;
+	const winnerStatus = JSON.parse(fs.readFileSync(`${winner.asyncDir}/status.json`, "utf8"));
+	assert.notEqual(winnerStatus.pid, process.pid);
+	assert.doesNotThrow(() => process.kill(winnerStatus.pid, 0));
+	const lease = inspectSessionLease(sessionFile);
+	assert.ok(lease.state === "owned");
+	assert.equal(lease.canonicalSessionFile, canonicalSessionFile);
+	assert.equal(lease.canonicalSessionId, canonicalSessionId);
+	assert.equal(lease.owner.canonicalSessionFile, canonicalSessionFile);
+	assert.equal(lease.owner.runId, winner.asyncId);
+	assert.equal(lease.owner.sourceRunId, source.asyncId);
+	assert.equal(lease.owner.parentSessionId, ctx.sessionManager.getSessionId());
+	assert.equal(lease.owner.pid, winnerStatus.pid);
+	await waitForFile("/stage/lifecycle.jsonl", (text) => text.trim().split("\n").map((line) => JSON.parse(line)).some((event) => event.event === "request" && event.pid === lease.owner.pid));
+	const request = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).find((event) => event.event === "request" && event.pid === lease.owner.pid);
+	assert.ok(JSON.stringify(request.messages).includes("standalone child response verified SINGLE"), "revival must load the actual previous SDK conversation");
+	const refusal = await tool.execute(
+		"REVIVAL_B", { action: "resume", id: source.asyncId, message: "REVIVAL_B", acceptance: false, timeoutMs: 20000 },
+		new AbortController().signal, undefined, ctx,
+	).then(() => assert.fail("a second revival must not acquire the owned session"), String);
+	assert.ok(refusal.includes(`'${canonicalSessionFile}' is already owned by run '${winner.asyncId}'`), "a second revival must refuse the exact owned session and name its owner");
+	fs.writeFileSync("/stage/revival-competition.json", JSON.stringify({ winner, refusal, owner: { runId: lease.owner.runId, sourceRunId: lease.owner.sourceRunId, pid: lease.owner.pid } }, null, 2));
+	const contenders = fs.readdirSync(root).filter((name) => !before.has(name));
+	assert.equal(contenders.length, 2, "both requests must reach independent configured runners");
+	const losingId = contenders.find((id) => id !== winner.asyncId)!;
+	await waitForFile(`${root}/${losingId}/process-terminal.json`, (text) => JSON.parse(text).state !== "pending");
+	const losingTerminal = JSON.parse(fs.readFileSync(`${root}/${losingId}/process-terminal.json`, "utf8"));
+	assert.equal(losingTerminal.state, "observed");
+	const losingStatus = JSON.parse(fs.readFileSync(`${root}/${losingId}/status.json`, "utf8"));
+	assert.equal(losingStatus.state, "failed");
+	assert.notEqual(losingStatus.pid, winnerStatus.pid);
+	assert.notEqual(losingStatus.processTerminal.runnerProcessInstanceId, winnerStatus.processTerminal.runnerProcessInstanceId);
+	assert.throws(() => process.kill(losingStatus.pid, 0), { code: "ESRCH" });
+	assert.ok(!fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).some((event) => event.pid === losingStatus.pid), "loser must not enter the provider/session");
+	const retainedLease = inspectSessionLease(sessionFile);
+	assert.ok(retainedLease.state === "owned", "loser cleanup must not release the winner's lease");
+	assert.equal(retainedLease.canonicalSessionId, canonicalSessionId);
+	assert.deepEqual(
+		{ token: retainedLease.owner.token, runId: retainedLease.owner.runId, sourceRunId: retainedLease.owner.sourceRunId, parentSessionId: retainedLease.owner.parentSessionId, pid: retainedLease.owner.pid },
+		{ token: lease.owner.token, runId: lease.owner.runId, sourceRunId: lease.owner.sourceRunId, parentSessionId: lease.owner.parentSessionId, pid: lease.owner.pid },
+		"loser cleanup must not replace or release the winner's lease",
+	);
+	fs.writeFileSync("/stage/release", "go");
+	await completed;
+	await finish(winner, "complete", lease.owner.token);
+
+	const failedCompletion = nextCompletion("fixture revival failure");
+	const failedLaunch = await tool.execute("revival-failure", { action: "resume", id: winner.asyncId, message: "REVIVAL_FAIL", acceptance: false, timeoutMs: 20000 }, new AbortController().signal, undefined, ctx);
+	const failed = failedLaunch.details as Run;
+	await failedCompletion;
+	await waitForFile(`${failed.asyncDir}/process-terminal.json`, (text) => JSON.parse(text).state !== "pending");
+	const failedCandidate = JSON.parse(fs.readFileSync(`${failed.asyncDir}/process-terminal-candidate.json`, "utf8"));
+	assert.equal(typeof failedCandidate.revivalLeaseToken, "string");
+	await finish(failed, "failed", failedCandidate.revivalLeaseToken);
+	assert.match(JSON.parse(fs.readFileSync(`${failed.asyncDir}/status.json`, "utf8")).error, /fixture revival failure/);
+	fs.writeFileSync("/stage/revival-result.json", JSON.stringify({ source, winner, loser: losingId, failed, sessionFile }, null, 2));
+
+	async function finish(run: Run, state: string, token: string): Promise<void> {
+		await waitForFile(`${run.asyncDir}/process-terminal.json`, (text) => JSON.parse(text).state !== "pending");
+		const status = JSON.parse(fs.readFileSync(`${run.asyncDir}/status.json`, "utf8"));
+		const terminal = JSON.parse(fs.readFileSync(`${run.asyncDir}/process-terminal.json`, "utf8"));
+		const candidate = JSON.parse(fs.readFileSync(`${run.asyncDir}/process-terminal-candidate.json`, "utf8"));
+		assert.equal(status.state, state);
+		assert.equal(status.sessionId, ctx.sessionManager.getSessionId());
+		assert.equal(status.steps[0].sessionFile, sessionFile);
+		assert.equal(terminal.state, "observed");
+		assert.equal(terminal.canonicalSession.leaseDisposition, "released");
+		assert.equal(terminal.canonicalSession.canonicalSessionLeaseReleased, true);
+		assert.equal(candidate.revivalLeaseToken, token);
+		assert.equal(candidate.revivalLeaseReleaseAcknowledged, true);
+		assert.equal(inspectSessionLease(sessionFile).state, "free");
+		assert.throws(() => process.kill(status.pid, 0), { code: "ESRCH" });
+		const handshake = fs.readFileSync("/stage/handshake.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.runId === run.asyncId);
+		assert.deepEqual(handshake.map((event) => [event.action, event.stateBefore]), [["ack", "ready"], ["confirm", "acknowledged"], ["proceed", "confirmed"]]);
+		assert.ok(handshake.every((event) => event.tokenMatches && !event.childStartedBeforeCommit));
+		const lifecycle = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.pid === status.pid);
+		assert.deepEqual(lifecycle.map((event) => event.event), ["start", "request", "shutdown"]);
+	}
+}

package/dist/extensions/pi-subagents/test/smoke/standalone-shared.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
+import { discoverAgents } from "../../src/agents/agents.js";
+import { executeAsyncChain } from "../../src/runs/background/async-execution.js";
+import { requestAsyncStop } from "../../src/runs/background/control-channel.js";
+import { resolveControlConfig } from "../../src/runs/shared/subagent-control.js";
+import { DEFAULT_ARTIFACT_CONFIG } from "../../src/shared/types.js";
+
+export async function verifySharedRun(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	mode: string,
+	waitForFile: (file: string, predicate: (text: string) => boolean) => Promise<void>,
+	completed: Promise<unknown>,
+): Promise<void> {
+	// Public workflows create independent runs. Use the existing private execution
+	// seam to exercise two real SDK sessions inside ONE configured runner.
+	const launch = executeAsyncChain(randomUUID(), {
+		chain: [{ parallel: ["LEFT", "RIGHT"].map((task) => ({ agent: "binary-smoke", task, output: false, acceptance: false })) }],
+		agents: discoverAgents(ctx.cwd, "project").agents,
+		ctx: { pi, cwd: ctx.cwd, currentSessionId: ctx.sessionManager.getSessionId(), parentSessionId: ctx.sessionManager.getSessionId(), currentModel: ctx.model },
+		artifactConfig: DEFAULT_ARTIFACT_CONFIG,
+		artifactsDir: "/stage/shared-artifacts",
+		shareEnabled: false,
+		sessionRoot: "/stage/shared-sessions",
+		maxSubagentDepth: 2,
+		globalConcurrencyLimit: 2,
+		controlConfig: resolveControlConfig(undefined, { enabled: true }),
+		timeoutMs: 20000,
+	});
+	assert.notEqual(launch.isError, true, JSON.stringify(launch));
+	fs.writeFileSync("/stage/launch.json", JSON.stringify(launch, null, 2));
+	const { asyncId, asyncDir } = launch.details;
+	assert.ok(asyncId && asyncDir);
+	await waitForFile("/stage/lifecycle.jsonl", (text) => text.trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.event === "request").length === 2);
+	const active = JSON.parse(fs.readFileSync(`${asyncDir}/status.json`, "utf8"));
+	assert.equal(active.steps.length, 2);
+	assert.equal(active.state, "running");
+	// Held requests witness execution even if status projection lags them.
+	const held = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.pid === active.pid);
+	assert.equal(held.filter((event) => event.event === "request").length, 2);
+	assert.equal(held.filter((event) => event.event === "shutdown").length, 0);
+	fs.writeFileSync("/stage/shared-active-witness.json", JSON.stringify({ pid: active.pid, heldRequests: 2, shutdowns: 0, projectedSteps: active.steps.map((step: { status: string }) => step.status) }));
+	if (mode === "parallel-stop") fs.writeFileSync("/stage/parallel-control.json", JSON.stringify(requestAsyncStop(asyncDir)));
+	else fs.writeFileSync("/stage/release", "go");
+	await completed;
+	await waitForFile(`${asyncDir}/process-terminal.json`, (text) => JSON.parse(text).state !== "pending");
+	const status = JSON.parse(fs.readFileSync(`${asyncDir}/status.json`, "utf8"));
+	const terminal = JSON.parse(fs.readFileSync(`${asyncDir}/process-terminal.json`, "utf8"));
+	assert.equal(status.state, mode === "parallel-stop" ? "stopped" : "complete");
+	assert.equal(status.sessionId, ctx.sessionManager.getSessionId());
+	assert.equal(status.runId, asyncId);
+	assert.equal(terminal.state, "observed");
+	assert.equal(terminal.instances.length, 1, "one host process, no per-session CLI writers");
+	assert.equal(terminal.instances[0].exitCode, 0);
+	assert.throws(() => process.kill(status.pid, 0), { code: "ESRCH" });
+	const lifecycle = fs.readFileSync("/stage/lifecycle.jsonl", "utf8").trim().split("\n").map((line) => JSON.parse(line)).filter((event) => event.pid !== process.pid);
+	assert.ok(lifecycle.every((event) => event.pid === status.pid));
+	const starts = lifecycle.filter((event) => event.event === "start");
+	const shutdowns = lifecycle.filter((event) => event.event === "shutdown");
+	assert.equal(starts.length, 2);
+	assert.equal(shutdowns.length, 2);
+	assert.equal(new Set(starts.map((event) => event.sessionId)).size, 2);
+	assert.deepEqual(shutdowns.map((event) => event.sessionId).sort(), starts.map((event) => event.sessionId).sort());
+	assert.ok(starts.every((event) => event.sdkIdentity && event.provider === "standalone-smoke" && event.model === "local"));
+	if (mode === "shared-run") {
+		const transcripts = status.steps.map((step: { transcriptPath: string }) => fs.readFileSync(step.transcriptPath, "utf8"));
+		assert.ok(transcripts[0].includes("standalone child response verified LEFT"));
+		assert.ok(transcripts[1].includes("standalone child response verified RIGHT"));
+		const sessions = shutdowns.map((event) => fs.readFileSync(event.sessionFile, "utf8"));
+		assert.equal(new Set(shutdowns.map((event) => event.sessionFile)).size, 2);
+		for (const label of ["LEFT", "RIGHT"]) assert.equal(sessions.filter((text) => text.includes(`standalone child response verified ${label}`)).length, 1);
+	} else {
+		assert.ok(status.steps.every((step: { status: string }) => step.status === "stopped"));
+	}
+	fs.writeFileSync("/stage/shared-result.json", JSON.stringify({ asyncId, asyncDir, mode, sessions: starts.map((event) => event.sessionId), terminal }, null, 2));
+}

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); }
+	});
+}