pi-subagents 0.69.0 → 0.70.0

package/src/runs/shared/cursor-agent-adapter.ts

@@ -1,114 +0,0 @@
-import * as path from "node:path";
-import { parseExternalCliJsonlEvent, type ExternalCliParser, type ExternalCliParserProgress, type ExternalCliParserTerminal } from "./external-cli-runner.ts";
-import type { ExternalCliPreflightSpec } from "./external-cli-preflight.ts";
-
-const MAX_EVENT_TYPE_LENGTH = 128;
-const MAX_ERROR_LENGTH = 4_096;
-const MAX_OVERSIZED_TOOL_CALL_BYTES = 1024 * 1024;
-
-export const CURSOR_AGENT_ADAPTER_ID = "cursor-agent" as const;
-export const CURSOR_AGENT_WRITER_ADAPTER_ID = "cursor-agent-writer" as const;
-export const CURSOR_AGENT_ENV_ALLOWLIST = [
-	"PATH",
-	"HOME",
-	"USERPROFILE",
-	"CURSOR_API_KEY",
-	"HTTP_PROXY",
-	"HTTPS_PROXY",
-	"NO_PROXY",
-	"http_proxy",
-	"https_proxy",
-	"no_proxy",
-	"SSL_CERT_FILE",
-	"SSL_CERT_DIR",
-] as const;
-
-function terminalError(event: Record<string, unknown>): string {
-	for (const value of [event.result, event.error, event.message]) {
-		if (typeof value === "string" && value.trim()) return value.trim().slice(0, MAX_ERROR_LENGTH);
-	}
-	const subtype = typeof event.subtype === "string" && event.subtype ? event.subtype : "unknown";
-	return `Cursor Agent reported terminal result ${subtype}.`;
-}
-
-export function createCursorAgentJsonlParser(): ExternalCliParser {
-	let eventCount = 0;
-	let terminal: ExternalCliParserTerminal | undefined;
-	return {
-		parseLine(line): ExternalCliParserProgress {
-			const event = parseExternalCliJsonlEvent(line, "Cursor Agent", MAX_EVENT_TYPE_LENGTH);
-			if (terminal) throw new Error("Cursor Agent emitted an event after its terminal state.");
-			eventCount += 1;
-			if (event.type === "error") terminal = { state: "failed", error: terminalError(event) };
-			else if (event.type === "result") {
-				if (event.subtype === "success" && event.is_error === false && typeof event.result === "string" && event.result.trim()) {
-					terminal = { state: "completed", output: event.result.trim() };
-				} else terminal = { state: "failed", error: terminalError(event) };
-			}
-			return { phase: terminal ? terminal.state : "streaming", eventCount };
-		},
-		skipOversizedLine(prefix, byteLength): ExternalCliParserProgress | undefined {
-			if (terminal || byteLength > MAX_OVERSIZED_TOOL_CALL_BYTES || !/^\s*\{\s*"type"\s*:\s*"tool_call"\s*,/.test(prefix)) return undefined;
-			eventCount += 1;
-			return { phase: "streaming", eventCount };
-		},
-		finish(): ExternalCliParserTerminal | undefined {
-			return terminal;
-		},
-	};
-}
-
-export function resolveCursorAgentLaunch(input: {
-	adapter: typeof CURSOR_AGENT_ADAPTER_ID | typeof CURSOR_AGENT_WRITER_ADAPTER_ID;
-	command: string;
-	cwd: string;
-	asyncDir: string;
-	stepIndex: number;
-	/** Test-only executable prefix for a fake Cursor Agent process. */
-	commandPrefixArgs?: readonly string[];
-}): {
-	command: string;
-	args: string[];
-	finalOutputPath?: undefined;
-	promptFilePath: string;
-	temporaryDirectories: string[];
-	environment: { allowlist: readonly string[] };
-	preflight: ExternalCliPreflightSpec;
-	parser: ExternalCliParser;
-} {
-	const writer = input.adapter === CURSOR_AGENT_WRITER_ADAPTER_ID;
-	const promptDirectory = path.join(input.asyncDir, `external-${input.stepIndex}.cursor-prompt`);
-	const promptFilePath = path.join(promptDirectory, "handoff.txt");
-	const promptRelative = path.relative(input.cwd, promptDirectory);
-	const promptOutsideWorkspace = promptRelative.startsWith("..") || path.isAbsolute(promptRelative);
-	const prefix = [...(input.commandPrefixArgs ?? [])];
-	const args = [
-		...prefix,
-		"-p",
-		"--output-format", "stream-json",
-		...(writer ? [] : ["--mode", "ask"]),
-		"--sandbox", "enabled",
-		"--workspace", input.cwd,
-		...(promptOutsideWorkspace ? ["--add-dir", promptDirectory] : []),
-		`Read the complete handoff from the private file at ${promptFilePath}. Follow it and return only the final answer.`,
-	];
-	return {
-		command: input.command,
-		args,
-		promptFilePath,
-		temporaryDirectories: [promptDirectory],
-		environment: { allowlist: CURSOR_AGENT_ENV_ALLOWLIST },
-		preflight: {
-			id: input.adapter,
-			versionArgs: [...prefix, "--version"],
-			helpArgs: [...prefix, "--help"],
-			validate(result) {
-				if (!/^\d{4}\.\d{2}\.\d{2}-[0-9a-f]+$/.test(result.version)) throw new Error(`Unsupported Cursor Agent version response: ${JSON.stringify(result.version)}.`);
-				for (const required of ["Start the Cursor Agent", "--print", "stream-json", "--sandbox <mode>", "enabled", "--workspace <path-or-name>", "--add-dir <path>", ...(writer ? ["all tools", "including write and shell"] : ["--mode <mode>", "ask:", "read-only"])]) {
-					if (!result.help.includes(required)) throw new Error(`Cursor Agent help does not document required option ${JSON.stringify(required)}.`);
-				}
-			},
-		},
-		parser: createCursorAgentJsonlParser(),
-	};
-}

package/src/runs/shared/dynamic-fanout.ts

@@ -1,297 +0,0 @@
-import type { DynamicParallelStep, ParallelTaskItem } from "../../shared/settings.ts";
-import type { ArtifactPaths, ChainOutputMap, JsonSchemaObject, SingleResult } from "../../shared/types.ts";
-import { getSingleResultOutput } from "../../shared/utils.ts";
-import { validateStructuredOutputValue } from "./structured-output.ts";
-
-export class DynamicFanoutError extends Error {}
-
-export interface DynamicFanoutConfig {
-	maxItems?: number;
-	allowRunnerFields?: boolean;
-}
-
-export interface DynamicMaterializedItem {
-	index: number;
-	key: string;
-	idKey: string;
-	item: unknown;
-}
-
-export interface DynamicCollectedResult {
-	key: string;
-	index: number;
-	item: unknown;
-	agent: string;
-	exitCode: number | null;
-	text: string;
-	structured?: unknown;
-	error?: string;
-	timedOut?: boolean;
-	stopped?: boolean;
-	outputPath?: string;
-	artifactPaths?: ArtifactPaths;
-}
-
-export interface DynamicMaterializedGroup {
-	items: DynamicMaterializedItem[];
-	parallel: ParallelTaskItem[];
-	collectedOnEmpty?: DynamicCollectedResult[];
-}
-
-const SAFE_OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const ITEM_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const ITEM_REF_PATTERN = /\{([A-Za-z_][A-Za-z0-9_]*)(?:\.([^{}]+))?\}/g;
-const RESERVED_TEMPLATE_NAMES = new Set(["task", "previous", "chain_dir", "outputs"]);
-const DYNAMIC_STEP_KEYS = new Set(["expand", "parallel", "collect", "concurrency", "failFast", "phase", "label", "acceptance", "agentContract", "gateOn"]);
-const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "sessionFiles", "thinkingOverrides"]);
-const DYNAMIC_EXPAND_KEYS = new Set(["from", "item", "key", "maxItems", "onEmpty"]);
-const DYNAMIC_EXPAND_FROM_KEYS = new Set(["output", "path"]);
-const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "machine", "output", "outputMode", "reads", "progress", "skill", "model", "fast", "toolBudget", "acceptance", "agentContract", "gateOn"]);
-const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
-	...DYNAMIC_PARALLEL_KEYS,
-	"outputName", "structured", "inheritProjectContext", "inheritGlobalContext", "inheritSkills", "skills", "outputPath", "namespaceOutputPath", "maxSubagentDepth", "timeoutMs", "waitToolEnabled", "waitToolDefaultTimeoutMs",
-	"structuredOutput", "structuredOutputSchema", "tools", "excludeTools", "allowNestedSubagents", "extensions", "subagentOnlyExtensions", "mcpDirectTools", "mutationTools", "capabilityCeiling", "completionGuard", "systemPrompt",
-	"systemPromptMode", "thinking", "requestedModel", "sessionFile", "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "parentSessionId", "requiredExtensions", "launchResolvedExtensions", "requestedCwd", "machineEnv",
-]);
-const DYNAMIC_COLLECT_KEYS = new Set(["as", "outputSchema"]);
-
-export function isSafeOutputName(name: string): boolean {
-	return SAFE_OUTPUT_NAME_PATTERN.test(name);
-}
-
-export function assertJsonPointer(pointer: string, label: string): void {
-	if (pointer === "") return;
-	if (!pointer.startsWith("/")) {
-		throw new DynamicFanoutError(`${label} must be a JSON Pointer starting with '/'.`);
-	}
-	for (const segment of pointer.slice(1).split("/")) {
-		if (/~(?![01])/.test(segment)) {
-			throw new DynamicFanoutError(`${label} contains invalid JSON Pointer escape.`);
-		}
-	}
-}
-
-function decodePointerSegment(segment: string): string {
-	return segment.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-
-export function resolveJsonPointer(value: unknown, pointer: string, label: string): unknown {
-	assertJsonPointer(pointer, label);
-	if (pointer === "") return value;
-	let current = value;
-	for (const rawSegment of pointer.slice(1).split("/")) {
-		const segment = decodePointerSegment(rawSegment);
-		if (Array.isArray(current)) {
-			if (!/^(0|[1-9][0-9]*)$/.test(segment)) {
-				throw new DynamicFanoutError(`${label} segment '${segment}' does not address an array index.`);
-			}
-			const index = Number(segment);
-			if (index >= current.length) throw new DynamicFanoutError(`${label} does not exist.`);
-			current = current[index];
-			continue;
-		}
-		if (!current || typeof current !== "object") {
-			throw new DynamicFanoutError(`${label} does not exist.`);
-		}
-		const record = current as Record<string, unknown>;
-		if (!Object.prototype.hasOwnProperty.call(record, segment)) {
-			throw new DynamicFanoutError(`${label} does not exist.`);
-		}
-		current = record[segment];
-	}
-	return current;
-}
-
-function scalarToKey(value: unknown, label: string): string {
-	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-		const key = String(value);
-		if (!key.trim()) throw new DynamicFanoutError(`${label} resolved to an empty key.`);
-		if (/[\u0000-\u001F\u007F]/.test(key)) throw new DynamicFanoutError(`${label} resolved to an unsafe key.`);
-		if (key.length > 200) throw new DynamicFanoutError(`${label} resolved to a key longer than 200 characters.`);
-		return key;
-	}
-	throw new DynamicFanoutError(`${label} must resolve to a string, number, or boolean.`);
-}
-
-export function normalizeItemKeyForId(key: string): string {
-	const normalized = key
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-")
-		.replace(/^-+|-+$/g, "")
-		.slice(0, 80);
-	return normalized || "item";
-}
-
-function valueToTemplateText(value: unknown, reference: string): string {
-	if (value === undefined) throw new DynamicFanoutError(`Unresolved item reference '${reference}'.`);
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean" || value === null) return String(value);
-	return JSON.stringify(value);
-}
-
-function resolveItemPath(item: unknown, pathText: string | undefined, reference: string): unknown {
-	if (!pathText) return item;
-	const pointer = `/${pathText.split(".").map((segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1")).join("/")}`;
-	return resolveJsonPointer(item, pointer, reference);
-}
-
-export function resolveItemTemplate(template: string, itemName: string, item: unknown): string {
-	return template.replace(ITEM_REF_PATTERN, (raw, name: string, pathText: string | undefined) => {
-		if (name !== itemName) return raw;
-		if (pathText !== undefined && (!pathText.trim() || pathText.includes(".."))) {
-			throw new DynamicFanoutError(`Invalid item reference '${raw}'.`);
-		}
-		return valueToTemplateText(resolveItemPath(item, pathText, raw), raw);
-	});
-}
-
-function assertOnlyKeys(value: unknown, allowed: Set<string>, label: string): void {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new DynamicFanoutError(`${label} must be an object.`);
-	for (const key of Object.keys(value)) {
-		if (!allowed.has(key)) throw new DynamicFanoutError(`${label} does not support field '${key}'.`);
-	}
-}
-
-export function assertNoUnresolvedItemReferences(template: string, itemName: string, label: string): void {
-	for (const match of template.matchAll(/\{([^{}]*)\}/g)) {
-		const raw = match[0]!;
-		const reference = match[1]!;
-		if (reference === itemName || reference.startsWith(`${itemName}.`)) {
-			if (!ITEM_REF_PATTERN.test(raw) || reference === `${itemName}.` || reference.includes("..")) {
-				throw new DynamicFanoutError(`Invalid item reference '${raw}' in ${label}.`);
-			}
-			ITEM_REF_PATTERN.lastIndex = 0;
-			continue;
-		}
-		ITEM_REF_PATTERN.lastIndex = 0;
-		const name = reference.match(/^[A-Za-z_][A-Za-z0-9_]*/)?.[0];
-		if (name === itemName) throw new DynamicFanoutError(`Invalid item reference '${raw}' in ${label}.`);
-		if (name && RESERVED_TEMPLATE_NAMES.has(name)) continue;
-		if (name) throw new DynamicFanoutError(`Unsupported template reference '${raw}' in ${label}.`);
-	}
-	ITEM_REF_PATTERN.lastIndex = 0;
-	if (template.includes(`{${itemName}.}`) || new RegExp(`\\{${itemName}(?:\\.|$)[^}]*$`).test(template)) {
-		throw new DynamicFanoutError(`Invalid item reference in ${label}.`);
-	}
-}
-
-export function hasDynamicFanoutFields(step: unknown): boolean {
-	return !!step && typeof step === "object" && !Array.isArray(step)
-		&& (Object.prototype.hasOwnProperty.call(step, "expand") || Object.prototype.hasOwnProperty.call(step, "collect"));
-}
-
-export function validateDynamicStepShape(step: DynamicParallelStep, stepIndex: number, config: DynamicFanoutConfig = {}): void {
-	const prefix = `Dynamic chain step ${stepIndex + 1}`;
-	assertOnlyKeys(step, config.allowRunnerFields ? RUNNER_DYNAMIC_STEP_KEYS : DYNAMIC_STEP_KEYS, prefix);
-	if (!step.expand || !step.expand.from) throw new DynamicFanoutError(`${prefix} requires expand.from.`);
-	assertOnlyKeys(step.expand, DYNAMIC_EXPAND_KEYS, `${prefix} expand`);
-	assertOnlyKeys(step.expand.from, DYNAMIC_EXPAND_FROM_KEYS, `${prefix} expand.from`);
-	if (!isSafeOutputName(step.expand.from.output)) throw new DynamicFanoutError(`${prefix} has invalid expand.from.output '${step.expand.from.output}'.`);
-	assertJsonPointer(step.expand.from.path, `${prefix} expand.from.path`);
-	if (step.expand.key !== undefined) assertJsonPointer(step.expand.key, `${prefix} expand.key`);
-	const itemName = step.expand.item ?? "item";
-	if (!ITEM_NAME_PATTERN.test(itemName)) throw new DynamicFanoutError(`${prefix} has invalid expand.item '${itemName}'.`);
-	if (step.expand.maxItems === undefined && config.maxItems === undefined) {
-		throw new DynamicFanoutError(`${prefix} requires expand.maxItems or config.chain.dynamicFanout.maxItems.`);
-	}
-	if (step.expand.maxItems !== undefined && (!Number.isInteger(step.expand.maxItems) || step.expand.maxItems < 0)) {
-		throw new DynamicFanoutError(`${prefix} expand.maxItems must be an integer >= 0.`);
-	}
-	if (config.maxItems !== undefined && (!Number.isInteger(config.maxItems) || config.maxItems < 0)) {
-		throw new DynamicFanoutError("config.chain.dynamicFanout.maxItems must be an integer >= 0.");
-	}
-	if (!step.parallel || Array.isArray(step.parallel)) throw new DynamicFanoutError(`${prefix} requires a single parallel template object and cannot mix dynamic expand/collect with static parallel arrays.`);
-	assertOnlyKeys(step.parallel, config.allowRunnerFields ? RUNNER_DYNAMIC_PARALLEL_KEYS : DYNAMIC_PARALLEL_KEYS, `${prefix} parallel`);
-	if ("expand" in (step.parallel as object)) throw new DynamicFanoutError(`${prefix} does not support nested dynamic fanout.`);
-	if (!step.parallel.agent) throw new DynamicFanoutError(`${prefix} parallel.agent is required.`);
-	if (!step.collect?.as || !isSafeOutputName(step.collect.as)) throw new DynamicFanoutError(`${prefix} requires collect.as with a safe output name.`);
-	assertOnlyKeys(step.collect, DYNAMIC_COLLECT_KEYS, `${prefix} collect`);
-	for (const [label, template] of [
-		["parallel.task", step.parallel.task],
-		["parallel.label", step.parallel.label],
-	] as const) {
-		if (template) assertNoUnresolvedItemReferences(template, itemName, `${prefix} ${label}`);
-	}
-}
-
-export function resolveDynamicFanoutItems(step: DynamicParallelStep, outputs: ChainOutputMap, stepIndex: number, config: DynamicFanoutConfig = {}): DynamicMaterializedItem[] {
-	validateDynamicStepShape(step, stepIndex, config);
-	const sourceName = step.expand.from.output;
-	const source = outputs[sourceName];
-	if (!source) throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} references unknown output '${sourceName}'.`);
-	if (source.structured === undefined) throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} requires structured output '${sourceName}'.`);
-	const value = resolveJsonPointer(source.structured, step.expand.from.path, `Dynamic chain step ${stepIndex + 1} expand.from.path`);
-	if (!Array.isArray(value)) throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} expand.from.path must resolve to an array.`);
-	const maxItems = step.expand.maxItems ?? config.maxItems;
-	if (maxItems === undefined) throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} requires an effective maxItems.`);
-	if (value.length > maxItems) throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} resolved ${value.length} items, exceeding maxItems ${maxItems}.`);
-	const seen = new Set<string>();
-	const seenIds = new Set<string>();
-	return value.map((item, index) => {
-		const key = step.expand.key === undefined
-			? String(index)
-			: scalarToKey(resolveJsonPointer(item, step.expand.key, `Dynamic chain step ${stepIndex + 1} expand.key`), `Dynamic chain step ${stepIndex + 1} expand.key`);
-		if (seen.has(key)) throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} produced duplicate item key '${key}'.`);
-		seen.add(key);
-		const idKey = normalizeItemKeyForId(key);
-		if (seenIds.has(idKey)) throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} produced colliding item id '${idKey}'.`);
-		seenIds.add(idKey);
-		return { index, key, idKey, item };
-	});
-}
-
-export function materializeDynamicParallelStep(step: DynamicParallelStep, outputs: ChainOutputMap, stepIndex: number, config: DynamicFanoutConfig = {}): DynamicMaterializedGroup {
-	const items = resolveDynamicFanoutItems(step, outputs, stepIndex, config);
-	if (items.length === 0) {
-		if ((step.expand.onEmpty ?? "skip") === "fail") {
-			throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} source array is empty.`);
-		}
-		return { items, parallel: [], collectedOnEmpty: [] };
-	}
-	const itemName = step.expand.item ?? "item";
-	const parallel = items.map((entry) => {
-		const task = resolveItemTemplate(step.parallel.task ?? "{previous}", itemName, entry.item);
-		const label = step.parallel.label ? resolveItemTemplate(step.parallel.label, itemName, entry.item) : undefined;
-		return {
-			...step.parallel,
-			task,
-			...(label !== undefined ? { label } : {}),
-		};
-	});
-	return { items, parallel };
-}
-
-export function collectDynamicResults(
-	step: DynamicParallelStep,
-	items: DynamicMaterializedItem[],
-	results: Array<Pick<SingleResult, "agent" | "error" | "timedOut" | "stopped" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & { exitCode: number | null; output?: string; finalOutput?: string }>,
-): DynamicCollectedResult[] {
-	return items.map((entry, index) => {
-		const result = results[index];
-		const text = result
-			? ("output" in result && typeof result.output === "string" ? result.output : getSingleResultOutput(result as SingleResult))
-			: "";
-		return {
-			key: entry.key,
-			index: entry.index,
-			item: entry.item,
-			agent: result?.agent ?? step.parallel.agent,
-			exitCode: result?.exitCode ?? null,
-			text,
-			...(result?.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),
-			...(result?.error ? { error: result.error } : {}),
-			...(result?.timedOut ? { timedOut: true } : {}),
-			...(result?.stopped ? { stopped: true } : {}),
-			...(result?.savedOutputPath ? { outputPath: result.savedOutputPath } : {}),
-			...(result?.artifactPaths ? { artifactPaths: result.artifactPaths } : {}),
-		};
-	});
-}
-
-export async function validateDynamicCollection(schema: JsonSchemaObject | undefined, value: DynamicCollectedResult[]): Promise<void> {
-	if (!schema) return;
-	const validation = await validateStructuredOutputValue(schema, value);
-	if (validation.status === "invalid") {
-		throw new DynamicFanoutError(`Collected output validation failed: ${validation.message}`);
-	}
-}

