@selesai/code 0.13.12 → 0.13.13

package/dist/extensions/pi-subagents/src/slash/delegation-json.ts

@@ -1,108 +0,0 @@
-const MAX_JSON_DEPTH = 64;
-const MAX_JSON_ENTRIES = 100_000;
-
-export type BoundedJsonClone =
-	| { ok: true; value: unknown; encodedBytes: number }
-	| { ok: false; reason: "invalid" | "too_large" };
-
-/** Clone plain JSON data without invoking getters or toJSON hooks. */
-export function cloneJsonWithinByteLimit(input: unknown, maxBytes: number): BoundedJsonClone {
-	let minimumBytes = 0;
-	let entries = 0;
-	const active = new WeakSet<object>();
-
-	const addMinimumBytes = (bytes: number): void => {
-		minimumBytes += bytes;
-		if (minimumBytes > maxBytes) throw new RangeError("too_large");
-	};
-
-	const visit = (value: unknown, depth: number): unknown => {
-		if (depth > MAX_JSON_DEPTH) throw new TypeError("invalid");
-		if (value === null) {
-			addMinimumBytes(4);
-			return null;
-		}
-		if (typeof value === "boolean") {
-			addMinimumBytes(value ? 4 : 5);
-			return value;
-		}
-		if (typeof value === "number") {
-			if (!Number.isFinite(value)) throw new TypeError("invalid");
-			const encoded = JSON.stringify(Object.is(value, -0) ? 0 : value);
-			addMinimumBytes(Buffer.byteLength(encoded, "utf8"));
-			return Object.is(value, -0) ? 0 : value;
-		}
-		if (typeof value === "string") {
-			// Quoting and escaping can only increase the encoded size.
-			addMinimumBytes(Buffer.byteLength(value, "utf8") + 2);
-			return value;
-		}
-		if (typeof value !== "object") throw new TypeError("invalid");
-
-		const object = value as object;
-		if (active.has(object)) throw new TypeError("invalid");
-		active.add(object);
-		try {
-			const prototype = Object.getPrototypeOf(object);
-			const keys = Reflect.ownKeys(object);
-			if (Array.isArray(object)) {
-				if (prototype !== Array.prototype) throw new TypeError("invalid");
-				const lengthDescriptor = Object.getOwnPropertyDescriptor(object, "length");
-				if (!lengthDescriptor || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0) {
-					throw new TypeError("invalid");
-				}
-				const length = lengthDescriptor.value as number;
-				addMinimumBytes(2 + Math.max(0, length - 1));
-				const output: unknown[] = [];
-				for (const key of keys) {
-					if (typeof key === "symbol") throw new TypeError("invalid");
-					if (key === "length") continue;
-					if (!/^(?:0|[1-9][0-9]*)$/.test(key) || Number(key) >= length) throw new TypeError("invalid");
-				}
-				for (let index = 0; index < length; index++) {
-					const descriptor = Object.getOwnPropertyDescriptor(object, String(index));
-					if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) throw new TypeError("invalid");
-					entries++;
-					if (entries > MAX_JSON_ENTRIES) throw new TypeError("invalid");
-					output.push(visit(descriptor.value, depth + 1));
-				}
-				return output;
-			}
-
-			if (prototype !== Object.prototype && prototype !== null) throw new TypeError("invalid");
-			addMinimumBytes(2 + Math.max(0, keys.length - 1));
-			const output: Record<string, unknown> = {};
-			for (const key of keys) {
-				if (typeof key === "symbol") throw new TypeError("invalid");
-				const descriptor = Object.getOwnPropertyDescriptor(object, key);
-				if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) throw new TypeError("invalid");
-				entries++;
-				if (entries > MAX_JSON_ENTRIES) throw new TypeError("invalid");
-				addMinimumBytes(Buffer.byteLength(JSON.stringify(key), "utf8") + 1);
-				Object.defineProperty(output, key, {
-					value: visit(descriptor.value, depth + 1),
-					enumerable: true,
-					configurable: true,
-					writable: true,
-				});
-			}
-			return output;
-		} finally {
-			active.delete(object);
-		}
-	};
-
-	try {
-		const value = visit(input, 0);
-		const encoded = JSON.stringify(value);
-		if (encoded === undefined) return { ok: false, reason: "invalid" };
-		const encodedBytes = Buffer.byteLength(encoded, "utf8");
-		if (encodedBytes > maxBytes) return { ok: false, reason: "too_large" };
-		return { ok: true, value, encodedBytes };
-	} catch (error) {
-		return {
-			ok: false,
-			reason: error instanceof RangeError && error.message === "too_large" ? "too_large" : "invalid",
-		};
-	}
-}

