@selesai/code 0.5.19 → 0.5.21

package/dist/extensions/pi-subagents/src/slash/prompt-template-bridge.ts

@@ -1,288 +1,67 @@
-export const PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = "prompt-template:subagent:request";
-export const PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = "prompt-template:subagent:started";
-export const PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT = "prompt-template:subagent:response";
-export const PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT = "prompt-template:subagent:update";
-export const PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT = "prompt-template:subagent:cancel";
+import {
+	SUBAGENT_DELEGATION_CANCEL_EVENT,
+	SUBAGENT_DELEGATION_PROTOCOL_VERSION,
+	SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+	SUBAGENT_DELEGATION_REQUEST_EVENT,
+	SUBAGENT_DELEGATION_RESPONSE_EVENT,
+	SUBAGENT_DELEGATION_STARTED_EVENT,
+	SUBAGENT_DELEGATION_UPDATE_EVENT,
+	type SubagentDelegationRequest,
+	type SubagentDelegationResponse,
+	type SubagentDelegationV2InvalidResponse,
+	type SubagentDelegationV2Request,
+	type SubagentDelegationV2Response,
+} from "../api/delegation.ts";
+import { parseSubagentDelegationRequest } from "./delegation-request.ts";
+import {
+	parsePromptTemplateRequest,
+	toDelegationUpdate,
+	toLegacyExecutionParams,
+	toPromptTemplateResponse,
+	toSubagentDelegationExecutionParams,
+	toSubagentDelegationResponse,
+	toSubagentDelegationUpdate,
+	toSubagentDelegationV2ExecutionParams,
+	toSubagentDelegationV2Response,
+	toSubagentDelegationV2Update,
+	type DelegatedSubagentExecutionParams,
+	type PromptTemplateBridgeResult,
+	type PromptTemplateDelegationRequest,
+	type PromptTemplateDelegationResponse,
+} from "./delegation-adapters.ts";
 
-interface PromptTemplateDelegationTask {
-	agent: string;
-	task: string;
-	model?: string;
-	cwd?: string;
-}
-
-interface PromptTemplateDelegationParallelResult {
-	agent: string;
-	messages: unknown[];
-	isError: boolean;
-	errorText?: string;
-}
-
-interface PromptTemplateDelegationRequest {
-	requestId: string;
-	agent: string;
-	task: string;
-	tasks?: PromptTemplateDelegationTask[];
-	context: "fresh" | "fork";
-	model: string;
-	cwd: string;
-	worktree?: boolean;
-}
-
-interface PromptTemplateDelegationResponse extends PromptTemplateDelegationRequest {
-	messages: unknown[];
-	parallelResults?: PromptTemplateDelegationParallelResult[];
-	contentText?: string;
-	isError: boolean;
-	errorText?: string;
-}
-
-interface PromptTemplateDelegationTaskProgress {
-	index?: number;
-	agent: string;
-	status?: string;
-	currentTool?: string;
-	currentToolArgs?: string;
-	recentOutput?: string;
-	recentOutputLines?: string[];
-	recentTools?: Array<{ tool: string; args: string }>;
-	model?: string;
-	toolCount?: number;
-	durationMs?: number;
-	tokens?: number;
-}
-
-interface PromptTemplateDelegationUpdate {
-	requestId: string;
-	currentTool?: string;
-	currentToolArgs?: string;
-	recentOutput?: string;
-	recentOutputLines?: string[];
-	recentTools?: Array<{ tool: string; args: string }>;
-	model?: string;
-	toolCount?: number;
-	durationMs?: number;
-	tokens?: number;
-	taskProgress?: PromptTemplateDelegationTaskProgress[];
-}
+export const PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = SUBAGENT_DELEGATION_REQUEST_EVENT;
+export const PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = SUBAGENT_DELEGATION_STARTED_EVENT;
+export const PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT = SUBAGENT_DELEGATION_RESPONSE_EVENT;
+export const PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT = SUBAGENT_DELEGATION_UPDATE_EVENT;
+export const PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT = SUBAGENT_DELEGATION_CANCEL_EVENT;
 
 export interface PromptTemplateBridgeEvents {
 	on(event: string, handler: (data: unknown) => void): (() => void) | void;
 	emit(event: string, data: unknown): void;
 }
 
