@selesai/code 0.13.16 → 0.13.19

package/dist/extensions/pi-subagents/test/unit/chain-root-attachment.test.ts

@@ -115,6 +115,40 @@ describe("async chain root attachment", () => {
 		assert.equal(result.exitCode, 0);
 	});
 
+	for (const proofState of [undefined, "pending"]) it(`waits past the terminal grace for workflow-owned single publication with ${proofState ?? "absent"} root proof`, async (t) => {
+		t.mock.timers.enable({ apis: ["setTimeout", "Date"], now: 0 });
+		const importedRoot = { ...root(), resultPath: path.join(tempDir, "root-run", "workflow-result.json") };
+		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
+			runId: importedRoot.runId,
+			mode: "single",
+			parentWorkflowRunId: "workflow-parent",
+			state: "running",
+			pid: process.pid,
+			startedAt: 1,
+			...(proofState ? { processTerminal: { version: 1, runId: importedRoot.runId, runnerProcessInstanceId: "runner-instance", state: proofState } } : {}),
+			steps: [{ agent: "worker", status: "complete" }],
+		});
+
+		// The live publisher is this process; advance only the waiter's clock,
+		// leaving the real completed-step evidence intact until publication.
+		const waiting = waitForImportedAsyncRoot(importedRoot);
+		for (let poll = 0; poll < 3; poll++) {
+			t.mock.timers.tick(500);
+			await Promise.resolve();
+		}
+		assert.equal(Date.now(), 1_500);
+		assert.equal(fs.existsSync(importedRoot.resultPath), false);
+		writeJson(importedRoot.resultPath, {
+			state: "complete",
+			success: true,
+			results: [{ agent: "worker", output: "published after step completion", success: true }],
+		});
+		t.mock.timers.tick(500);
+		const result = await waiting;
+		assert.equal(result.success, true, result.error);
+		assert.equal(result.output, "published after step completion");
+	});
+
 	it("imports a failed root as a failed first chain step", async () => {
 		const importedRoot = root();
 		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
@@ -188,14 +222,21 @@ describe("async chain root attachment", () => {
 		assert.deepEqual(result.effects?.fileMutation?.evidence?.changedFiles, ["input.md"]);
 	});
 
-	it("fails a terminal root that never produced a result file", async () => {
-		const importedRoot = root();
+	for (const fixture of [
+		{ name: "terminal root", status: { mode: "single", state: "complete" } },
+		{ name: "terminal workflow-owned single", status: { mode: "single", state: "complete", parentWorkflowRunId: "workflow-parent" } },
+		{ name: "running workflow-owned single with unavailable root proof", status: {
+			mode: "single", state: "running", parentWorkflowRunId: "workflow-parent",
+			processTerminal: { version: 1, runId: "root-run", runnerProcessInstanceId: "runner-instance", state: "unknown", reason: "runner-candidate-missing" },
+		} },
+		{ name: "selected child of running workflow-owned parallel root", index: 1, status: { mode: "parallel", state: "running", parentWorkflowRunId: "workflow-parent" } },
+	]) it(`fails closed without a result for ${fixture.name}`, async () => {
+		const importedRoot = root("root-run", fixture.index ?? 0);
 		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
 			runId: importedRoot.runId,
-			mode: "single",
-			state: "complete",
+			...fixture.status,
 			startedAt: 1,
-			steps: [{ agent: "worker", status: "complete" }],
+			steps: [...(fixture.index ? [{ agent: "first", status: "running" }] : []), { agent: "worker", status: "complete" }],
 		});
 
 		const result = await waitForImportedAsyncRoot(importedRoot, {
@@ -203,6 +244,7 @@ describe("async chain root attachment", () => {
 			terminalResultGraceMs: 0,
 		});
 
+		assert.equal(result.agent, "worker");
 		assert.equal(result.exitCode, 1);
 		assert.match(result.error ?? "", /ended without a result file/);
 	});
@@ -233,4 +275,4 @@ describe("async chain root attachment", () => {
 		assert.equal(result.error, "parent timed out");
 		assert.equal(result.output, "parent timed out");
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/child-runtime-config.test.ts

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createChildHooks } from "../../src/runs/shared/child-hooks.ts";
+import { childSupervisorMetadata, evaluateChildToolDiagnostic, type ChildRuntimeConfig } from "../../src/runs/shared/child-runtime-config.ts";
+
+function baseConfig(overrides: Partial<ChildRuntimeConfig> = {}): ChildRuntimeConfig {
+	return { fanoutChild: false, depth: 1, waitTool: { enabled: true }, fast: false, ...overrides };
+}
+
+interface FakePi {
+	handlers: Map<string, Array<(event?: unknown, ctx?: unknown) => unknown>>;
+	tools: Array<{ name: string }>;
+	api: unknown;
+}
+
+function fakePi(available: string[]): FakePi {
+	const handlers = new Map<string, Array<(event?: unknown, ctx?: unknown) => unknown>>();
+	const tools: Array<{ name: string }> = [];
+	const api = {
+		on(event: string, handler: (event?: unknown, ctx?: unknown) => unknown) {
+			handlers.set(event, [...(handlers.get(event) ?? []), handler]);
+		},
+		registerTool(tool: { name: string }) { tools.push(tool); },
+		getAllTools: () => [...available, ...tools.map((tool) => tool.name)].map((name) => ({ name })),
+		events: { on() {}, emit() {} },
+		sendMessage() {},
+		getThinkingLevel: () => "off",
+	};
+	return { handlers, tools, api };
+}
+
+describe("child runtime config", () => {
+	it("creates the prompt runtime hook always and the fast and fanout hooks on demand", () => {
+		assert.deepEqual(createChildHooks(baseConfig()).map((hook) => hook.name), ["pi-subagents:prompt-runtime"]);
+		assert.deepEqual(createChildHooks(baseConfig({ fast: true })).map((hook) => hook.name), ["pi-subagents:prompt-runtime", "pi-subagents:fast-mode"]);
+		assert.deepEqual(createChildHooks(baseConfig({ fanoutChild: true })).map((hook) => hook.name), ["pi-subagents:prompt-runtime", "pi-subagents:fanout-child"]);
+	});
+
+	it("hooks read the config object", async () => {
+		const diagnostics: unknown[] = [];
+		const captured: unknown[] = [];
+		const config = baseConfig({
+			agent: "config-agent",
+			requiredTools: ["read", "fixture_search"],
+			toolDiagnostic: (diagnostic) => diagnostics.push(diagnostic),
+			structuredOutput: { schema: { type: "object" }, capture: (value) => captured.push(value) },
+			inheritProjectContext: true,
+			inheritGlobalContext: true,
+			inheritSkills: true,
+		});
+		const pi = fakePi(["read"]);
+		for (const hook of createChildHooks(config)) hook.factory(pi.api as never);
+
+		assert.throws(() => pi.handlers.get("agent_start")?.[0]?.({}), /Agent 'config-agent' requested unavailable child tools: fixture_search/);
+		assert.deepEqual(diagnostics, [{ agent: "config-agent", required: ["read", "fixture_search"], available: ["read", "bg_wait", "subagent_wait", "structured_output"], missing: ["fixture_search"] }]);
+
+		const structured = pi.tools.find((tool) => tool.name === "structured_output") as { execute: (id: string, params: { value: unknown }) => Promise<unknown> } | undefined;
+		assert.ok(structured, "structured_output tool registered from config");
+		await structured.execute("call-1", { value: { done: true } });
+		assert.deepEqual(captured, [{ done: true }]);
+
+		const rewritten = await pi.handlers.get("before_agent_start")?.[0]?.({ systemPrompt: "base prompt" }) as { systemPrompt: string } | undefined;
+		assert.match(rewritten?.systemPrompt ?? "", /strict structured output contract/);
+	});
+
+	it("evaluates the tool diagnostic against the available tools", () => {
+		assert.equal(evaluateChildToolDiagnostic(baseConfig(), ["read"]), undefined);
+		assert.equal(evaluateChildToolDiagnostic(baseConfig({ requiredTools: ["read"] }), ["read", "write"]), undefined);
+		assert.deepEqual(
+			evaluateChildToolDiagnostic(baseConfig({ agent: "worker", requiredTools: ["read", "mcp_search"], mcpDirectTools: ["mcp_search"] }), ["read"]),
+			{ agent: "worker", required: ["read", "mcp_search"], available: ["read"], missing: ["mcp_search"], missingMcpDirectTools: ["mcp_search"] },
+		);
+	});
+
+	it("derives supervisor metadata only when the channel, run, agent, index, and orchestrator session are all set", () => {
+		assert.equal(childSupervisorMetadata(baseConfig({ supervisorChannelDir: "/tmp/channel", runId: "run-1", agent: "worker" })), undefined);
+		assert.deepEqual(
+			childSupervisorMetadata(baseConfig({
+				supervisorChannelDir: "/tmp/channel",
+				runId: "run-1",
+				agent: "worker",
+				childIndex: 2,
+				orchestratorSessionId: "session-1",
+				orchestratorTarget: "orchestrator",
+				intercomSessionName: "child-target",
+			})),
+			{ channelDir: "/tmp/channel", runId: "run-1", agent: "worker", childIndex: 2, orchestratorTarget: "orchestrator", orchestratorSessionId: "session-1", childTarget: "child-target" },
+		);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/{pi-args-permission-system.test.ts → child-tool-plan-permission-system.test.ts}

@@ -9,11 +9,11 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
+import { buildInProcessChildLaunch, type BuildInProcessChildLaunchInput } from "../../src/runs/shared/child-launch.ts";
 import {
-	buildPiArgs,
 	resolvePermissionSystemExtension,
 	resolvePiLaunchToolPlan,
-} from "../../src/runs/shared/pi-args.ts";
+} from "../../src/runs/shared/child-tool-plan.ts";
 
 const originalEnv = {
 	HOME: process.env.HOME,
@@ -23,7 +23,7 @@ const originalEnv = {
 const tempRoots: string[] = [];
 
 function createFixture() {
-	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-args-perm-"));
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "child-tool-plan-perm-"));
 	tempRoots.push(root);
 	const home = path.join(root, "home");
 	const agentDir = path.join(home, ".selesai", "agent");
@@ -53,12 +53,25 @@ afterEach(() => {
 	tempRoots.length = 0;
 });
 
-function readPromptFile(result: { tempDir?: string }): string {
-	assert.ok(result.tempDir, "expected a temp dir from buildPiArgs");
-	const files = fs.readdirSync(result.tempDir);
-	const promptFile = files.find((f: string) => f.endsWith(".md") && f !== "task.md");
-	assert.ok(promptFile, "expected a prompt.md file");
-	return fs.readFileSync(path.join(result.tempDir, promptFile), "utf-8");
+function childLaunch(overrides: Partial<BuildInProcessChildLaunchInput> = {}): BuildInProcessChildLaunchInput {
+	return {
+		host: "parent",
+		cwd: process.cwd(),
+		sessionEnabled: false,
+		inheritProjectContext: false,
+		inheritGlobalContext: false,
+		inheritSkills: false,
+		childAgentName: "worker",
+		childIndex: 0,
+		...overrides,
+	};
+}
+
+/** The system prompt the child session receives (append mode by default). */
+function childSystemPrompt(result: ReturnType<typeof buildInProcessChildLaunch>): string {
+	const prompt = result.session.systemPrompt ?? result.session.appendSystemPrompt;
+	assert.ok(prompt !== undefined, "expected a child system prompt");
+	return prompt;
 }
 
 function escapeRegExp(value: string): string {
@@ -235,20 +248,11 @@ describe("resolvePiLaunchToolPlan with permission system", () => {
 			JSON.stringify({ name: "test", pi: { extensions: ["./src/index.ts"] } }),
 		);
 
-		const { args } = buildPiArgs({
-			baseArgs: ["-p"],
-			task: "test task",
-			sessionEnabled: false,
-			inheritProjectContext: false,
-			inheritSkills: false,
-		});
-		const extensionArgs = args.filter(
-			(arg, index) => args[index - 1] === "--extension",
-		);
+		const { session } = buildInProcessChildLaunch(childLaunch());
 		assert.equal(
-			extensionArgs.includes(path.join(extDir, "src", "index.ts")),
+			session.extensionPaths.includes(path.join(extDir, "src", "index.ts")),
 			false,
-			"permission system extension should not be emitted without native rules",
+			"permission system extension should not be loaded without native rules",
 		);
 	});
 
@@ -266,20 +270,10 @@ describe("resolvePiLaunchToolPlan with permission system", () => {
 			JSON.stringify({ name: "test", pi: { extensions: ["./src/index.ts"] } }),
 		);
 
-		const { args } = buildPiArgs({
-			baseArgs: ["-p"],
-			task: "test task",
-			sessionEnabled: false,
-			inheritProjectContext: false,
-			inheritSkills: false,
-			permissionRules: { write: "ask" },
-		});
-		const extensionArgs = args.filter(
-			(arg, index) => args[index - 1] === "--extension",
-		);
+		const { session } = buildInProcessChildLaunch(childLaunch({ permissionRules: { write: "ask" } }));
 		assert.ok(
-			extensionArgs.includes(path.join(extDir, "src", "index.ts")),
-			"permission system extension should be emitted when native rules are active",
+			session.extensionPaths.includes(path.join(extDir, "src", "index.ts")),
+			"permission system extension should be loaded when native rules are active",
 		);
 	});
 
@@ -329,23 +323,15 @@ describe("resolvePiLaunchToolPlan with permission system", () => {
 	});
 });
 
-describe("buildPiArgs <active_agent> tag injection", () => {
+describe("child launch <active_agent> tag injection", () => {
 	it("prepends <active_agent> tag when childAgentName is set", () => {
 		const { agentDir } = createFixture();
 		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
 
-		const result = buildPiArgs({
-			baseArgs: ["-p"],
-			task: "test task",
-			sessionEnabled: false,
+		const promptContent = childSystemPrompt(buildInProcessChildLaunch(childLaunch({
 			systemPrompt: "You are a helpful assistant.",
-			inheritProjectContext: false,
-			inheritSkills: false,
 			childAgentName: "reviewer",
-			promptFileStem: "reviewer",
-		});
-
-		const promptContent = readPromptFile(result);
+		})));
 		assert.ok(
 			promptContent.startsWith('<active_agent name="reviewer"/>'),
 			`expected prompt to start with <active_agent> tag, got: ${promptContent.slice(0, 100)}`,
@@ -356,45 +342,29 @@ describe("buildPiArgs <active_agent> tag injection", () => {
 		);
 	});
 
-	it("does NOT inject tag when childAgentName is not set", () => {
+	it("passes no system prompt when the agent has none", () => {
 		const { agentDir } = createFixture();
 		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
 
-		const result = buildPiArgs({
-			baseArgs: ["-p"],
-			task: "test task",
-			sessionEnabled: false,
-			systemPrompt: "You are a helper.",
-			inheritProjectContext: false,
-			inheritSkills: false,
-			promptFileStem: "test",
-		});
-
-		const promptContent = readPromptFile(result);
-		assert.equal(
-			promptContent.includes("<active_agent"),
-			false,
-			"should not inject tag when no childAgentName",
-		);
-		assert.equal(promptContent, "You are a helper.");
+		const { session } = buildInProcessChildLaunch(childLaunch({ childAgentName: "helper" }));
+		assert.equal(session.systemPrompt, undefined);
+		assert.equal(session.appendSystemPrompt, undefined);
 	});
 
-	it("does NOT inject tag when systemPrompt is empty", () => {
+	it("replaces the system prompt in replace mode", () => {
 		const { agentDir } = createFixture();
 		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
 
-		const result = buildPiArgs({
-			baseArgs: ["-p"],
-			task: "test task",
-			sessionEnabled: false,
-			systemPrompt: "",
-			inheritProjectContext: false,
-			inheritSkills: false,
-			childAgentName: "worker",
-			promptFileStem: "worker",
-		});
+		const { session } = buildInProcessChildLaunch(childLaunch({ systemPrompt: "You are a helper.", systemPromptMode: "replace", childAgentName: "helper" }));
+		assert.equal(session.systemPrompt, '<active_agent name="helper"/>\n\nYou are a helper.');
+		assert.equal(session.appendSystemPrompt, undefined);
+	});
+
+	it("injects the tag even when systemPrompt is empty", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
 
-		const promptContent = readPromptFile(result);
+		const promptContent = childSystemPrompt(buildInProcessChildLaunch(childLaunch({ systemPrompt: "", childAgentName: "worker" })));
 		assert.ok(promptContent.startsWith('<active_agent name="worker"/>'));
 	});
 
@@ -402,18 +372,10 @@ describe("buildPiArgs <active_agent> tag injection", () => {
 		const { agentDir } = createFixture();
 		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
 
-		const result = buildPiArgs({
-			baseArgs: ["-p"],
-			task: "test task",
-			sessionEnabled: false,
+		const promptContent = childSystemPrompt(buildInProcessChildLaunch(childLaunch({
 			systemPrompt: "System prompt here",
-			inheritProjectContext: false,
-			inheritSkills: false,
 			childAgentName: 'my "special" agent',
-			promptFileStem: "test",
-		});
-
-		const promptContent = readPromptFile(result);
+		})));
 		assert.ok(
 			promptContent.startsWith('<active_agent name="my &quot;special&quot; agent"/>'),
 			`expected escaped tag, got: ${promptContent.slice(0, 120)}`,
@@ -434,4 +396,4 @@ describe("buildPiArgs <active_agent> tag injection", () => {
 			"prompt runtime extension should always be included",
 		);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/child-tool-plan.test.ts

@@ -0,0 +1,33 @@
+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 { describe, it } from "node:test";
+import { resolvePiLaunchToolPlan } from "../../src/runs/shared/child-tool-plan.ts";
+import { MCP_RUNTIME_SNAPSHOT_EVENT, MCP_RUNTIME_SNAPSHOT_VERSION, type McpRuntimeSnapshotHost } from "../../src/runs/shared/mcp-direct-tool-allowlist.ts";
+
+/** A parent whose pi-mcp-adapter answers snapshot requests for one runtime-only server. */
+function runtimeSnapshotHost(serverName: string): McpRuntimeSnapshotHost {
+	return {
+		events: {
+			emit(event, request) {
+				if (event !== MCP_RUNTIME_SNAPSHOT_EVENT || request.version !== MCP_RUNTIME_SNAPSHOT_VERSION || request.name !== serverName) return;
+				request.result = { ok: true, snapshot: { name: serverName, runtime: true, persisted: false, definition: { command: "node", args: ["server.js"] } } };
+			},
+		},
+	};
+}
+
+describe("child tool plan", () => {
+	it("fails a launch that selects MCP tools from the adapter's runtime snapshot", () => {
+		const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-runtime-mcp-"));
+		try {
+			assert.throws(
+				() => resolvePiLaunchToolPlan({ tools: ["read"], mcpDirectTools: ["runtime-only/search"], cwd, agentName: "browser", runtimeSnapshotHost: runtimeSnapshotHost("runtime-only") }),
+				/cannot be provided to in-process children; MCP tools must come from an ambient adapter extension in a background child/,
+			);
+		} finally {
+			fs.rmSync(cwd, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -19,49 +19,49 @@ describe("async compaction resume", () => {
 			let renders = 0;
 			const pi = new Proxy({
 				events,
-				on(name, handler) { handlers.set(name, handler); },
+				on(name, handler) { handlers.set(name, [...(handlers.get(name) ?? []), handler]); },
 				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
 				sendMessage(message, options) { sent.push({ message, options }); }, getSessionName() { return undefined; },
 			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
 			const ctx = { cwd: process.cwd(), hasUI: true, ui: { setWidget(key, value) { widgets.push([key, value]); }, requestRender() { renders++; }, onTerminalInput() { return () => {}; }, getEditorText() { return ""; }, notify() {}, theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } } }, sessionManager: { getSessionId() { return "compact-session"; }, getSessionFile() { return null; }, getEntries() { return []; } }, modelRegistry: { getAvailable() { return []; } } };
 			registerSubagentExtension(pi);
-			handlers.get("session_start")({}, ctx);
+			for (const handler of handlers.get("session_start")) await handler({}, ctx);
 			sent.length = 0;
 			events.emit("subagent:async-started", { id: "running", pid: 1, sessionId: "compact-session", mode: "single", agent: "worker", asyncDir: path.join(os.tmpdir(), "pi-compaction-test-running") });
 			widgets.length = 0;
 			renders = 0;
-			handlers.get("session_before_compact")({ reason: "threshold", signal: new AbortController().signal });
+			for (const handler of handlers.get("session_before_compact")) await handler({ reason: "threshold", signal: new AbortController().signal });
 			const cleared = widgets.filter(([key, value]) => value === undefined).map(([key]) => key).sort();
 			if (JSON.stringify(cleared) !== JSON.stringify(["subagent-async", "subagent-fleet-status"])) throw new Error(JSON.stringify(widgets));
 			widgets.length = 0;
 			events.emit("subagent:async-complete", { id: "running", sessionId: "compact-session", agent: "worker", success: true, summary: "done" });
 			events.emit("subagent:async-started", { id: "running-2", pid: 2, sessionId: "compact-session", mode: "single", agent: "worker", asyncDir: path.join(os.tmpdir(), "pi-compaction-test-running-2") });
 			if (widgets.length !== 0 || renders !== 0) throw new Error("widgets repainted during compaction");
-			handlers.get("session_compact")({ reason: "threshold" });
+			for (const handler of handlers.get("session_compact")) await handler({ reason: "threshold" });
 			if (widgets.length !== 0) throw new Error("widgets restored inside compaction hook");
-			handlers.get("agent_start")();
+			for (const handler of handlers.get("agent_start")) await handler();
 			const restored = widgets.filter(([_, value]) => value !== undefined).map(([key]) => key).sort();
 			if (JSON.stringify(restored) !== JSON.stringify(["subagent-async", "subagent-fleet-status"])) throw new Error(JSON.stringify(widgets));
 			if (sent.length !== 1 || sent[0].options?.triggerTurn !== true || sent[0].message?.customType !== "subagent-compaction-resume") throw new Error(JSON.stringify(sent));
 
 			sent.length = 0;
 			events.emit("subagent:async-complete", { id: "running-2", sessionId: "compact-session", agent: "worker", success: true, summary: "done" });
-			handlers.get("session_before_compact")({ reason: "threshold", signal: new AbortController().signal });
-			handlers.get("session_compact")({ reason: "threshold" });
-			handlers.get("agent_settled")();
+			for (const handler of handlers.get("session_before_compact")) await handler({ reason: "threshold", signal: new AbortController().signal });
+			for (const handler of handlers.get("session_compact")) await handler({ reason: "threshold" });
+			for (const handler of handlers.get("agent_settled")) await handler();
 			if (sent.some((entry) => entry.message?.customType === "subagent-compaction-resume")) throw new Error("resumed without active work");
 
 			events.emit("subagent:async-started", { id: "running-3", pid: 3, sessionId: "compact-session", mode: "single", agent: "worker", asyncDir: path.join(os.tmpdir(), "pi-compaction-test-running-3") });
 			widgets.length = 0;
-			handlers.get("session_before_compact")({ reason: "overflow", signal: new AbortController().signal });
+			for (const handler of handlers.get("session_before_compact")) await handler({ reason: "overflow", signal: new AbortController().signal });
 			widgets.length = 0;
-			handlers.get("agent_settled")();
+			for (const handler of handlers.get("agent_settled")) await handler();
 			if (!widgets.some(([_, value]) => value !== undefined)) throw new Error("widgets did not recover after compaction failure");
 
 			widgets.length = 0;
-			handlers.get("session_before_compact")({ reason: "manual", signal: new AbortController().signal });
+			for (const handler of handlers.get("session_before_compact")) await handler({ reason: "manual", signal: new AbortController().signal });
 			if (widgets.length !== 0) throw new Error("manual compaction changed widget state");
-			await handlers.get("session_shutdown")();
+			for (const handler of handlers.get("session_shutdown")) await handler();
 		`;
 		const env = { ...process.env };
 		delete env.SELESAI_SUBAGENT_CHILD;
@@ -76,23 +76,23 @@ describe("async compaction resume", () => {
 			const events = { listeners: new Map(), on(name, handler) { this.listeners.set(name, handler); return () => this.listeners.delete(name); }, emit(name, payload) { this.listeners.get(name)?.(payload); } };
 			const pi = new Proxy({
 				events,
-				on(name, handler) { handlers.set(name, handler); },
+				on(name, handler) { handlers.set(name, [...(handlers.get(name) ?? []), handler]); },
 				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
 				sendMessage() {}, getSessionName() { return undefined; },
 			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
 			let stale = false;
 			const ctx = { cwd: process.cwd(), get hasUI() { if (stale) throw new Error("This extension ctx is stale after session replacement or reload."); return true; }, ui: { setWidget() {}, requestRender() {}, onTerminalInput() { return () => {}; }, getEditorText() { return ""; }, notify() {}, theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } } }, sessionManager: { getSessionId() { return "stale-context-session"; }, getSessionFile() { return null; }, getEntries() { return []; } }, modelRegistry: { getAvailable() { return []; } } };
 			registerSubagentExtension(pi);
-			handlers.get("session_start")({}, ctx);
+			for (const handler of handlers.get("session_start")) await handler({}, ctx);
 			events.emit("subagent:async-started", { id: "running", sessionId: "stale-context-session", mode: "single", agent: "worker", asyncDir: "/tmp/pi-stale-context-running" });
 			stale = true;
-			handlers.get("session_compact")({ reason: "threshold" });
-			handlers.get("session_before_compact")({ reason: "threshold", signal: new AbortController().signal });
-			await handlers.get("session_shutdown")();
+			for (const handler of handlers.get("session_compact")) await handler({ reason: "threshold" });
+			for (const handler of handlers.get("session_before_compact")) await handler({ reason: "threshold", signal: new AbortController().signal });
+			for (const handler of handlers.get("session_shutdown")) await handler();
 		`;
 		const env = { ...process.env };
 		delete env.SELESAI_SUBAGENT_CHILD;
 		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
 		assert.ok(true);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/completion-evidence.test.ts

@@ -23,7 +23,7 @@ describe("planCompletionEvidence", () => {
 			implementationMutationExpected: true,
 			mutationAttemptObserved: false,
 			mutationEvidence: evidence,
-			agentContractV1: false,
+			agentContractEnabled: false,
 		});
 
 		assert.equal(plan.guardTriggered, true);
@@ -37,14 +37,14 @@ describe("planCompletionEvidence", () => {
 		});
 	});
 
-	it("keeps agent contract v1 rejection in evidence without forcing execution failure", () => {
+	it("keeps agent contract rejection in evidence without forcing execution failure", () => {
 		const plan = planCompletionEvidence({
 			guard: { expectedMutation: true, attemptedMutation: false, triggered: true, blocked: false },
 			completionGuardEnabled: true,
 			mutationCapable: true,
 			implementationMutationExpected: true,
 			mutationAttemptObserved: false,
-			agentContractV1: true,
+			agentContractEnabled: true,
 		});
 
 		assert.equal(plan.guardTriggered, true);
@@ -59,7 +59,7 @@ describe("planCompletionEvidence", () => {
 			mutationCapable: false,
 			implementationMutationExpected: true,
 			mutationAttemptObserved: true,
-			agentContractV1: false,
+			agentContractEnabled: false,
 		});
 		assert.deepEqual(blocked.fileMutation, {
 			status: "blocked",
@@ -86,7 +86,7 @@ describe("planCompletionEvidence", () => {
 			implementationMutationExpected: true,
 			mutationAttemptObserved: false,
 			arbiterRescued: true,
-			agentContractV1: false,
+			agentContractEnabled: false,
 		});
 		assert.deepEqual(rescued.fileMutation, {
 			status: "not-applicable",
@@ -103,7 +103,7 @@ describe("planCompletionEvidence", () => {
 			mutationCapable: true,
 			implementationMutationExpected: true,
 			mutationAttemptObserved: false,
-			agentContractV1: false,
+			agentContractEnabled: false,
 		});
 		assert.equal(plan.mutationExpected, true);
 		assert.equal(plan.fileMutation, undefined);
@@ -117,7 +117,7 @@ describe("projectSettlementDiagnostic", () => {
 			mutationCapable: true,
 			implementationMutationExpected: true,
 			mutationAttemptObserved: false,
-			agentContractV1: false,
+			agentContractEnabled: false,
 		});
 		assert.deepEqual(projectSettlementDiagnostic(plan, {
 			terminalFailed: true,
@@ -139,7 +139,7 @@ describe("projectSettlementDiagnostic", () => {
 			mutationCapable: false,
 			implementationMutationExpected: false,
 			mutationAttemptObserved: false,
-			agentContractV1: false,
+			agentContractEnabled: false,
 		});
 		assert.equal(projectSettlementDiagnostic(plan, {
 			terminalFailed: false,
@@ -147,4 +147,4 @@ describe("projectSettlementDiagnostic", () => {
 			mutationObserved: false,
 		}), undefined);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/completion-guard.test.ts

@@ -53,7 +53,7 @@ function revivedTask(followUp: string): string {
 		"Original agent: worker",
 		"Original session file: /tmp/session.jsonl",
 		"",
-		"Use the stored session context as background. Answer the orchestrator's follow-up below. Do not assume the original child process is still alive.",
+		"Use the stored session context as background. Answer the orchestrator's follow-up below. Do not assume the original child session is still running.",
 		"",
 		"Follow-up:",
 		followUp,
@@ -241,12 +241,13 @@ test("implementation challenge reports with negated or uncertain no-better-chang
 
 });
 
-test("declared read-only builtin tools suppress implementation-word false positives", () => {
+test("source_check read-only capability suppresses an implementation completion guard", () => {
+	assert.equal(expectsImplementationMutation("worker", "Implement the approved fix"), true);
 	const result = evaluateCompletionMutationGuard({
-		agent: "architect",
-		task: "Produce a proposal that implements the approved fix",
-		messages: [assistantText("Proposal only")],
-		tools: ["read", "grep", "find", "ls"],
+		agent: "worker",
+		task: "Implement the approved fix",
+		messages: [assistantText("Source evidence only")],
+		tools: ["source_check"],
 	});
 
 	assert.deepEqual(result, {
@@ -750,4 +751,4 @@ test("read-only agents and pure extension workers keep their launch contracts",
 		requestedTools: ["read"],
 		completionGuard: false,
 	}), undefined);
-});
+});