Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/pipi/runtime.ts

Raw
import { isAbsolute, resolve } from "node:path";
import type {
	AssistantMessage,
	ImageContent,
	JsonValue,
	Usage,
} from "@earendil-works/pi-ai";
import {
	type AgentSession,
	type AgentSessionEvent,
	type BuildSystemPromptOptions,
	createAgentSession,
	createCodemodeExtension,
	createMcpExtension,
	createToolSearchExtension,
	DefaultResourceLoader,
	defineTool,
	type ExtensionAPI,
	type ExtensionToolContext,
	getAgentDir,
	ModelRuntime,
	type SessionEntry,
	SessionManager,
} from "@earendil-works/pi-coding-agent";
import { Type } from "typebox";
import {
	type Config,
	discover,
	effectiveTiers,
	instructions,
	selectModel,
	type TierSettings,
} from "./config.ts";
import { childResources } from "./resources.ts";
import { dbg, span } from "./src/debug.ts";

export interface TaskRequest extends Config {
	prompt: string;
	images?: ImageContent[];
	agent?: string;
	cwd?: string;
	sessionId?: string;
	fork?: boolean;
}
export interface Inheritance {
	tools: string[];
	availableTools: string[];
	extensions: string[];
	prompt: Pick<
		BuildSystemPromptOptions,
		| "sections"
		| "customPrompt"
		| "appendSystemPrompt"
		| "forceSystemPrompt"
		| "contextFiles"
	>;
}
export interface Progress {
	phase: string;
	preview: string;
	tool?: { name: string; args: string };
}
export interface TaskResult {
	outputMode: "message" | "structured";
	outcome: "completed" | "aborted" | "error" | "failed";
	output: JsonValue;
	assistantMessage: AssistantMessage | null;
	sessionId: string;
	sessionFile: string | null;
	durationMs: number;
	turns: number;
	usage: Usage;
	requested: Config;
	effective: {
		cwd: string;
		model: string | null;
		thinkingLevel: string;
		tools: string[];
		excludedTools?: string[];
		extensions: string[];
		skills?: string[];
		prompts?: string[];
		flagNames?: string[];
		sections?: string[];
	};
	diagnostics: string[];
}
export function emptyUsage(): Usage {
	return {
		input: 0,
		output: 0,
		cacheRead: 0,
		cacheWrite: 0,
		totalTokens: 0,
		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
	};
}
function addUsage(total: Usage, value: Usage): void {
	const totalFromProvider = total.cost.totalFromProvider;
	const valueFromProvider = value.cost.totalFromProvider === true;
	for (const key of [
		"input",
		"output",
		"cacheRead",
		"cacheWrite",
		"totalTokens",
	] as const)
		total[key] += value[key];
	for (const key of [
		"input",
		"output",
		"cacheRead",
		"cacheWrite",
		"total",
	] as const)
		total.cost[key] += value.cost[key];
	total.cost.totalFromProvider =
		totalFromProvider === undefined
			? valueFromProvider
			: totalFromProvider && valueFromProvider;
	if (value.reasoning !== undefined)
		total.reasoning = (total.reasoning ?? 0) + value.reasoning;
	if (value.cacheWrite1h !== undefined)
		total.cacheWrite1h = (total.cacheWrite1h ?? 0) + value.cacheWrite1h;
}
export function newUsage(entries: SessionEntry[], before: Set<string>): Usage {
	const total = emptyUsage();
	for (const entry of entries) {
		if (before.has(entry.id)) continue;
		if (entry.type === "message") {
			const message = entry.message;
			if (
				(message.role === "assistant" || message.role === "toolResult") &&
				message.usage
			)
				addUsage(total, message.usage);
		} else if ("usage" in entry && entry.usage) addUsage(total, entry.usage);
	}
	return total;
}
export function json(value: unknown): JsonValue {
	return JSON.parse(JSON.stringify(value)) as JsonValue;
}
/** Upper bound on child teardown; a wedged child is disposed forcefully after it. */
const TEARDOWN_TIMEOUT_MS = 5_000;
function delay(ms: number): Promise<void> {
	return new Promise((resolve) => {
		const timer = setTimeout(resolve, ms);
		timer.unref();
	});
}