-interface PromptTemplateBridgeResult {
-	isError?: boolean;
-	content?: unknown;
-	details?: {
-		results?: Array<{
-			agent?: string;
-			messages?: unknown[];
-			finalOutput?: string;
-			toolCalls?: Array<{ text?: string; expandedText?: string }>;
-			exitCode?: number;
-			error?: string;
-			model?: string;
-		}>;
-		progress?: Array<{
-			index?: number;
-			agent?: string;
-			status?: string;
-			currentTool?: string;
-			currentToolArgs?: string;
-			recentOutput?: string[];
-			recentTools?: Array<{ tool?: string; args?: string }>;
-			toolCount?: number;
-			durationMs?: number;
-			tokens?: number;
-		}>;
-	};
-}
-
 interface PromptTemplateBridgeOptions<Ctx extends { cwd?: string }> {
 	events: PromptTemplateBridgeEvents;
 	getContext: () => Ctx | null;
 	execute: (
 		requestId: string,
-		request: PromptTemplateDelegationRequest,
+		params: DelegatedSubagentExecutionParams,
+		signal: AbortSignal,
+		ctx: Ctx,
+		onUpdate: (result: PromptTemplateBridgeResult) => void,
+	) => Promise<PromptTemplateBridgeResult>;
+	/**
+	 * Concurrent-safe executor for strict versioned delegation requests.
+	 * Non-versioned prompt-template requests retain the ordinary single-dispatch guard.
+	 */
+	executeVersioned?: (
+		requestId: string,
+		params: DelegatedSubagentExecutionParams,
 		signal: AbortSignal,
 		ctx: Ctx,
 		onUpdate: (result: PromptTemplateBridgeResult) => void,
 	) => Promise<PromptTemplateBridgeResult>;
-}
-
-function parseDelegationTasks(tasks: unknown): PromptTemplateDelegationTask[] {
-	if (!Array.isArray(tasks)) return [];
-	const parsed: PromptTemplateDelegationTask[] = [];
-	for (const item of tasks) {
-		if (!item || typeof item !== "object") return [];
-		const value = item as Partial<PromptTemplateDelegationTask>;
-		if (typeof value.agent !== "string" || !value.agent.trim()) return [];
-		if (typeof value.task !== "string" || !value.task.trim()) return [];
-		const model = typeof value.model === "string" && value.model.trim().length > 0 ? value.model : undefined;
-		const cwd = typeof value.cwd === "string" && value.cwd.trim().length > 0 ? value.cwd : undefined;
-		parsed.push({
-			agent: value.agent,
-			task: value.task,
-			...(model ? { model } : {}),
-			...(cwd ? { cwd } : {}),
-		});
-	}
-	return parsed;
-}
-
-function parsePromptTemplateRequest(data: unknown): PromptTemplateDelegationRequest | undefined {
-	if (!data || typeof data !== "object") return undefined;
-	const value = data as Partial<PromptTemplateDelegationRequest> & { tasks?: unknown };
-	if (typeof value.requestId !== "string" || !value.requestId) return undefined;
-	if (typeof value.model !== "string" || !value.model) return undefined;
-	if (typeof value.cwd !== "string" || !value.cwd) return undefined;
-	if (value.context !== "fresh" && value.context !== "fork") return undefined;
-	const tasks = parseDelegationTasks(value.tasks);
-	const worktree = value.worktree === true ? true : undefined;
-	const hasSingle =
-		typeof value.agent === "string" &&
-		value.agent.length > 0 &&
-		typeof value.task === "string" &&
-		value.task.length > 0;
-	if (!hasSingle && tasks.length === 0) return undefined;
-
-	const fallbackTask = tasks[0];
-	return {
-		requestId: value.requestId,
-		agent: hasSingle ? value.agent : fallbackTask!.agent,
-		task: hasSingle ? value.task : fallbackTask!.task,
-		...(tasks.length > 0 ? { tasks } : {}),
-		context: value.context,
-		model: value.model,
-		cwd: value.cwd,
-		...(worktree ? { worktree } : {}),
-	};
-}
-
-function firstTextContent(content: unknown): string | undefined {
-	if (!Array.isArray(content)) return undefined;
-	for (const part of content) {
-		if (!part || typeof part !== "object") continue;
-		if ((part as { type?: string }).type !== "text") continue;
-		const text = (part as { text?: unknown }).text;
-		if (typeof text === "string" && text.trim()) return text.trim();
-	}
-	return undefined;
-}
-
-function filterRecentOutput(lines: string[] | undefined): string[] | undefined {
-	if (!lines || lines.length === 0) return undefined;
-	const filtered = lines.filter((line) => typeof line === "string" && line.trim() && line.trim() !== "(running...)");
-	if (filtered.length === 0) return undefined;
-	return filtered;
-}
-
-function sanitizeRecentTools(
-	tools: Array<{ tool?: string; args?: string }> | undefined,
-): Array<{ tool: string; args: string }> | undefined {
-	if (!tools || tools.length === 0) return undefined;
-	const sanitized = tools.flatMap((entry) => {
-		if (typeof entry.tool !== "string" || entry.tool.trim().length === 0) return [];
-		return [{
-			tool: entry.tool,
-			args: typeof entry.args === "string" ? entry.args : String(entry.args ?? ""),
-		}];
-	});
-	return sanitized.length > 0 ? sanitized : undefined;
-}
-
-function resolveProgressModel(
-	update: PromptTemplateBridgeResult,
-	entry: { index?: number; agent?: string },
-): string | undefined {
-	const results = update.details?.results;
-	if (!results || results.length === 0) return undefined;
-	if (typeof entry.index === "number" && entry.index >= 0) {
-		const byIndex = results[entry.index];
-		if (typeof byIndex?.model === "string") return byIndex.model;
-	}
-	if (entry.agent) {
-		const byAgent = results.find((result) => result.agent === entry.agent && typeof result.model === "string");
-		if (byAgent?.model) return byAgent.model;
-	}
-	const firstWithModel = results.find((result) => typeof result.model === "string");
-	return firstWithModel?.model;
-}
-
-function toolCallNameFromSummary(summary: { text?: string; expandedText?: string }): string | undefined {
-	const text = typeof summary.expandedText === "string" && summary.expandedText.trim().length > 0
-		? summary.expandedText.trim()
-		: typeof summary.text === "string"
-			? summary.text.trim()
-			: "";
-	if (!text) return undefined;
-	if (text.startsWith("$ ")) return "bash";
-	return text.match(/^[A-Za-z_][\w.-]*/)?.[0];
-}
-
-function buildDelegationMessages(
-	result: { messages?: unknown[]; finalOutput?: string; toolCalls?: Array<{ text?: string; expandedText?: string }> },
-	fallbackText?: string,
-): unknown[] {
-	if (Array.isArray(result.messages) && result.messages.length > 0) return result.messages;
-	const toolCallParts = (result.toolCalls ?? []).flatMap((summary) => {
-		const name = toolCallNameFromSummary(summary);
-		return name ? [{ type: "toolCall", name, arguments: { summary: summary.expandedText ?? summary.text ?? "" } }] : [];
-	});
-	const text = typeof result.finalOutput === "string" && result.finalOutput.trim().length > 0
-		? result.finalOutput.trim()
-		: fallbackText;
-	const content = [
-		...toolCallParts,
-		...(text ? [{ type: "text", text }] : []),
-	];
-	if (content.length === 0) return [];
-	return [{ role: "assistant", content }];
-}
-
-function toDelegationUpdate(requestId: string, update: PromptTemplateBridgeResult): PromptTemplateDelegationUpdate | undefined {
-	const progress = update.details?.progress?.[0];
-	const taskProgress = update.details?.progress?.map((entry) => {
-		const lastOutput = entry.recentOutput?.[entry.recentOutput.length - 1];
-		const safeLastOutput =
-			typeof lastOutput === "string" && lastOutput.trim() && lastOutput !== "(running...)"
-				? lastOutput
-				: undefined;
-		return {
-			index: entry.index,
-			agent: entry.agent ?? "delegate",
-			status: entry.status,
-			currentTool: entry.currentTool,
-			currentToolArgs: entry.currentToolArgs,
-			recentOutput: safeLastOutput,
-			recentOutputLines: filterRecentOutput(entry.recentOutput),
-			recentTools: sanitizeRecentTools(entry.recentTools),
-			model: resolveProgressModel(update, entry),
-			toolCount: entry.toolCount,
-			durationMs: entry.durationMs,
-			tokens: entry.tokens,
-		};
-	});
-	if (!progress && (!taskProgress || taskProgress.length === 0)) return undefined;
-	const lastOutput = progress?.recentOutput?.[progress.recentOutput.length - 1];
-	const safeLastOutput =
-		typeof lastOutput === "string" && lastOutput.trim() && lastOutput !== "(running...)"
-			? lastOutput
-			: undefined;
-	return {
-		requestId,
-		currentTool: progress?.currentTool,
-		currentToolArgs: progress?.currentToolArgs,
-		recentOutput: safeLastOutput,
-		recentOutputLines: filterRecentOutput(progress?.recentOutput),
-		recentTools: sanitizeRecentTools(progress?.recentTools),
-		model: progress ? resolveProgressModel(update, progress) : undefined,
-		toolCount: progress?.toolCount,
-		durationMs: progress?.durationMs,
-		tokens: progress?.tokens,
-		taskProgress,
-	};
 }
 
 export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: string }>(
@@ -291,130 +70,359 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 	cancelAll: () => void;
 	dispose: () => void;
 } {
+	// Legacy and V1 retain requestId-only correlation. V2 attempts are isolated by
+	// their complete wire identity, while logical-node ownership is tracked separately.
 	const controllers = new Map<string, AbortController>();
-	const pendingCancels = new Set<string>();
+	const pendingCancels = new Map<string, true>();
+	const v2Controllers = new Map<string, AbortController>();
+	const pendingV2Cancels = new Map<string, true>();
+	const activeV2Nodes = new Map<string, { attemptKey: string; controller: AbortController }>();
+	const settledV2Attempts = new Map<string, true>();
 	const subscriptions: Array<() => void> = [];
+	let disposed = false;
+	let v2IdentitySaturated = false;
 
 	const subscribe = (event: string, handler: (data: unknown) => void): void => {
 		const unsubscribe = options.events.on(event, handler);
 		if (typeof unsubscribe === "function") subscriptions.push(unsubscribe);
 	};
+	const ownsRequest = (requestId: string, controller: AbortController): boolean =>
+		!disposed && controllers.get(requestId) === controller;
+	const ownsV2Attempt = (attemptKey: string, controller: AbortController): boolean =>
+		!disposed && v2Controllers.get(attemptKey) === controller;
+	const boundedRemember = (map: Map<string, true>, key: string): void => {
+		map.delete(key);
+		map.set(key, true);
+		while (map.size > 256) {
+			const oldest = map.keys().next().value;
+			if (typeof oldest !== "string") break;
+			map.delete(oldest);
+		}
+	};
+	const rememberV2Identity = (map: Map<string, true>, key: string): void => {
+		if (map.has(key) || v2IdentitySaturated) return;
+		if (map.size >= 8_192) {
+			v2IdentitySaturated = true;
+			return;
+		}
+		map.set(key, true);
+		if (map.size === 8_192) {
+			// V2 identity facts are security state, not an LRU cache. Saturate as
+			// soon as the bounded history fills so no later untracked attempt can
+			// start, rather than evicting a cancellation or settled-attempt fact.
+			v2IdentitySaturated = true;
+		}
+	};
+	const v2NodeKey = (ownerRunId: string, nodeId: string): string => JSON.stringify([ownerRunId, nodeId]);
+	const v2AttemptKey = (requestId: string, ownerRunId: string, nodeId: string): string => JSON.stringify([requestId, ownerRunId, nodeId]);
+	const rememberPendingCancel = (requestId: string): void => {
+		boundedRemember(pendingCancels, requestId);
+	};
+	const emitV2Terminal = (attemptKey: string, payload: SubagentDelegationV2Response): void => {
+		if (disposed || settledV2Attempts.has(attemptKey)) return;
+		rememberV2Identity(settledV2Attempts, attemptKey);
+		options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, payload);
+	};
 
 	subscribe(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, (data) => {
-		if (!data || typeof data !== "object") return;
-		const requestId = (data as { requestId?: unknown }).requestId;
-		if (typeof requestId !== "string") return;
+		if (!data || typeof data !== "object" || Array.isArray(data)) return;
+		const value = data as Record<string, unknown>;
+		const requestId = value.requestId;
+		if (typeof requestId !== "string" || !requestId.trim() || requestId.length > 256 || /[\r\n]/.test(requestId)) return;
+		if (Object.hasOwn(value, "version")) {
+			if (value.version === SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION) {
+				if (Object.keys(value).some((key) => key !== "version" && key !== "requestId" && key !== "ownerRunId" && key !== "nodeId")) return;
+				const ownerRunId = value.ownerRunId;
+				const nodeId = value.nodeId;
+				if (typeof ownerRunId !== "string" || !ownerRunId.trim() || ownerRunId.length > 256 || /[\r\n]/.test(ownerRunId)) return;
+				if (typeof nodeId !== "string" || !nodeId.trim() || nodeId.length > 256 || /[\r\n]/.test(nodeId)) return;
+				const attemptKey = v2AttemptKey(requestId, ownerRunId, nodeId);
+				const controller = v2Controllers.get(attemptKey);
+				if (controller) controller.abort();
+				else rememberV2Identity(pendingV2Cancels, attemptKey);
+				return;
+			}
+			if (value.version !== SUBAGENT_DELEGATION_PROTOCOL_VERSION) return;
+			if (Object.keys(value).some((key) => key !== "version" && key !== "requestId")) return;
+		}
 		const controller = controllers.get(requestId);
 		if (controller) {
 			controller.abort();
 			return;
 		}
-		pendingCancels.add(requestId);
+		rememberPendingCancel(requestId);
 	});
 
 	subscribe(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, async (data) => {
-		const request = parsePromptTemplateRequest(data);
-		if (!request) return;
+		const isVersioned = !!data && typeof data === "object" && Object.hasOwn(data, "version");
+		let requestId: string;
+		let params: DelegatedSubagentExecutionParams;
+		let versionedRequest: SubagentDelegationRequest | SubagentDelegationV2Request | undefined;
+		let v2Request: SubagentDelegationV2Request | undefined;
+		let v2Key: string | undefined;
+		let legacyRequest: PromptTemplateDelegationRequest | undefined;
+
+		if (isVersioned) {
+			const parsed = parseSubagentDelegationRequest(data);
+			if (parsed.ok === false) {
+				if (!disposed && parsed.requestId) {
+					if (parsed.version === SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION) {
+						const payload = {
+							version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+							requestId: parsed.requestId,
+							...(parsed.ownerRunId ? { ownerRunId: parsed.ownerRunId } : {}),
+							...(parsed.nodeId ? { nodeId: parsed.nodeId } : {}),
+							status: "invalid_request",
+							error: parsed.error,
+						} satisfies SubagentDelegationV2InvalidResponse;
+						if (parsed.ownerRunId && parsed.nodeId) {
+							const attemptKey = v2AttemptKey(parsed.requestId, parsed.ownerRunId, parsed.nodeId);
+							if (!v2Controllers.has(attemptKey)) emitV2Terminal(attemptKey, payload);
+						} else {
+							options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, payload);
+						}
+					} else if (!controllers.has(parsed.requestId)) {
+						options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
+							version: SUBAGENT_DELEGATION_PROTOCOL_VERSION,
+							requestId: parsed.requestId,
+							status: "invalid_request",
+							error: parsed.error,
+						} satisfies SubagentDelegationResponse);
+					}
+				}
+				return;
+			}
+			versionedRequest = parsed.request;
+			requestId = parsed.request.requestId;
+			if (parsed.request.version === SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION) {
+				v2Request = parsed.request;
+				v2Key = v2AttemptKey(requestId, parsed.request.ownerRunId, parsed.request.nodeId);
+				params = toSubagentDelegationV2ExecutionParams(parsed.request);
+			} else {
+				params = toSubagentDelegationExecutionParams(parsed.request);
+			}
+		} else {
+			legacyRequest = parsePromptTemplateRequest(data);
+			if (!legacyRequest) return;
+			requestId = legacyRequest.requestId;
+			params = toLegacyExecutionParams(legacyRequest);
+		}
 
