@selesai/code 0.8.3 → 0.8.4

package/dist/extensions/pi-subagents/test/unit/project-panes-public-api.test.ts

@@ -0,0 +1,243 @@
+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 {
+	PROJECT_PANES_API_VERSION,
+	PROJECT_PANE_TRUST_STATUS,
+	createProjectPaneManager,
+	openProjectPane,
+	getProjectPaneStatus,
+	closeProjectPane,
+	projectPaneBindingPath,
+	readProjectPaneBinding,
+	type ProjectPaneCommandClient,
+} from "pi-subagents/project-panes";
+
+describe("public project-panes package export", () => {
+	it("exposes the versioned extension-to-extension lifecycle surface", () => {
+		assert.equal(PROJECT_PANES_API_VERSION, 1);
+		assert.equal(PROJECT_PANE_TRUST_STATUS, "human-verification-required");
+		assert.equal(typeof createProjectPaneManager, "function");
+		assert.equal(typeof openProjectPane, "function");
+		assert.equal(typeof getProjectPaneStatus, "function");
+		assert.equal(typeof closeProjectPane, "function");
+		assert.equal(typeof readProjectPaneBinding, "function");
+	});
+
+	it("runs the structured lifecycle and verifies pane ownership before idle close", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-public-project-pane-"));
+		try {
+			const projectRoot = fs.realpathSync(root);
+			const calls: string[][] = [];
+			let opened = false;
+			const client: ProjectPaneCommandClient = {
+				run: async <T>(args: string[]) => {
+					calls.push(args);
+					if (args[0] === "--version") return { ok: true, data: "herdr 0.8.0" as T };
+					if (args[0] === "pane" && args[1] === "split") return { ok: true, data: { pane: { pane_id: "w1:p20" } } as T };
+					if (args[0] === "pane" && args[1] === "run") { opened = true; return { ok: true, data: {} as T }; }
+					if (args[0] === "pane" && args[1] === "get" && opened) return { ok: true, data: { pane: {
+						pane_id: "w1:p20", agent: "pi", agent_status: "IDLE", cwd: projectRoot,
+						foreground_cwd: projectRoot, focused: false, terminal_title_stripped: "Pi · project",
+					} } as T };
+					return { ok: true, data: {} as T };
+				},
+			};
+			const manager = createProjectPaneManager({ client, now: () => new Date("2026-01-01T00:00:00.000Z") });
+			const open = await manager.open({ cwd: root, focus: false });
+			assert.equal(open.ok, true);
+			if (open.ok) {
+				assert.equal(open.data.disposition, "opened");
+				assert.equal(open.data.projectRoot, projectRoot);
+				assert.equal(open.data.trust, "human-verification-required");
+			}
+			const status = await manager.status({ cwd: root });
+			assert.equal(status.ok, true);
+			if (status.ok) {
+				assert.equal(status.data.state, "open");
+				assert.equal(status.data.runtime?.agentStatus, "idle");
+				assert.equal(status.data.ownership, "verified");
+				assert.equal(status.data.safeToClose, true);
+			}
+			const close = await manager.close({ cwd: root, requireIdle: true });
+			assert.equal(close.ok, true);
+			if (close.ok) assert.equal(close.data.disposition, "closed");
+			assert.deepEqual(readProjectPaneBinding(root), { ok: true, data: undefined });
+			assert.ok(calls.some((args) => args.join(" ") === "pane close w1:p20"));
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("distinguishes a stale binding on the default close path", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-public-project-pane-stale-"));
+		try {
+			const projectRoot = fs.realpathSync(root);
+			fs.mkdirSync(path.dirname(projectPaneBindingPath(projectRoot)), { recursive: true });
+			fs.writeFileSync(projectPaneBindingPath(projectRoot), JSON.stringify({
+				schemaVersion: 1, kind: "herdr-project-pane", projectRoot, paneId: "w1:p21",
+				openedAt: "2026-01-01T00:00:00.000Z", command: "pi",
+			}));
+			const client: ProjectPaneCommandClient = {
+				run: async () => ({ ok: false, error: { code: "NOT_FOUND", message: "gone" } }),
+			};
+			const result = await createProjectPaneManager({ client }).close({ cwd: root });
+			assert.equal(result.ok, true);
+			if (result.ok) assert.equal(result.data.disposition, "stale-binding-removed");
+			assert.deepEqual(readProjectPaneBinding(root), { ok: true, data: undefined });
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("returns a structured error when an existing binding cannot be read", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-public-project-pane-read-failure-"));
+		try {
+			const projectRoot = fs.realpathSync(root);
+			const bindingPath = projectPaneBindingPath(projectRoot);
+			fs.mkdirSync(bindingPath, { recursive: true });
+			const binding = readProjectPaneBinding(projectRoot);
+			assert.equal(binding.ok, false);
+			if (!binding.ok) {
+				assert.equal(binding.error.code, "BINDING_READ_FAILED");
+				assert.equal(binding.error.bindingPath, bindingPath);
+			}
+			let clientCalled = false;
+			const manager = createProjectPaneManager({ client: { run: async () => { clientCalled = true; return { ok: true, data: {} }; } } });
+			const status = await manager.status({ cwd: root });
+			assert.equal(status.ok, false);
+			if (!status.ok) {
+				assert.equal(status.error.code, "BINDING_READ_FAILED");
+				assert.equal(status.error.bindingPath, bindingPath);
+				assert.match(status.error.message, /Failed to read project pane binding/);
+				assert.match(String((status.error.details as { code?: unknown }).code), /EISDIR|EPERM|EACCES/);
+			}
+			assert.equal(clientCalled, false);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("returns a structured error and closes the pane when binding persistence fails", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-public-project-pane-write-failure-"));
+		try {
+			fs.mkdirSync(path.join(root, ".selesai"));
+			fs.writeFileSync(path.join(root, ".pi-subagents"), "directory collision");
+			const calls: string[][] = [];
+			const client: ProjectPaneCommandClient = {
+				run: async <T>(args: string[]) => {
+					calls.push(args);
+					if (args[0] === "--version") return { ok: true, data: "herdr 0.8.0" as T };
+					if (args[1] === "split") return { ok: true, data: { pane: { pane_id: "w1:p24" } } as T };
+					return { ok: true, data: {} as T };
+				},
+			};
+			const result = await createProjectPaneManager({ client }).open({ cwd: root, focus: false });
+			assert.equal(result.ok, false);
+			if (!result.ok) {
+				assert.equal(result.error.code, "BINDING_WRITE_FAILED");
+				assert.equal(result.error.bindingPath, projectPaneBindingPath(fs.realpathSync(root)));
+				assert.match(result.error.message, /newly opened pane 'w1:p24' was closed/);
+			}
+			assert.ok(calls.some((args) => args.join(" ") === "pane close w1:p24"));
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("returns a structured error when binding removal fails after closing the pane", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-public-project-pane-remove-failure-"));
+		try {
+			const projectRoot = fs.realpathSync(root);
+			const bindingPath = projectPaneBindingPath(projectRoot);
+			fs.mkdirSync(path.dirname(bindingPath), { recursive: true });
+			fs.writeFileSync(bindingPath, JSON.stringify({
+				schemaVersion: 1, kind: "herdr-project-pane", projectRoot, paneId: "w1:p25",
+				openedAt: "2026-01-01T00:00:00.000Z", command: "pi",
+			}));
+			const client: ProjectPaneCommandClient = {
+				run: async <T>(args: string[]) => {
+					if (args.join(" ") === "pane close w1:p25") {
+						fs.rmSync(bindingPath);
+						fs.mkdirSync(bindingPath);
+					}
+					return { ok: true, data: {} as T };
+				},
+			};
+			const result = await createProjectPaneManager({ client }).close({ cwd: root });
+			assert.equal(result.ok, false);
+			if (!result.ok) {
+				assert.equal(result.error.code, "BINDING_REMOVE_FAILED");
+				assert.equal(result.error.bindingPath, bindingPath);
+			}
+			assert.equal(fs.statSync(bindingPath).isDirectory(), true);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects idle close when Herdr pane ownership no longer matches the project", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-public-project-pane-owner-"));
+		const other = fs.mkdtempSync(path.join(os.tmpdir(), "pi-public-project-pane-other-"));
+		try {
+			const projectRoot = fs.realpathSync(root);
+			fs.mkdirSync(path.dirname(projectPaneBindingPath(projectRoot)), { recursive: true });
+			fs.writeFileSync(projectPaneBindingPath(projectRoot), JSON.stringify({
+				schemaVersion: 1, kind: "herdr-project-pane", projectRoot, paneId: "w1:p22",
+				openedAt: "2026-01-01T00:00:00.000Z", command: "pi",
+			}));
+			let closeCalled = false;
+			const client: ProjectPaneCommandClient = {
+				run: async <T>(args: string[]) => {
+					if (args[0] === "--version") return { ok: true, data: "herdr 0.8.0" as T };
+					if (args[1] === "get") return { ok: true, data: { pane: { pane_id: "w1:p22", agent_status: "idle", cwd: other } } as T };
+					if (args[1] === "close") closeCalled = true;
+					return { ok: true, data: {} as T };
+				},
+			};
+			const manager = createProjectPaneManager({ client });
+			const open = await manager.open({ cwd: root });
+			assert.equal(open.ok, false);
+			if (!open.ok) assert.equal(open.error.code, "PANE_OWNERSHIP_UNVERIFIED");
+			const result = await manager.close({ cwd: root, requireIdle: true });
+			assert.equal(result.ok, false);
+			if (!result.ok) assert.equal(result.error.code, "PANE_OWNERSHIP_UNVERIFIED");
+			assert.equal(closeCalled, false);
+			const binding = readProjectPaneBinding(root);
+			assert.equal(binding.ok, true);
+			if (binding.ok) assert.equal(binding.data?.paneId, "w1:p22");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+			fs.rmSync(other, { recursive: true, force: true });
+		}
+	});
+
+	it("does not expose or lifecycle-manage malformed public bindings as if they were absent", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-public-project-pane-binding-"));
+		try {
+			const projectRoot = fs.realpathSync(root);
+			fs.mkdirSync(path.dirname(projectPaneBindingPath(projectRoot)), { recursive: true });
+			fs.writeFileSync(projectPaneBindingPath(projectRoot), JSON.stringify({
+				schemaVersion: 1, kind: "herdr-project-pane", projectRoot, paneId: "w1:p23",
+				openedAt: "2026-01-01T00:00:00.000Z", command: "pi", startupMessage: 42,
+			}));
+			const binding = readProjectPaneBinding(root);
+			assert.equal(binding.ok, false);
+			if (!binding.ok) assert.equal(binding.error.code, "INVALID_BINDING");
+			let clientCalled = false;
+			const manager = createProjectPaneManager({ client: { run: async () => { clientCalled = true; return { ok: true, data: {} }; } } });
+			const status = await manager.status({ cwd: root });
+			assert.equal(status.ok, false);
+			if (!status.ok) assert.equal(status.error.code, "INVALID_BINDING");
+			const close = await manager.close({ cwd: root });
+			assert.equal(close.ok, false);
+			if (!close.ok) assert.equal(close.error.code, "INVALID_BINDING");
+			assert.equal(clientCalled, false);
+			assert.equal(fs.existsSync(projectPaneBindingPath(projectRoot)), true);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/prompt-template-bridge.test.ts

@@ -25,8 +25,7 @@ class FakeEvents implements PromptTemplateBridgeEvents {
 	}
 
 	emit(event: string, data: unknown): void {
-		const list = this.handlers.get(event) ?? [];
-		for (const handler of [...list]) handler(data);
+		for (const handler of [...this.handlers.get(event) ?? []]) handler(data);
 	}
 }
 
@@ -39,21 +38,36 @@ function once(events: FakeEvents, event: string): Promise<unknown> {
 	});
 }
 
+function structuredRequest(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+	return {
+		requestId: "r1",
+		ownerRunId: "owner-1",
+		nodeId: "node-1",
+		agent: "worker",
+		task: "do work",
+		context: "fresh",
+		model: "openai/gpt-5",
+		cwd: "/repo",
+		result: { kind: "text" },
+		...overrides,
+	};
+}
+
 describe("prompt-template delegation bridge", () => {
-	it("emits started/update/response on successful request", async () => {
+	it("emits started/update/response on successful structured request", async () => {
 		const events = new FakeEvents();
 		let executeCalls = 0;
 		const bridge = registerPromptTemplateDelegationBridge({
 			events,
 			getContext: () => ({ cwd: "/repo" }),
-			execute: async (_requestId, _request, _signal, _ctx, onUpdate) => {
+			executeStructured: async (_requestId, _request, _signal, _ctx, onUpdate) => {
 				executeCalls++;
 				onUpdate({
 					details: {
-						results: [{ agent: "builder", model: "openai/gpt-5-mini" }],
+						results: [{ agent: "worker", model: "openai/gpt-5-mini" }],
 						progress: [{
 							index: 0,
-							agent: "builder",
+							agent: "worker",
 							currentTool: "read",
 							currentToolArgs: "src/extension/index.ts",
 							recentOutput: ["line 1"],
@@ -66,30 +80,26 @@ describe("prompt-template delegation bridge", () => {
 				});
 				return {
 					details: {
-						results: [{ messages: [{ role: "assistant", content: [{ type: "text", text: "ok" }] }] }],
+						results: [{ agent: "worker", finalOutput: "ok", exitCode: 0 }],
 					},
 				};
 			},
+			execute: async () => { throw new Error("structured request should use executeStructured"); },
 		});
 
 		const startedPromise = once(events, PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT);
 		const updatePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT);
 		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
 
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r1",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, structuredRequest());
 
-		const started = await startedPromise as { requestId: string };
-		assert.equal(started.requestId, "r1");
+		const started = await startedPromise as { requestId: string; ownerRunId: string; nodeId: string };
+		assert.deepEqual(started, { requestId: "r1", ownerRunId: "owner-1", nodeId: "node-1" });
 
 		const update = await updatePromise as {
 			requestId: string;
+			ownerRunId: string;
+			nodeId: string;
 			currentTool?: string;
 			toolCount?: number;
 			recentOutputLines?: string[];
@@ -98,107 +108,24 @@ describe("prompt-template delegation bridge", () => {
 			taskProgress?: Array<{ model?: string }>;
 		};
 		assert.equal(update.requestId, "r1");
+		assert.equal(update.ownerRunId, "owner-1");
+		assert.equal(update.nodeId, "node-1");
 		assert.equal(update.currentTool, "read");
 		assert.equal(update.toolCount, 1);
 		assert.deepEqual(update.recentOutputLines, ["line 1"]);
 		assert.deepEqual(update.recentTools, [{ tool: "read", args: '{"path":"src/extension/index.ts"}' }]);
-		assert.equal(update.model, "openai/gpt-5-mini");
-		assert.equal(update.taskProgress?.[0]?.model, "openai/gpt-5-mini");
 
-		const response = await responsePromise as { requestId: string; isError: boolean; messages: unknown[] };
+		const response = await responsePromise as { requestId: string; ownerRunId: string; nodeId: string; status: string; result?: { kind: string; text?: string } };
 		assert.equal(response.requestId, "r1");
-		assert.equal(response.isError, false);
-		assert.equal(Array.isArray(response.messages), true);
+		assert.equal(response.ownerRunId, "owner-1");
+		assert.equal(response.nodeId, "node-1");
+		assert.equal(response.status, "completed");
+		assert.deepEqual(response.result, { kind: "text", text: "ok" });
 		assert.equal(executeCalls, 1);
 
 		bridge.dispose();
 	});
 
-	it("rebuilds compact tool-call summaries into delegated response messages", async () => {
-		const events = new FakeEvents();
-		const bridge = registerPromptTemplateDelegationBridge({
-			events,
-			getContext: () => ({ cwd: "/repo" }),
-			execute: async () => ({
-				details: {
-					results: [{
-						finalOutput: "finished",
-						toolCalls: [
-							{ text: "write src/output.md", expandedText: "write src/output.md" },
-							{ text: "edit src/output.md", expandedText: "edit src/output.md" },
-						],
-					}],
-				},
-			}),
-		});
-
-		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r-compact-tools",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
-
-		const response = await responsePromise as { messages: Array<{ role?: string; content?: Array<{ type?: string; name?: string; text?: string }> }> };
-		assert.equal(response.messages.length, 1);
-		assert.equal(response.messages[0]?.role, "assistant");
-		assert.deepEqual(
-			response.messages[0]?.content?.filter((part) => part.type === "toolCall").map((part) => part.name),
-			["write", "edit"],
-		);
-		assert.equal(response.messages[0]?.content?.some((part) => part.type === "text" && part.text === "finished"), true);
-
-		bridge.dispose();
-	});
-
-	it("filters malformed recent output entries in updates", async () => {
-		const events = new FakeEvents();
-		const bridge = registerPromptTemplateDelegationBridge({
-			events,
-			getContext: () => ({ cwd: "/repo" }),
-			execute: async (_requestId, _request, _signal, _ctx, onUpdate) => {
-				onUpdate({
-					details: {
-						results: [{ agent: "builder", model: "openai/gpt-5-mini" }],
-						progress: [{
-							index: 0,
-							agent: "builder",
-							recentOutput: ["line 1", 123 as unknown as string],
-						}],
-					},
-				});
-				return { details: { results: [{ messages: [] }] } };
-			},
-		});
-
-		const updatePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT);
-		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r-malformed-output",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
-
-		const update = await updatePromise as {
-			recentOutput?: string;
-			recentOutputLines?: string[];
-			taskProgress?: Array<{ recentOutput?: string; recentOutputLines?: string[] }>;
-		};
-		assert.equal(update.recentOutput, undefined);
-		assert.deepEqual(update.recentOutputLines, ["line 1"]);
-		assert.equal(update.taskProgress?.[0]?.recentOutput, undefined);
-		assert.deepEqual(update.taskProgress?.[0]?.recentOutputLines, ["line 1"]);
-
-		await responsePromise;
-		bridge.dispose();
-	});
-
 	it("returns structured error when no active context", async () => {
 		const events = new FakeEvents();
 		const bridge = registerPromptTemplateDelegationBridge({
@@ -208,113 +135,86 @@ describe("prompt-template delegation bridge", () => {
 		});
 
 		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r2",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, structuredRequest({ requestId: "r2" }));
 
-		const response = await responsePromise as { isError: boolean; errorText?: string };
-		assert.equal(response.isError, true);
-		assert.match(response.errorText ?? "", /No active extension context/);
+		const response = await responsePromise as { status: string; error?: string };
+		assert.equal(response.status, "unavailable_context");
+		assert.match(response.error ?? "", /No active extension context/);
 
 		bridge.dispose();
 	});
 
-	it("accepts requests when delegated cwd differs from active context", async () => {
+	it("applies pending cancel when cancel arrives before structured request", async () => {
 		const events = new FakeEvents();
-		let executeCwd: string | undefined;
+		let executeCalls = 0;
 		const bridge = registerPromptTemplateDelegationBridge({
 			events,
-			getContext: () => ({ cwd: "/actual" }),
-			execute: async (_requestId, request) => {
-				executeCwd = request.cwd;
+			getContext: () => ({ cwd: "/repo" }),
+			execute: async () => {
+				executeCalls++;
 				return { details: { results: [{ messages: [] }] } };
 			},
 		});
 
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, { requestId: "r4", ownerRunId: "owner-1", nodeId: "node-1" });
 		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r3",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, structuredRequest({ requestId: "r4" }));
 
-		const response = await responsePromise as { isError: boolean; errorText?: string };
-		assert.equal(response.isError, false);
-		assert.equal(executeCwd, "/repo");
+		const response = await responsePromise as { status: string };
+		assert.equal(response.status, "cancelled");
+		assert.equal(executeCalls, 0);
 
 		bridge.dispose();
 	});
 
-	it("applies pending cancel when cancel arrives before request", async () => {
+	it("cancels in-flight structured delegated execution", async () => {
 		const events = new FakeEvents();
-		let executeCalls = 0;
 		const bridge = registerPromptTemplateDelegationBridge({
 			events,
 			getContext: () => ({ cwd: "/repo" }),
-			execute: async () => {
-				executeCalls++;
-				return { details: { results: [{ messages: [] }] } };
-			},
+			execute: async (_requestId, _request, signal) =>
+				await new Promise((_resolve, reject) => {
+					signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
+				}),
 		});
 
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, { requestId: "r4" });
+		const startedPromise = once(events, PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT);
 		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
 
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r4",
-			agent: "builder",
-			task: "do work",
-			context: "fresh",
-			model: "openai/gpt-5",
-			cwd: "/repo",
-		});
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, structuredRequest({ requestId: "r5" }));
 
-		const response = await responsePromise as { isError: boolean; errorText?: string };
-		assert.equal(response.isError, true);
-		assert.equal(response.errorText, "Delegated prompt cancelled.");
-		assert.equal(executeCalls, 0);
+		await startedPromise;
+		events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, { requestId: "r5", ownerRunId: "owner-1", nodeId: "node-1" });
+
+		const response = await responsePromise as { status: string; error?: string };
+		assert.equal(response.status, "cancelled");
 
 		bridge.dispose();
 	});
 
-	it("cancels in-flight delegated execution", async () => {
+	it("rejects legacy direct payloads without executor dispatch", async () => {
 		const events = new FakeEvents();
+		let executeCalls = 0;
 		const bridge = registerPromptTemplateDelegationBridge({
 			events,
 			getContext: () => ({ cwd: "/repo" }),
-			execute: async (_requestId, _request, signal) =>
-				await new Promise((_resolve, reject) => {
-					signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
-				}),
+			execute: async () => { executeCalls++; return {}; },
 		});
 
-		const startedPromise = once(events, PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT);
 		const responsePromise = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
-
 		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
-			requestId: "r5",
-			agent: "builder",
+			requestId: "legacy-1",
+			agent: "worker",
 			task: "do work",
 			context: "fresh",
 			model: "openai/gpt-5",
 			cwd: "/repo",
 		});
 
-		await startedPromise;
-		events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, { requestId: "r5" });
-
 		const response = await responsePromise as { isError: boolean; errorText?: string };
 		assert.equal(response.isError, true);
-		assert.match(response.errorText ?? "", /aborted/i);
-
+		assert.match(response.errorText ?? "", /Legacy prompt-template direct delegation was removed/);
+		assert.equal(executeCalls, 0);
 		bridge.dispose();
 	});
 
@@ -330,7 +230,7 @@ describe("prompt-template delegation bridge", () => {
 		const tasksResponse = once(events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT);
 		events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, {
 			requestId: "r6",
-			tasks: [{ agent: "builder-a", task: "A" }],
+			tasks: [{ agent: "worker-a", task: "A" }],
 			context: "fresh",
 			model: "openai/gpt-5",
 			cwd: "/repo",