package/src/runs/shared/effective-system-prompt.ts

@@ -1,33 +0,0 @@
-import type { AgentConfig } from "../../agents/agents.ts";
-import { buildAgentMemoryInjection } from "../../agents/agent-memory.ts";
-import { appendAgentRefinementOverlay } from "../../agents/agent-refinements.ts";
-import { buildSkillInjection } from "../../agents/skills.ts";
-import { injectOutputPathSystemPrompt } from "./single-output.ts";
-
-export interface EffectiveSystemPromptInput {
-	/** Agent as handed to the child, including runtime-declared overlays such as the Intercom bridge. */
-	agent: AgentConfig;
-	resolvedSkills: Parameters<typeof buildSkillInjection>[0];
-	/** Directory that scopes memory and refinement lookups. */
-	cwd: string;
-	/** Omit when the caller injects the output path through another channel. */
-	outputPath?: string;
-}
-
-function appendSection(prompt: string, section: string): string {
-	return prompt ? `${prompt}\n\n${section}` : section;
-}
-
-/**
- * Child system prompt in the order preflight and every execution path hash:
- * base prompt, skills, memory, refinement overlay, output path. Runtime
- * acceptance prose is appended later and stays outside launch identity.
- */
-export function buildEffectiveSystemPrompt(input: EffectiveSystemPromptInput): string {
-	let prompt = input.agent.systemPrompt?.trim() ?? "";
-	if (input.resolvedSkills.length > 0) prompt = appendSection(prompt, buildSkillInjection(input.resolvedSkills));
-	const memoryInjection = buildAgentMemoryInjection(input.agent, input.cwd);
-	if (memoryInjection) prompt = appendSection(prompt, memoryInjection);
-	prompt = appendAgentRefinementOverlay(prompt, { cwd: input.cwd, agentName: input.agent.name });
-	return injectOutputPathSystemPrompt(prompt, input.outputPath, input.agent);
-}