+		// Legacy and V1 keep requestId-only ownership. V2 retransmission and terminal
+		// suppression use the full tuple, independently from logical-node ownership.
+		if (!v2Request && controllers.has(requestId)) return;
+		if (v2Request && v2Key) {
+			if (v2Controllers.has(v2Key) || settledV2Attempts.has(v2Key)) return;
+			if (pendingV2Cancels.delete(v2Key)) {
+				emitV2Terminal(v2Key, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: "cancelled",
+				});
+				return;
+			}
+			if (v2IdentitySaturated) {
+				options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: "unavailable_context",
+					error: "Delegation v2 identity capacity is exhausted for this extension context.",
+				} satisfies SubagentDelegationV2Response);
+				return;
+			}
+			const active = activeV2Nodes.get(v2NodeKey(v2Request.ownerRunId, v2Request.nodeId));
+			if (active) {
+				emitV2Terminal(v2Key, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: "duplicate_node",
+				});
+				return;
+			}
+		}
 		const ctx = options.getContext();
 		if (!ctx) {
-			const response: PromptTemplateDelegationResponse = {
-				...request,
-				messages: [],
-				isError: true,
-				errorText: "No active extension context for delegated subagent execution.",
-			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			if (v2Request && v2Key) {
+				emitV2Terminal(v2Key, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: "unavailable_context",
+					error: "No active extension context for delegated subagent execution.",
+				});
+			} else if (versionedRequest) {
+				options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
+					version: SUBAGENT_DELEGATION_PROTOCOL_VERSION,
+					requestId,
+					status: "unavailable_context",
+					error: "No active extension context for delegated subagent execution.",
+				} satisfies SubagentDelegationResponse);
+			} else if (legacyRequest) {
+				options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
+					...legacyRequest,
+					messages: [],
+					isError: true,
+					errorText: "No active extension context for delegated subagent execution.",
+				} satisfies PromptTemplateDelegationResponse);
+			}
 			return;
 		}
 
 		const controller = new AbortController();