package/dist/extensions/pi-subagents/src/slash/delegation-request.ts

@@ -1,162 +0,0 @@
-import {
-	type SubagentDelegationRequest,
-} from "../api/delegation.ts";
-import { validateToolBudgetConfig } from "../runs/shared/tool-budget.ts";
-import { cloneJsonWithinByteLimit } from "./delegation-json.ts";
-
-export type SubagentDelegationParseResult =
-	| { ok: true; request: SubagentDelegationRequest }
-	| { ok: false; requestId?: string; ownerRunId?: string; nodeId?: string; error: string };
-
-const supportedFields = new Set([
-	"requestId",
-	"ownerRunId",
-	"nodeId",
-	"agent",
-	"task",
-	"context",
-	"cwd",
-	"model",
-	"thinking",
-	"timeoutMs",
-	"toolBudget",
-	"skill",
-	"artifacts",
-	"result",
-]);
-
-const thinkingLevels = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-const MAX_SCHEMA_BYTES = 64 * 1024;
-const MAX_TASK_BYTES = 1024 * 1024;
-const MAX_CWD_BYTES = 32 * 1024;
-const MAX_SHORT_TEXT_BYTES = 1024;
-const MAX_SKILL_ENTRIES = 256;
-const MAX_SKILL_AGGREGATE_BYTES = 64 * 1024;
-
-function nonEmptyString(value: unknown): value is string {
-	return typeof value === "string" && value.trim().length > 0;
-}
-
-function validateId(value: unknown): string | undefined {
-	if (!nonEmptyString(value) || value.length > 256 || /[\r\n]/.test(value)) return undefined;
-	return value;
-}
-
-export function parseSubagentDelegationRequest(data: unknown): SubagentDelegationParseResult {
-	if (!data || typeof data !== "object" || Array.isArray(data)) {
-		return { ok: false, error: "Delegation request must be an object." };
-	}
-	const value = data as Record<string, unknown>;
-	const requestId = validateId(value.requestId);
-	if (!requestId) {
-		return { ok: false, error: "Delegation requestId must be a non-empty string of at most 256 characters without newlines." };
-	}
-	const ownerRunId = validateId(value.ownerRunId);
-	if (!ownerRunId) {
-		return { ok: false, requestId, error: "Delegation ownerRunId must be a non-empty string of at most 256 characters without newlines." };
-	}
-	const nodeId = validateId(value.nodeId);
-	if (!nodeId) {
-		return { ok: false, requestId, ownerRunId, error: "Delegation nodeId must be a non-empty string of at most 256 characters without newlines." };
-	}
-	const identity = { requestId, ownerRunId, nodeId };
-	const unsupportedField = Object.keys(value).find((key) => !supportedFields.has(key));
-	if (unsupportedField) return { ok: false, ...identity, error: `Unsupported delegation field: ${unsupportedField}.` };
-	if (!nonEmptyString(value.agent)) return { ok: false, ...identity, error: "Delegation agent must be a non-empty string." };
-	if (!nonEmptyString(value.task)) return { ok: false, ...identity, error: "Delegation task must be a non-empty string." };
-	if (value.context !== "fresh" && value.context !== "fork") {
-		return { ok: false, ...identity, error: "Delegation context must be fresh or fork." };
-	}
-	if (!nonEmptyString(value.cwd)) return { ok: false, ...identity, error: "Delegation cwd must be a non-empty string." };
-	if (value.model !== undefined && !nonEmptyString(value.model)) {
-		return { ok: false, ...identity, error: "model must be a non-empty string when provided." };
-	}
-	if (value.timeoutMs !== undefined && (typeof value.timeoutMs !== "number" || !Number.isInteger(value.timeoutMs) || value.timeoutMs < 1)) {
-		return { ok: false, ...identity, error: "timeoutMs must be an integer >= 1." };
-	}
-	const timeoutMs = typeof value.timeoutMs === "number" ? value.timeoutMs : undefined;
-	if (timeoutMs !== undefined && timeoutMs > 2_147_483_647) {
-		return { ok: false, ...identity, error: "timeoutMs must be <= 2147483647." };
-	}
-	if (value.toolBudget && typeof value.toolBudget === "object" && !Array.isArray(value.toolBudget)) {
-		const unsupportedToolBudgetField = Object.keys(value.toolBudget).find((key) => key !== "soft" && key !== "hard" && key !== "block");
-		if (unsupportedToolBudgetField) {
-			return { ok: false, ...identity, error: `toolBudget.${unsupportedToolBudgetField} is not supported.` };
-		}
-	}
-	const toolBudget = validateToolBudgetConfig(value.toolBudget, "toolBudget", { minimumHard: 0 });
-	if (toolBudget.error) return { ok: false, ...identity, error: toolBudget.error };
-	if (value.skill !== undefined) {
-		const validSkill = typeof value.skill === "boolean"
-			|| nonEmptyString(value.skill)
-			|| (Array.isArray(value.skill) && value.skill.length > 0 && value.skill.every(nonEmptyString));
-		if (!validSkill) {
-			return { ok: false, ...identity, error: "skill must be a boolean, non-empty string, or non-empty string array." };
-		}
-	}
-	if (value.artifacts !== undefined && typeof value.artifacts !== "boolean") {
-		return { ok: false, ...identity, error: "artifacts must be a boolean." };
-	}
-	if (Buffer.byteLength(value.task as string, "utf8") > MAX_TASK_BYTES) {
-		return { ok: false, ...identity, error: "Delegation task exceeds 1 MiB when UTF-8 encoded." };
-	}
-	if (Buffer.byteLength(value.cwd as string, "utf8") > MAX_CWD_BYTES) {
-		return { ok: false, ...identity, error: "Delegation cwd exceeds 32 KiB when UTF-8 encoded." };
-	}
-	if (Buffer.byteLength(value.agent as string, "utf8") > MAX_SHORT_TEXT_BYTES) {
-		return { ok: false, ...identity, error: "Delegation agent exceeds 1 KiB when UTF-8 encoded." };
-	}
-	if (typeof value.model === "string" && Buffer.byteLength(value.model, "utf8") > MAX_SHORT_TEXT_BYTES) {
-		return { ok: false, ...identity, error: "Delegation model exceeds 1 KiB when UTF-8 encoded." };
-	}
-	const skillEntries = typeof value.skill === "string" ? [value.skill] : Array.isArray(value.skill) ? value.skill as string[] : [];
-	if (skillEntries.length > MAX_SKILL_ENTRIES) {
-		return { ok: false, ...identity, error: "Delegation skill supports at most 256 entries." };
-	}
-	if (skillEntries.some((entry) => Buffer.byteLength(entry, "utf8") > MAX_SHORT_TEXT_BYTES)) {
-		return { ok: false, ...identity, error: "Delegation skill entry exceeds 1 KiB when UTF-8 encoded." };
-	}
-	if (skillEntries.reduce((total, entry) => total + Buffer.byteLength(entry, "utf8"), 0) > MAX_SKILL_AGGREGATE_BYTES) {
-		return { ok: false, ...identity, error: "Delegation skill entries exceed 64 KiB in aggregate when UTF-8 encoded." };
-	}
-	if (value.thinking !== undefined && (typeof value.thinking !== "string" || !thinkingLevels.has(value.thinking))) {
-		return { ok: false, ...identity, error: "thinking must be one of off, minimal, low, medium, high, xhigh, or max." };
-	}
-	if (!value.result || typeof value.result !== "object" || Array.isArray(value.result)) {
-		return { ok: false, ...identity, error: "result must be { kind: \"text\" } or { kind: \"structured\", schema: object }." };
-	}
-	const result = value.result as Record<string, unknown>;
-	let structuredSchema: Record<string, unknown> | undefined;
-	if (result.kind === "text") {
-		const unsupportedResultField = Object.keys(result).find((key) => key !== "kind");
-		if (unsupportedResultField) return { ok: false, ...identity, error: `result.${unsupportedResultField} is not supported for text results.` };
-	} else if (result.kind === "structured") {
-		const unsupportedResultField = Object.keys(result).find((key) => key !== "kind" && key !== "schema");
-		if (unsupportedResultField) return { ok: false, ...identity, error: `result.${unsupportedResultField} is not supported for structured results.` };
-		if (!result.schema || typeof result.schema !== "object" || Array.isArray(result.schema)) {
-			return { ok: false, ...identity, error: "result.schema must be a JSON Schema object." };
-		}
-		const inspectedSchema = cloneJsonWithinByteLimit(result.schema, MAX_SCHEMA_BYTES);
-		if (inspectedSchema.ok === false) {
-			return {
-				ok: false,
-				...identity,
-				error: inspectedSchema.reason === "too_large"
-					? "result.schema exceeds 64 KiB when encoded."
-					: "result.schema must be plain JSON data.",
-			};
-		}
-		structuredSchema = inspectedSchema.value as Record<string, unknown>;
-	} else {
-		return { ok: false, ...identity, error: "result.kind must be text or structured." };
-	}
-	return {
-		ok: true,
-		request: {
-			...value,
-			result: structuredSchema
-				? { kind: "structured", schema: structuredSchema }
-				: { kind: "text" },
-		} as unknown as SubagentDelegationRequest,
-	};
-}

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