const OUTPUT_GUIDANCE =
	"Submit the result with pipi_output, alone as your final action. Do not substitute an ordinary final answer. Submit only after completing the task. Corrections are allowed: the last valid submission wins.";
const OUTPUT_SUFFIX =
	"\n<pipi_output>\n" + OUTPUT_GUIDANCE + "\n</pipi_output>";
export function outputParameters(
	schema: Record<string, unknown>,
): ReturnType<typeof Type.Unsafe> {
	// A resource boundary preserves caller-local references without rewriting schema or literal data.
	return Type.Unsafe({
		type: "object",
		properties: { output: { $id: "https://pi.local/pipi/output/", ...schema } },
		required: ["output"],
		additionalProperties: false,
	});
}
export function snapshotPrompt(
	options: Inheritance["prompt"],
): Inheritance["prompt"] {
	const force = options.forceSystemPrompt;
	return structuredClone({
		contextFiles: options.contextFiles ?? [],
		sections: Object.fromEntries(
			Object.entries(options.sections ?? {}).filter(
				([name]) =>
					name !== "pipi_output" &&
					name !== "pipi_library" &&
					name !== "pipi_tiers",
			),
		),
		...(options.customPrompt !== undefined
			? { customPrompt: options.customPrompt }
			: {}),
		...(options.appendSystemPrompt !== undefined
			? { appendSystemPrompt: options.appendSystemPrompt }
			: {}),
		...(force !== undefined
			? {
					forceSystemPrompt: force.endsWith(OUTPUT_SUFFIX)
						? force.slice(0, -OUTPUT_SUFFIX.length)
						: force,
				}
			: {}),
	});
}
const builtins = [
	{
		name: "codemode",
		factory: createCodemodeExtension(),
		builtin: true,
		replaceable: true,
	},
	{
		name: "tool-search",
		factory: createToolSearchExtension(),
		builtin: true,
		replaceable: true,
	},
	{
		name: "mcp",
		factory: createMcpExtension(),
		builtin: true,
		replaceable: true,
	},
];
async function managerFor(
	ctx: ExtensionToolContext,
	request: TaskRequest,
	cwdOverride: string | undefined,
): Promise<SessionManager> {
	const end = span?.(
		request.sessionId
			? request.fork
				? "session.fork"
				: "session.open"
			: "session.create",
	);
	try {
		const parentSession = ctx.sessionManager.getSessionFile();
		const directory = ctx.sessionManager.getSessionDir() || undefined;
		if (!request.sessionId) {
			if (request.fork) {
				if (!parentSession)
					throw new Error("pipi: cannot fork an unpersisted parent session");
				return SessionManager.forkFrom(
					parentSession,
					cwdOverride ?? ctx.cwd,
					directory,
					{
						parentSession,
					},
				);
			}
			return SessionManager.create(
				cwdOverride ?? ctx.cwd,
				directory,
				parentSession ? { parentSession } : undefined,
			);
		}
		let file = request.sessionId;
		if (!isAbsolute(file) && !file.includes("/") && !file.includes("\\")) {
			const found =
				SessionManager.findById(cwdOverride ?? ctx.cwd, file, directory) ??
				(await SessionManager.listAll(directory, undefined, ctx.signal)).find(
					(session) => session.id === file,
				)?.path;
			if (!found)
				throw new Error(
					`pipi: sessionId not found: ${file}; use the returned sessionFile for another workspace`,
				);
			file = found;
		}
		return request.fork
			? SessionManager.forkFrom(
					file,
					cwdOverride ?? ctx.cwd,
					directory,
					parentSession ? { parentSession } : undefined,
				)
			: SessionManager.open(file, directory, cwdOverride);
	} finally {
		end?.();
	}
}
function copyProviders(ctx: ExtensionToolContext, runtime: ModelRuntime): void {
	for (const id of ctx.modelRegistry.getRegisteredProviderIds()) {
		const native = ctx.modelRegistry.getRegisteredNativeProvider(id);
		if (native) runtime.registerNativeProvider(native);
		else {
			const config = ctx.modelRegistry.getRegisteredProviderConfig(id);
			if (config) runtime.registerProvider(id, config);
		}
	}
}
async function inheritAuthentication(
	ctx: ExtensionToolContext,
	runtime: ModelRuntime,
	signal?: AbortSignal,
): Promise<void> {
	// Delegate resolution, not credential storage: parent owns OAuth refresh and runtime-key precedence.
	const models = ctx.modelRegistry.getAll();
	for (const id of new Set(models.map((model) => model.provider))) {
		if (!ctx.modelRegistry.getProviderAuthStatus(id).configured) continue;
		const provider =
			runtime.getProvider(id) ?? ctx.modelRegistry.getProvider(id);
		if (!provider) continue;
		const model = models.find((value) => value.provider === id);
		runtime.registerNativeProvider({
			...provider,
			auth: {
				...provider.auth,
				apiKey: {
					name: "Parent session authentication",
					check: async () =>
						ctx.modelRegistry.getProviderAuthStatus(id).configured
							? {
									type:
										model && ctx.modelRegistry.isUsingOAuth(model)
											? ("oauth" as const)
											: ("api_key" as const),
									source: "parent session",
								}
							: undefined,
					resolve: async () => ctx.modelRegistry.getProviderAuth(id),
				},
			},
		});
	}
	await runtime.refresh({ allowNetwork: false, ...(signal ? { signal } : {}) });
}
function applyFlags(
	loader: DefaultResourceLoader,
	overrides: Config["flags"],
	inherited: Map<string, string | boolean>,
): void {
	const loaded = loader.getExtensions();
	const registered = new Map(
		loaded.extensions.flatMap((extension) => [...extension.flags]),
	);
	for (const [name, value] of inherited) {
		const flag = registered.get(name);
		if (flag?.type === "boolean") loaded.runtime.flagValues.set(name, true);
		else if (flag?.type === "string" && typeof value === "string")
			loaded.runtime.flagValues.set(name, value);
	}
	for (const [name, value] of Object.entries(overrides ?? {})) {
		const flag = registered.get(name);
		if (!flag) throw new Error(`pipi: flag --${name} not registered in child`);
		if (typeof value !== flag.type)
			throw new Error(`pipi: flag --${name} expects ${flag.type}`);
		loaded.runtime.flagValues.set(name, value);
	}
}
const SESSION_NAME_MAX = 120;
// Mirrors dilemma's named children so `pi --resume` shows recognisable entries.
export function sessionName(request: TaskRequest, config: Config): string {
	const kind = request.agent ?? config.tier ?? config.model ?? "task";
	const task = request.prompt.replace(/\s+/gu, " ").trim();
	return `PiPi · ${kind} · ${task}`.slice(0, SESSION_NAME_MAX);
}
export async function runTask(
	ctx: ExtensionToolContext,
	request: TaskRequest,
	inherited: Inheritance,
	tiers: TierSettings,
	defaultTimeoutMs: number,
	signal?: AbortSignal,
	progress?: (value: Progress) => void,
	activity?: (event: AgentSessionEvent, child: AgentSession) => void,
): Promise<TaskResult> {
	const started = performance.now();
	const taskEnd = span?.("task", {
		hasSchema: !!request.outputSchema,
		resumed: !!request.sessionId,
	});
	try {
		const agentDir = getAgentDir();
		const requestedCwd =
			request.cwd === undefined ? undefined : resolve(ctx.cwd, request.cwd);
		const catalog = await discover(agentDir);
		const presetEnd = span?.("preset");
		const preset = request.agent
			? catalog.agents.find((value) => value.name === request.agent)
			: undefined;
		if (request.agent && !preset)
			throw new Error(`pipi: preset unavailable: ${request.agent}`);
		const {
			prompt: _prompt,
			images: _images,
			agent: _agent,
			cwd: _cwd,
			sessionId: _sessionId,
			fork: _fork,
			...overrides
		} = request;
		const presetConfig = preset?.config ?? {};
		const { model: _presetModel, ...withoutModel } = presetConfig;
		const config: Config = structuredClone({
			...(request.tier !== undefined && request.model === undefined
				? withoutModel
				: presetConfig),
			...overrides,
		});
		for (const kind of ["extensions", "skills", "prompts"] as const) {
			if (presetConfig[kind] && overrides[kind])
				config[kind] = [...presetConfig[kind], ...overrides[kind]];
		}
		const body = await instructions(preset);
		if (body !== undefined && config.sections?.["pipi_agent"] === undefined)
			config.sections = { ...config.sections, pipi_agent: body };
		presetEnd?.();
		const deadline =
			config.timeoutMs === null
				? undefined
				: (config.timeoutMs ?? defaultTimeoutMs);
		const timeoutSignal =
			deadline === undefined ? undefined : AbortSignal.timeout(deadline);
		const taskSignal = timeoutSignal
			? signal
				? AbortSignal.any([signal, timeoutSignal])
				: timeoutSignal
			: signal;
		const schema = config.outputSchema;
		let effectivePrompt: BuildSystemPromptOptions | undefined;
		let submitted = false,
			output: JsonValue = null,
			reminded = false;
		let outcome: TaskResult["outcome"] = "completed";
		let assistantMessage: AssistantMessage | null = null;
		let turns = 0,
			firstModel = true;
		const diagnostics = [...catalog.diagnostics];
		const manager = await managerFor(ctx, request, requestedCwd);
		if (!request.sessionId || request.fork)
			manager.appendSessionInfo(sessionName(request, config));
		const cwd = manager.getCwd();
		const before = new Set(manager.getEntries().map((entry) => entry.id));
		let child:
			| Awaited<ReturnType<typeof createAgentSession>>["session"]
			| undefined;
		let unsubscribe: (() => void) | undefined;
		let modelEnd: ReturnType<NonNullable<typeof span>> | undefined;
		const toolSpans = new Map<string, ReturnType<NonNullable<typeof span>>>();
		const abort = () => {
			void child?.abort();
		};
		let effective: TaskResult["effective"] = {
			cwd,
			model: null,
			thinkingLevel: "off",
			tools: [],
			extensions: [],
		};
		try {
			taskSignal?.throwIfAborted();
			const runtime = await ModelRuntime.create({
				authPath: resolve(agentDir, "auth.json"),
				modelsPath: resolve(agentDir, "models.json"),
				refreshOnCreate: false,
				...(taskSignal ? { signal: taskSignal } : {}),
			});
			copyProviders(ctx, runtime);
			const loadEnd = span?.("resources");
			const { cli, settingsManager, extensions, skills, prompts } =
				await childResources(ctx, cwd, inherited, config);
			const controller = (pi: ExtensionAPI) => {
				if (schema)
					pi.registerTool(
						defineTool({
							name: "pipi_output",
							label: "Submit result",
							description: OUTPUT_GUIDANCE,
							promptGuidelines: [OUTPUT_GUIDANCE],
							exposure: "model-only",
							parameters: outputParameters(schema),
							async execute(_id, args) {
								output = json((args as { output: unknown }).output);
								submitted = true;
								dbg?.("output.submit", { hasSchema: true });
								return {
									content: [{ type: "text", text: "Result accepted." }],
									details: {},
									terminate: true,
								};
							},
						}),
					);
				pi.on("before_agent_start", (event) => {
					const options = event.systemPromptOptions;
					effectivePrompt = options;
					const base = inherited.prompt;
					if (base.customPrompt !== undefined)
						options.customPrompt = base.customPrompt;
					if (base.forceSystemPrompt !== undefined)
						options.forceSystemPrompt = base.forceSystemPrompt;
					if (
						base.appendSystemPrompt &&
						options.appendSystemPrompt !== base.appendSystemPrompt
					)
						options.appendSystemPrompt += "\n" + base.appendSystemPrompt;
					Object.assign(options.sections, base.sections);
					// Submission state and instructions never cross the parent/child boundary.
					delete options.sections["pipi_output"];
					if (config.customPrompt !== undefined)
						options.customPrompt = config.customPrompt;
					if (config.appendSystemPrompt)
						options.appendSystemPrompt += "\n" + config.appendSystemPrompt;
					Object.assign(options.sections, config.sections);
					if (config.forceSystemPrompt !== undefined)
						options.forceSystemPrompt = config.forceSystemPrompt;
					if (schema) {
						options.sections["pipi_output"] = OUTPUT_GUIDANCE;
						if (options.forceSystemPrompt !== undefined)
							options.forceSystemPrompt += OUTPUT_SUFFIX;
					}
				});
				pi.on("agent_before_settle", (event) => {
					outcome = event.outcome;
					if (event.outcome !== "completed" || !schema || submitted || reminded)
						return undefined;
					reminded = true;
					dbg?.("output.reminder", { hasSchema: true });
					return {
						entries: [
							{
								type: "custom_message",
								customType: "pipi_output_reminder",
								content: OUTPUT_GUIDANCE,
								display: false,
							},
						],
						continue: true,
					};
				});
			};
			const loader = new DefaultResourceLoader({
				cwd,
				agentDir,
				settingsManager,
				noExtensions: config.noExtensions ?? cli.noExtensions ?? false,
				noSkills: config.noSkills ?? cli.noSkills ?? false,
				noPromptTemplates:
					config.noPromptTemplates ?? cli.noPromptTemplates ?? false,
				noContextFiles: config.noContextFiles ?? cli.noContextFiles ?? false,
				additionalExtensionPaths: extensions,
				additionalSkillPaths: skills,
				additionalPromptTemplatePaths: prompts,
				agentsFilesOverride: (base) => ({
					agentsFiles:
						(config.noContextFiles ?? cli.noContextFiles)
							? []
							: [
									...new Map(
										[
											...(inherited.prompt.contextFiles ?? []),
											...base.agentsFiles,
										].map((file) => [file.path, file]),
									).values(),
								],
				}),
				extensionFactories: [...builtins, controller],
				...(cli.noMcp ? { disabledBuiltinExtensions: ["mcp"] } : {}),
			});
			await loader.reload();
			loadEnd?.();
			for (const error of loader.getExtensions().errors)
				diagnostics.push(`Extension unavailable: ${error.path}`);
			for (const issue of [
				...loader.getSkills().diagnostics,
				...loader.getPrompts().diagnostics,
			])
				diagnostics.push(
					`${issue.message}${issue.path ? ": " + issue.path : ""}`,
				);
			applyFlags(loader, config.flags, cli.unknownFlags);
			effective.extensions = loader
				.getExtensions()
				.extensions.map((extension) => extension.path);
			const ref = selectModel(config, tiers, ctx.model?.provider);
			const thinkingLevel =
				config.thinkingLevel ??
				(config.tier
					? effectiveTiers(tiers, ctx.model?.provider)[config.tier]
							.thinkingLevel
					: undefined);
			let model = request.sessionId || request.fork ? undefined : ctx.model;
			if (ref) {
				const slash = ref.indexOf("/");
				if (slash <= 0) throw new Error("pipi: model must be provider/model");
				model = ctx.modelRegistry
					.getAll()
					.find((candidate) => `${candidate.provider}/${candidate.id}` === ref);
				if (!model) throw new Error(`pipi: model unavailable: ${ref}`);
			}
			taskSignal?.throwIfAborted();
			await inheritAuthentication(ctx, runtime, taskSignal);
			const created = await createAgentSession({
				cwd,
				agentDir,
				resourceLoader: loader,
				modelRuntime: runtime,
				settingsManager,
				sessionManager: manager,
				...(model ? { model } : {}),
				...(thinkingLevel !== undefined
					? {
							thinkingLevel: thinkingLevel as NonNullable<
								ExtensionToolContext["thinkingLevel"]
							>,
						}
					: !request.sessionId && !request.fork && ctx.thinkingLevel
						? { thinkingLevel: ctx.thinkingLevel }
						: {}),
				// Tool selection is applied to the complete registry before native startup hooks.
			});
			child = created.session;
			if (created.modelFallbackMessage)
				diagnostics.push(created.modelFallbackMessage);
			taskSignal?.addEventListener("abort", abort, { once: true });
			const activeChild = child;
			unsubscribe = child.subscribe((event) => {
				activity?.(event, activeChild);
				if (event.type === "agent_start" && taskSignal?.aborted) abort();
				if (event.type === "turn_start") {
					modelEnd = span?.("model.request");
					progress?.({ phase: "running", preview: "" });
				}
				if (
					event.type === "message_update" &&
					event.assistantMessageEvent.type.endsWith("_delta") &&
					firstModel
				) {
					firstModel = false;
					dbg?.("model.first", { elapsedMs: performance.now() - started });
				}
				if (
					event.type === "message_end" &&
					event.message.role === "assistant"
				) {
					assistantMessage = event.message;
					modelEnd?.(
						event.message.stopReason === "error" ||
							event.message.stopReason === "aborted"
							? "error"
							: "finish",
					);
					modelEnd = undefined;
					turns++;
				}
				if (event.type === "tool_execution_start") {
					dbg?.("tool.start");
					const end = span?.("tool");
					if (end) toolSpans.set(event.toolCallId, end);
					progress?.({
						phase: "tool",
						preview: "",
						tool: {
							name: event.toolName,
							args: JSON.stringify(event.args, null, 2).slice(0, 6000),
						},
					});
				}
				if (event.type === "tool_execution_end") {
					dbg?.("tool.finish");
					toolSpans.get(event.toolCallId)?.(event.isError ? "error" : "finish");
					toolSpans.delete(event.toolCallId);
					if (event.toolName === "pipi_output" && event.isError)
						dbg?.("output.invalid", { count: 1 });
				}
				if (
					event.type === "message_update" &&
					event.message.role === "assistant" &&
					event.assistantMessageEvent.type === "text_delta"
				)
					progress?.({
						phase: "answering",
						preview: event.message.content
							.filter((part) => part.type === "text")
							.map((part) => part.text)
							.join("\n")
							.slice(-6000),
					});
			});
			// Recreate tools without an SDK registry allowlist, so native late registration remains possible.
			const { resolveToolNames } = await import("./tools.ts");
			const enhanced = child
				.getActiveToolNames()
				.filter((name) => !inherited.availableTools.includes(name));
			const baseline = [...new Set([...inherited.tools, ...enhanced])];
			child.setActiveToolsByName(
				config.tools ? resolveToolNames(config.tools, baseline) : baseline,
			);
			const extensionEnd = span?.("extensions");
			await child.bindExtensions({
				mode: "print",
				onError: (error) =>
					diagnostics.push(
						`Child extension failed: ${error.extensionPath} (${error.event}): ${error.error}`,
					),
			});
			extensionEnd?.();
			await inheritAuthentication(ctx, runtime, taskSignal);
			if (schema)
				child.setActiveToolsByName([
					...new Set([...child.getActiveToolNames(), "pipi_output"]),
				]);
			effective = {
				cwd,
				model: child.model ? `${child.model.provider}/${child.model.id}` : null,
				thinkingLevel: child.thinkingLevel,
				tools: child.getActiveToolNames(),
				extensions: effective.extensions,
				skills: loader.getSkills().skills.map((skill) => skill.filePath),
				prompts: loader.getPrompts().prompts.map((prompt) => prompt.filePath),
				flagNames: [...loader.getExtensions().runtime.flagValues.keys()],
			};
			const requestedTools = config.tools
				? resolveToolNames(config.tools, baseline)
				: inherited.tools;
			const registered = new Map(
				child.getAllTools().map((tool) => [tool.name, tool]),
			);
			const explicit = new Set(
				(config.tools ?? []).map((name) =>
					name.startsWith("+") ? name.slice(1) : name,
				),
			);
			const excluded: string[] = [];
			const hidden: string[] = [];
			const inactive: string[] = [];
			const unavailable: string[] = [];
			for (const name of requestedTools) {
				if (effective.tools.includes(name)) continue;
				const tool = registered.get(name);
				if (!tool) unavailable.push(name);
				else if (tool.exposure === "hidden")
					(explicit.has(name) ? hidden : excluded).push(name);
				else inactive.push(name);
			}
			if (excluded.length) effective.excludedTools = excluded;
			if (hidden.length)
				diagnostics.push(
					`Requested tools hidden by child extension: ${hidden.join(", ")}`,
				);
			if (inactive.length)
				diagnostics.push(`Requested tools inactive: ${inactive.join(", ")}`);
			if (unavailable.length)
				diagnostics.push(
					`Requested tools unavailable: ${unavailable.join(", ")}`,
				);
			progress?.({ phase: "running", preview: "" });
			taskSignal?.throwIfAborted();
			const settleEnd = span?.("settlement");
			let settle: Promise<void> | undefined;
			try {
				settle = child.prompt(request.prompt, {
					source: "extension",
					...(request.images ? { images: request.images } : {}),
				});
				if (timeoutSignal) {
					const deadlineRace = new Promise<"deadline">((resolve) => {
						timeoutSignal.addEventListener("abort", () => resolve("deadline"), {
							once: true,
						});
					});
					const winner = await Promise.race([
						settle.then(() => "settled" as const),
						deadlineRace,
					]);
					if (winner === "deadline") settle.catch(() => {});
				} else {
					await settle;
				}
			} finally {
				settleEnd?.();
			}
			if (taskSignal?.aborted) outcome = "aborted";
			if (outcome === "completed" && schema && !submitted) {
				outcome = "failed";
				diagnostics.push(
					"Child completed without a valid current-call pipi_output submission after one reminder.",
				);
			}
		} catch (error) {
			outcome = taskSignal?.aborted ? "aborted" : "error";
			diagnostics.push(
				error instanceof Error ? error.message : "Child task failed",
			);
		} finally {
			taskSignal?.removeEventListener("abort", abort);
			unsubscribe?.();
			modelEnd?.("error");
			for (const end of toolSpans.values()) end("error");
			const disposeEnd = span?.("dispose");
			if (child) {
				effective.model = child.model
					? `${child.model.provider}/${child.model.id}`
					: null;
				effective.thinkingLevel = child.thinkingLevel;
				effective.tools = child.getActiveToolNames();
				effective.sections = Object.keys(effectivePrompt?.sections ?? {});
				try {
					const teardown = (async () => {
						if (!child.isIdle) await child.abort();
						await child.extensionRunner.emit({
							type: "session_shutdown",
							reason: "quit",
						});
					})();
					const forced = await Promise.race([
						teardown.then(() => false),
						delay(TEARDOWN_TIMEOUT_MS).then(() => true),
					]);
					teardown.catch(() => {});
					if (forced)
						diagnostics.push(
							`Child teardown exceeded ${TEARDOWN_TIMEOUT_MS}ms; disposed forcefully.`,
						);
				} catch {
					diagnostics.push("Child shutdown hook failed");
				} finally {
					try {
						child.dispose();
					} catch {
						diagnostics.push("Child dispose failed");
					}
				}
			}
			disposeEnd?.();
		}
		if (timeoutSignal?.aborted && !signal?.aborted && deadline !== undefined)
			diagnostics.push(
				`pipi deadline exceeded after ${deadline}ms; child aborted, session preserved for continuation.`,
			);
		const result: TaskResult = {
			outputMode: schema ? "structured" : "message",
			outcome,
			output: schema ? output : json(assistantMessage),
			assistantMessage: schema ? assistantMessage : null,
			sessionId: manager.getSessionId(),
			sessionFile: manager.getSessionFile() ?? null,
			durationMs: performance.now() - started,
			turns,
			usage: newUsage(manager.getEntries(), before),
			requested: config,
			effective,
			diagnostics,
		};
		taskEnd?.(outcome === "completed" ? "finish" : "error", { outcome });
		return result;
	} catch (error) {
		taskEnd?.("error", { outcome: "error" });
		throw error;
	}
}