-		controllers.set(request.requestId, controller);
-
-		if (pendingCancels.delete(request.requestId)) {
-			controller.abort();
-			const response: PromptTemplateDelegationResponse = {
-				...request,
-				messages: [],
-				isError: true,
-				errorText: "Delegated prompt cancelled.",
-			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
-			controllers.delete(request.requestId);
+		if (v2Request && v2Key) {
+			v2Controllers.set(v2Key, controller);
+			activeV2Nodes.set(v2NodeKey(v2Request.ownerRunId, v2Request.nodeId), { attemptKey: v2Key, controller });
+		} else {
+			controllers.set(requestId, controller);
+			if (pendingCancels.delete(requestId)) controller.abort();
+		}
+		if (controller.signal.aborted) {
+			if (v2Request && v2Key) {
+				emitV2Terminal(v2Key, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: "cancelled",
+				});
+				activeV2Nodes.delete(v2NodeKey(v2Request.ownerRunId, v2Request.nodeId));
+			} else if (versionedRequest) {
+				options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
+					version: SUBAGENT_DELEGATION_PROTOCOL_VERSION,
+					requestId,
+					status: "cancelled",
+				} satisfies SubagentDelegationResponse);
+			} else if (legacyRequest) {
+				options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
+					...legacyRequest,
+					messages: [],
+					isError: true,
+					errorText: "Delegated prompt cancelled.",
+				} satisfies PromptTemplateDelegationResponse);
+			}
+			if (v2Key) v2Controllers.delete(v2Key);
+			else controllers.delete(requestId);
 			return;
 		}
 