package/src/runs/shared/extension-bindings.ts

@@ -1,78 +0,0 @@
-export const PI_SUBAGENT_EXTENSION_BINDINGS_ENV = "PI_SUBAGENT_EXTENSION_BINDINGS";
-export const MAX_EXTENSION_BINDING_NAMESPACES = 16;
-export const MAX_EXTENSION_BINDINGS_BYTES = 16 * 1024;
-export const MAX_EXTENSION_BINDINGS_DEPTH = 16;
-export const MAX_EXTENSION_BINDINGS_PROPERTIES = 256;
-
-const EXTENSION_BINDING_NAMESPACE = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,62})\/[1-9][0-9]{0,8}$/;
-
-export type ExtensionBindingJson = null | boolean | number | string | ReadonlyArray<ExtensionBindingJson> | { readonly [key: string]: ExtensionBindingJson };
-export type ExtensionBindings = Readonly<Record<string, ExtensionBindingJson>>;
-
-export interface NormalizedExtensionBindings {
-	value: ExtensionBindings;
-	json: string;
-}
-
-function canonicalizeJson(value: unknown, path: string, depth: number, seen: Set<object>, propertyCount: { value: number }): ExtensionBindingJson {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new Error(`${path} must contain only finite JSON numbers.`);
-		return value;
-	}
-	if (typeof value !== "object") throw new Error(`${path} must contain only plain JSON values.`);
-	if (depth > MAX_EXTENSION_BINDINGS_DEPTH) throw new Error(`${path} exceeds the maximum nesting depth of ${MAX_EXTENSION_BINDINGS_DEPTH}.`);
-	if (seen.has(value)) throw new Error(`${path} must not contain cycles.`);
-	seen.add(value);
-	try {
-		if (Array.isArray(value)) {
-			const output: ExtensionBindingJson[] = [];
-			for (let index = 0; index < value.length; index++) {
-				if (!Object.prototype.hasOwnProperty.call(value, index)) throw new Error(`${path} must not contain sparse arrays.`);
-				output.push(canonicalizeJson(value[index], `${path}[${index}]`, depth + 1, seen, propertyCount));
-			}
-			return Object.freeze(output);
-		}
-		const prototype = Object.getPrototypeOf(value);
-		if (prototype !== Object.prototype && prototype !== null) throw new Error(`${path} must contain only plain JSON objects.`);
-		if (Object.getOwnPropertySymbols(value).length > 0) throw new Error(`${path} must not contain symbol keys.`);
-		const descriptors = Object.getOwnPropertyDescriptors(value);
-		const output: Record<string, ExtensionBindingJson> = {};
-		for (const key of Object.keys(descriptors).sort()) {
-			const descriptor = descriptors[key]!;
-			if (!descriptor.enumerable || !("value" in descriptor)) throw new Error(`${path}.${key} must be an enumerable data property.`);
-			propertyCount.value += 1;
-			if (propertyCount.value > MAX_EXTENSION_BINDINGS_PROPERTIES) throw new Error(`extensionBindings exceeds ${MAX_EXTENSION_BINDINGS_PROPERTIES} total properties.`);
-			Object.defineProperty(output, key, { value: canonicalizeJson(descriptor.value, `${path}.${key}`, depth + 1, seen, propertyCount), enumerable: true, writable: false, configurable: false });
-		}
-		return Object.freeze(output);
-	} finally {
-		seen.delete(value);
-	}
-}
-
-export function normalizeExtensionBindings(input: unknown): NormalizedExtensionBindings | undefined {
-	if (input === undefined) return undefined;
-	if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("extensionBindings must be a plain JSON object.");
-	const prototype = Object.getPrototypeOf(input);
-	if (prototype !== Object.prototype && prototype !== null) throw new Error("extensionBindings must be a plain JSON object.");
-	const keys = Object.keys(input);
-	if (keys.length > MAX_EXTENSION_BINDING_NAMESPACES) throw new Error(`extensionBindings supports at most ${MAX_EXTENSION_BINDING_NAMESPACES} namespaces.`);
-	for (const key of keys) {
-		if (!EXTENSION_BINDING_NAMESPACE.test(key)) throw new Error(`extensionBindings namespace '${key}' must use a package-like name followed by '/<positive-version>'.`);
-	}
-	const value = canonicalizeJson(input, "extensionBindings", 0, new Set(), { value: 0 }) as ExtensionBindings;
-	const json = JSON.stringify(value);
-	const bytes = Buffer.byteLength(json, "utf8");
-	if (bytes > MAX_EXTENSION_BINDINGS_BYTES) throw new Error(`extensionBindings canonical JSON is ${bytes} bytes; maximum is ${MAX_EXTENSION_BINDINGS_BYTES}.`);
-	return { value, json };
-}
-
-export function encodeExtensionBindings(input: ExtensionBindings | undefined): string | undefined {
-	return input === undefined ? undefined : normalizeExtensionBindings(input)!.json;
-}
-
-export function omitExtensionBindingsEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
-	const { [PI_SUBAGENT_EXTENSION_BINDINGS_ENV]: _extensionBindings, ...sanitized } = env;
-	return sanitized;
-}