@@ -1,419 +0,0 @@
-import {
-	SUBAGENT_DELEGATION_CANCEL_EVENT,
-	SUBAGENT_DELEGATION_REQUEST_EVENT,
-	SUBAGENT_DELEGATION_RESPONSE_EVENT,
-	SUBAGENT_DELEGATION_STARTED_EVENT,
-	SUBAGENT_DELEGATION_UPDATE_EVENT,
-	type SubagentDelegationInvalidResponse,
-	type SubagentDelegationRequest,
-	type SubagentDelegationResponse,
-	type SubagentDelegationUpdate,
-} from "../api/delegation.ts";
-import { parseSubagentDelegationRequest } from "./delegation-request.ts";
-import {
-	parsePromptTemplateRequest,
-	toDelegationUpdate,
-	toPromptTemplateResponse,
-	toSubagentDelegationExecutionParams,
-	toSubagentDelegationResponse,
-	toSubagentDelegationUpdate,
-	type DelegatedSubagentExecutionParams,
-	type PromptTemplateBridgeResult,
-	type PromptTemplateDelegationRequest,
-	type PromptTemplateDelegationResponse,
-} from "./delegation-adapters.ts";
-
-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 PromptTemplateBridgeOptions<Ctx extends { cwd?: string }> {
-	events: PromptTemplateBridgeEvents;
-	getContext: () => Ctx | null;
-	execute: (
-		requestId: string,
-		params: DelegatedSubagentExecutionParams,
-		signal: AbortSignal,
-		ctx: Ctx,
-		onUpdate: (result: PromptTemplateBridgeResult) => void,
-	) => Promise<PromptTemplateBridgeResult>;
-	/** Concurrent-safe executor for structured delegation requests. */
-	executeStructured?: (
-		requestId: string,
-		params: DelegatedSubagentExecutionParams,
-		signal: AbortSignal,
-		ctx: Ctx,
-		onUpdate: (result: PromptTemplateBridgeResult) => void,
-	) => Promise<PromptTemplateBridgeResult>;
-}
-
-function hasStructuredDelegationMarker(data: unknown): boolean {
-	if (!data || typeof data !== "object" || Array.isArray(data)) return false;
-	const value = data as Record<string, unknown>;
-	return Object.hasOwn(value, "ownerRunId")
-		|| Object.hasOwn(value, "nodeId")
-		|| Object.hasOwn(value, "result")
-		|| Object.hasOwn(value, "version");
-}
-
-function validId(value: unknown): value is string {
-	return typeof value === "string" && value.trim().length > 0 && value.length <= 256 && !/[\r\n]/.test(value);
-}
-
-function sameStringArray(left: string[] | undefined, right: string[] | undefined): boolean {
-	if (left === right) return true;
-	if (!left || !right || left.length !== right.length) return false;
-	return left.every((value, index) => value === right[index]);
-}
-
-function sameRecentTools(
-	left: Array<{ tool: string; args: string }> | undefined,
-	right: Array<{ tool: string; args: string }> | undefined,
-): boolean {
-	if (left === right) return true;
-	if (!left || !right || left.length !== right.length) return false;
-	return left.every((tool, index) => tool.tool === right[index]?.tool && tool.args === right[index]?.args);
-}
-
-/** Duration is a heartbeat clock, not delegation-visible progress; terminal usage remains authoritative. */
-function sameStructuredDelegationUpdateProgress(left: SubagentDelegationUpdate, right: SubagentDelegationUpdate): boolean {
-	return left.requestId === right.requestId
-		&& left.ownerRunId === right.ownerRunId
-		&& left.nodeId === right.nodeId
-		&& left.runId === right.runId
-		&& left.currentTool === right.currentTool
-		&& left.currentToolArgs === right.currentToolArgs
-		&& left.recentOutput === right.recentOutput
-		&& sameStringArray(left.recentOutputLines, right.recentOutputLines)
-		&& sameRecentTools(left.recentTools, right.recentTools)
-		&& left.model === right.model
-		&& left.toolCount === right.toolCount
-		&& left.tokens === right.tokens;
-}
-
-export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: string }>(
-	options: PromptTemplateBridgeOptions<Ctx>,
-): {
-	cancelAll: () => void;
-	dispose: () => void;
-} {
-	const legacyControllers = new Map<string, AbortController>();
-	const pendingLegacyCancels = new Map<string, true>();
-	const attemptControllers = new Map<string, AbortController>();
-	const pendingAttemptCancels = new Map<string, true>();
-	const activeOwnedNodes = new Map<string, { attemptKey: string; controller: AbortController }>();
-	const settledAttempts = new Map<string, true>();
-	const subscriptions: Array<() => void> = [];
-	let disposed = false;
-	let identitySaturated = 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 ownsLegacyRequest = (requestId: string, controller: AbortController): boolean =>
-		!disposed && legacyControllers.get(requestId) === controller;
-	const ownsAttempt = (attemptKey: string, controller: AbortController): boolean =>
-		!disposed && attemptControllers.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 rememberIdentity = (map: Map<string, true>, key: string): void => {
-		if (map.has(key) || identitySaturated) return;
-		if (map.size >= 8_192) {
-			identitySaturated = true;
-			return;
-		}
-		map.set(key, true);
-		if (map.size === 8_192) {
-			// Exact cancellation and terminal-attempt facts are security state, not an
-			// LRU cache. Once full, fail closed rather than evicting identity facts.
-			identitySaturated = true;
-		}
-	};
-	const nodeKey = (ownerRunId: string, nodeId: string): string => JSON.stringify([ownerRunId, nodeId]);
-	const attemptKey = (requestId: string, ownerRunId: string, nodeId: string): string => JSON.stringify([requestId, ownerRunId, nodeId]);
-	const rememberPendingLegacyCancel = (requestId: string): void => {
-		boundedRemember(pendingLegacyCancels, requestId);
-	};
-	const emitTerminal = (key: string, payload: SubagentDelegationResponse): void => {
-		if (disposed || settledAttempts.has(key)) return;
-		rememberIdentity(settledAttempts, key);
-		options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, payload);
-	};
-
-	subscribe(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, (data) => {
-		if (!data || typeof data !== "object" || Array.isArray(data)) return;
-		const value = data as Record<string, unknown>;
-		const requestId = value.requestId;
-		if (!validId(requestId)) return;
-		if (hasStructuredDelegationMarker(data)) {
-			if (Object.keys(value).some((key) => key !== "requestId" && key !== "ownerRunId" && key !== "nodeId")) return;
-			const ownerRunId = value.ownerRunId;
-			const nodeId = value.nodeId;
-			if (!validId(ownerRunId) || !validId(nodeId)) return;
-			const key = attemptKey(requestId, ownerRunId, nodeId);
-			const controller = attemptControllers.get(key);
-			if (controller) controller.abort();
-			else rememberIdentity(pendingAttemptCancels, key);
-			return;
-		}
-		const controller = legacyControllers.get(requestId);
-		if (controller) {
-			controller.abort();
-			return;
-		}
-		rememberPendingLegacyCancel(requestId);
-	});
-
-	subscribe(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, async (data) => {
-		const structuredPayload = hasStructuredDelegationMarker(data);
-		let requestId: string;
-		let params: DelegatedSubagentExecutionParams;
-		let structuredRequest: SubagentDelegationRequest | undefined;
-		let key: string | undefined;
-		let legacyRequest: PromptTemplateDelegationRequest | undefined;
-
-		if (structuredPayload) {
-			const parsed = parseSubagentDelegationRequest(data);
-			if (parsed.ok === false) {
-				if (!disposed && parsed.requestId) {
-					const payload = {
-						requestId: parsed.requestId,
-						...(parsed.ownerRunId ? { ownerRunId: parsed.ownerRunId } : {}),
-						...(parsed.nodeId ? { nodeId: parsed.nodeId } : {}),
-						status: "invalid_request",
-						error: parsed.error,
-					} satisfies SubagentDelegationInvalidResponse;
-					if (parsed.ownerRunId && parsed.nodeId) {
-						const attemptedKey = attemptKey(parsed.requestId, parsed.ownerRunId, parsed.nodeId);
-						if (!attemptControllers.has(attemptedKey)) emitTerminal(attemptedKey, payload);
-					} else {
-						options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, payload);
-					}
-				}
-				return;
-			}
-			structuredRequest = parsed.request;
-			requestId = parsed.request.requestId;
-			key = attemptKey(requestId, parsed.request.ownerRunId, parsed.request.nodeId);
-			params = toSubagentDelegationExecutionParams(parsed.request);
-		} else {
-			if (data && typeof data === "object" && !Array.isArray(data)) {
-				const legacy = data as Record<string, unknown>;
-				if ((legacy.tasks !== undefined || legacy.worktree !== undefined) && typeof legacy.requestId === "string" && legacy.requestId) {
-					options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
-						requestId: legacy.requestId,
-						messages: [],
-						isError: true,
-						errorText: "Legacy prompt-template tasks/worktree orchestration was removed; use workflowScript.",
-					});
-					return;
-				}
-			}
-			legacyRequest = parsePromptTemplateRequest(data);
-			if (!legacyRequest) return;
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
-				...legacyRequest,
-				messages: [],
-				isError: true,
-				errorText: "Legacy prompt-template direct delegation was removed; use workflowScript through the subagent tool or structured delegation.",
-			} satisfies PromptTemplateDelegationResponse);
-			return;
-		}
-
-		if (!structuredRequest && legacyControllers.has(requestId)) return;
-		if (structuredRequest && key) {
-			if (attemptControllers.has(key) || settledAttempts.has(key)) return;
-			if (pendingAttemptCancels.delete(key)) {
-				emitTerminal(key, {
-					requestId,
-					ownerRunId: structuredRequest.ownerRunId,
-					nodeId: structuredRequest.nodeId,
-					status: "cancelled",
-				});
-				return;
-			}
-			if (identitySaturated) {
-				options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
-					requestId,
-					ownerRunId: structuredRequest.ownerRunId,
-					nodeId: structuredRequest.nodeId,
-					status: "unavailable_context",
-					error: "Delegation identity capacity is exhausted for this extension context.",
-				} satisfies SubagentDelegationResponse);
-				return;
-			}
-			const active = activeOwnedNodes.get(nodeKey(structuredRequest.ownerRunId, structuredRequest.nodeId));
-			if (active) {
-				emitTerminal(key, {
-					requestId,
-					ownerRunId: structuredRequest.ownerRunId,
-					nodeId: structuredRequest.nodeId,
-					status: "duplicate_node",
-				});
-				return;
-			}
-		}
-		const ctx = options.getContext();
-		if (!ctx) {
-			if (structuredRequest && key) {
-				emitTerminal(key, {
-					requestId,
-					ownerRunId: structuredRequest.ownerRunId,
-					nodeId: structuredRequest.nodeId,
-					status: "unavailable_context",
-					error: "No active extension context for delegated subagent execution.",
-				});
-			} 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();
-		if (structuredRequest && key) {
-			attemptControllers.set(key, controller);
-			activeOwnedNodes.set(nodeKey(structuredRequest.ownerRunId, structuredRequest.nodeId), { attemptKey: key, controller });
-		} else {
-			legacyControllers.set(requestId, controller);
-			if (pendingLegacyCancels.delete(requestId)) controller.abort();
-		}
-		if (controller.signal.aborted) {
-			if (structuredRequest && key) {
-				emitTerminal(key, {
-					requestId,
-					ownerRunId: structuredRequest.ownerRunId,
-					nodeId: structuredRequest.nodeId,
-					status: "cancelled",
-				});
-				activeOwnedNodes.delete(nodeKey(structuredRequest.ownerRunId, structuredRequest.nodeId));
-			} else if (legacyRequest) {
-				options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
-					...legacyRequest,
-					messages: [],
-					isError: true,
-					errorText: "Delegated prompt cancelled.",
-				} satisfies PromptTemplateDelegationResponse);
-			}
-			if (key) attemptControllers.delete(key);
-			else legacyControllers.delete(requestId);
-			return;
-		}
-
-		options.events.emit(
-			structuredRequest ? SUBAGENT_DELEGATION_STARTED_EVENT : PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT,
-			structuredRequest
-				? { requestId, ownerRunId: structuredRequest.ownerRunId, nodeId: structuredRequest.nodeId }
-				: { requestId },
-		);
-
-		try {
-			const executeRequest = structuredRequest && options.executeStructured
-				? options.executeStructured
-				: options.execute;
-			let lastStructuredUpdate: SubagentDelegationUpdate | undefined;
-			const result = await executeRequest(
-				requestId,
-				params,
-				controller.signal,
-				ctx,
-				(update) => {
-					if (key ? !ownsAttempt(key, controller) : !ownsLegacyRequest(requestId, controller)) return;
-					if (structuredRequest) {
-						const payload = toSubagentDelegationUpdate(structuredRequest, update);
-						if (payload && (!lastStructuredUpdate || !sameStructuredDelegationUpdateProgress(lastStructuredUpdate, payload))) {
-							lastStructuredUpdate = 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);
-				},
-			);
-			if (key ? !ownsAttempt(key, controller) : !ownsLegacyRequest(requestId, controller)) return;
-			if (structuredRequest && key) {
-				emitTerminal(key, toSubagentDelegationResponse(structuredRequest, 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) {
-			if (key ? !ownsAttempt(key, controller) : !ownsLegacyRequest(requestId, controller)) return;
-			if (structuredRequest && key) {
-				emitTerminal(key, {
-					requestId,
-					ownerRunId: structuredRequest.ownerRunId,
-					nodeId: structuredRequest.nodeId,
-					status: controller.signal.aborted ? "cancelled" : "failed",
-					...(controller.signal.aborted ? {} : { error: error instanceof Error ? error.message : String(error) }),
-				});
-			} 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 {
-			if (key) {
-				if (attemptControllers.get(key) === controller) attemptControllers.delete(key);
-			} else if (legacyControllers.get(requestId) === controller) legacyControllers.delete(requestId);
-			if (structuredRequest) {
-				const ownedNodeKey = nodeKey(structuredRequest.ownerRunId, structuredRequest.nodeId);
-				if (activeOwnedNodes.get(ownedNodeKey)?.controller === controller) activeOwnedNodes.delete(ownedNodeKey);
-			}
-		}
-	});
-
-	return {
-		cancelAll: () => {
-			for (const controller of legacyControllers.values()) controller.abort();
-			for (const controller of attemptControllers.values()) controller.abort();
-			legacyControllers.clear();
-			attemptControllers.clear();
-			pendingLegacyCancels.clear();
-			pendingAttemptCancels.clear();
-			activeOwnedNodes.clear();
-			settledAttempts.clear();
-			identitySaturated = false;
-		},
-		dispose: () => {
-			disposed = true;
-			for (const controller of legacyControllers.values()) controller.abort();
-			for (const controller of attemptControllers.values()) controller.abort();
-			legacyControllers.clear();
-			attemptControllers.clear();
-			for (const unsubscribe of subscriptions) unsubscribe();
-			subscriptions.length = 0;
-			pendingLegacyCancels.clear();
-			pendingAttemptCancels.clear();
-			activeOwnedNodes.clear();
-			settledAttempts.clear();
-		},
-	};
-}