-		options.events.emit(PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT, { requestId: request.requestId });
+		options.events.emit(
+			versionedRequest ? SUBAGENT_DELEGATION_STARTED_EVENT : PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT,
+			v2Request
+				? { version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION, requestId, ownerRunId: v2Request.ownerRunId, nodeId: v2Request.nodeId }
+				: versionedRequest
+					? { version: SUBAGENT_DELEGATION_PROTOCOL_VERSION, requestId }
+					: { requestId },
+		);
 
 		try {
-			const result = await options.execute(
-				request.requestId,
-				request,
+			const executeRequest = versionedRequest && options.executeVersioned
+				? options.executeVersioned
+				: options.execute;
+			const result = await executeRequest(
+				requestId,
+				params,
 				controller.signal,
 				ctx,
 				(update) => {
-					const payload = toDelegationUpdate(request.requestId, update);
-					if (!payload) return;
-					options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
+					if (v2Key ? !ownsV2Attempt(v2Key, controller) : !ownsRequest(requestId, controller)) return;
+					if (v2Request) {
+						const payload = toSubagentDelegationV2Update(v2Request, update);
+						if (payload) options.events.emit(SUBAGENT_DELEGATION_UPDATE_EVENT, payload);
+						return;
+					}
+					if (versionedRequest) {
+						const payload = toSubagentDelegationUpdate(requestId, update);
+						if (payload) options.events.emit(SUBAGENT_DELEGATION_UPDATE_EVENT, payload);
+						return;
+					}
+					const payload = toDelegationUpdate(requestId, update);
+					if (payload) options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
 				},
 			);
-			const contentText = firstTextContent(result.content);
-			const messages = buildDelegationMessages(result.details?.results?.[0] ?? {}, contentText);
-			const parallelResults = request.tasks
-				? request.tasks.map<PromptTemplateDelegationParallelResult>((task, index) => {
-					const step = result.details?.results?.[index];
-					if (!step) {
-						return {
-							agent: task.agent,
-							messages: [],
-							isError: true,
-							errorText: "Missing result for delegated parallel task.",
-						};
-					}
-					const exitCode = typeof step.exitCode === "number" ? step.exitCode : undefined;
-					const errorText = step.error;
-					return {
-						agent: step.agent ?? task.agent,
-						messages: buildDelegationMessages(step),
-						isError: (exitCode !== undefined && exitCode !== 0) || !!errorText,
-						errorText: errorText || undefined,
-					};
-				})
-				: undefined;
-			const response: PromptTemplateDelegationResponse = {
-				...request,
-				messages,
-				...(parallelResults ? { parallelResults } : {}),
-				...(contentText ? { contentText } : {}),
-				isError: result.isError === true,
-				errorText: result.isError ? contentText : undefined,
-			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			if (v2Key ? !ownsV2Attempt(v2Key, controller) : !ownsRequest(requestId, controller)) return;
+			if (v2Request && v2Key) {
+				emitV2Terminal(v2Key, toSubagentDelegationV2Response(v2Request, result, controller.signal.aborted));
+			} else if (versionedRequest) {
+				options.events.emit(
+					SUBAGENT_DELEGATION_RESPONSE_EVENT,
+					toSubagentDelegationResponse(requestId, result, controller.signal.aborted),
+				);
+			} else if (legacyRequest) {
+				options.events.emit(
+					PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT,
+					controller.signal.aborted
+						? { ...legacyRequest, messages: [], isError: true, errorText: "Delegated prompt cancelled." }
+						: toPromptTemplateResponse(legacyRequest, result),
+				);
+			}
 		} catch (error) {
-			const response: PromptTemplateDelegationResponse = {
-				...request,
-				messages: [],
-				isError: true,
-				errorText: error instanceof Error ? error.message : String(error),
-			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			if (v2Key ? !ownsV2Attempt(v2Key, controller) : !ownsRequest(requestId, controller)) return;
+			if (v2Request && v2Key) {
+				emitV2Terminal(v2Key, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: controller.signal.aborted ? "cancelled" : "failed",
+					...(controller.signal.aborted ? {} : { error: error instanceof Error ? error.message : String(error) }),
+				});
+			} else if (versionedRequest) {
+				options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
+					version: SUBAGENT_DELEGATION_PROTOCOL_VERSION,
+					requestId,
+					status: controller.signal.aborted ? "cancelled" : "failed",
+					...(controller.signal.aborted ? {} : { error: error instanceof Error ? error.message : String(error) }),
+				} satisfies SubagentDelegationResponse);
+			} else if (legacyRequest) {
+				options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
+					...legacyRequest,
+					messages: [],
+					isError: true,
+					errorText: error instanceof Error ? error.message : String(error),
+				} satisfies PromptTemplateDelegationResponse);
+			}
 		} finally {
-			controllers.delete(request.requestId);
+			if (v2Key) {
+				if (v2Controllers.get(v2Key) === controller) v2Controllers.delete(v2Key);
+			} else if (controllers.get(requestId) === controller) controllers.delete(requestId);
+			if (v2Request) {
+				const key = v2NodeKey(v2Request.ownerRunId, v2Request.nodeId);
+				if (activeV2Nodes.get(key)?.controller === controller) activeV2Nodes.delete(key);
+			}
 		}
 	});
 
 	return {
 		cancelAll: () => {
-			for (const controller of controllers.values()) {
-				controller.abort();
-			}
+			for (const controller of controllers.values()) controller.abort();
+			for (const controller of v2Controllers.values()) controller.abort();
 			controllers.clear();
+			v2Controllers.clear();
 			pendingCancels.clear();
+			pendingV2Cancels.clear();
+			activeV2Nodes.clear();
+			settledV2Attempts.clear();
+			v2IdentitySaturated = false;
 		},
 		dispose: () => {
+			disposed = true;
+			for (const controller of controllers.values()) controller.abort();
+			for (const controller of v2Controllers.values()) controller.abort();
+			controllers.clear();
+			v2Controllers.clear();
 			for (const unsubscribe of subscriptions) unsubscribe();
 			subscriptions.length = 0;
 			pendingCancels.clear();
+			pendingV2Cancels.clear();
+			activeV2Nodes.clear();
+			settledV2Attempts.clear();
 		},
 	};
 }