@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/runs/foreground/execution-attempt.ts

@@ -1,558 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync, unlinkSync } from "node:fs";
-import type { Message } from "@earendil-works/pi-ai/compat";
-import type { AgentConfig } from "../../agents/agents.ts";
-import { requestSupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
-import { resolveSubagentModelFastMode } from "../../shared/fast-mode.ts";
-import { createJsonlWriter } from "../../shared/jsonl-writer.ts";
-import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
-import { type AgentProgress, getSubagentDepthEnv, type RunSyncOptions, type SingleResult } from "../../shared/types.ts";
-import { extractTextFromContent, extractToolArgsPreview, getFinalOutput } from "../../shared/utils.ts";
-import { createAttemptWatchdog } from "../shared/attempt-watchdog.ts";
-import {
-	assistantStopReason,
-	isAssistantFailureStopReason,
-	shouldStartSubagentFinalDrain,
-} from "../shared/final-drain.ts";
-import {
-	createMutatingFailureState,
-	didMutatingToolFail,
-	isMutatingTool,
-	recordMutatingFailure,
-	resetMutatingFailureState,
-	resolveCurrentPath,
-	shouldEscalateMutatingFailures,
-	summarizeRecentMutatingFailures,
-} from "../shared/long-running-guard.ts";
-import { modelFailureMessage } from "../shared/model-fallback.ts";
-import { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "../shared/pi-args.ts";
-import { formatPiSpawnError, getPiSpawnCommand, validatePiSpawnCwd } from "../shared/pi-spawn.ts";
-import { buildSubagentSpawnEnv } from "../shared/spawn-env.ts";
-import { createAttemptControlRuntime } from "./execution-attempt-control.ts";
-import { finalizeSingleAttempt } from "./execution-attempt-finalize.ts";
-import type { RunSingleAttemptShared } from "./execution-attempt-types.ts";
-import { registerExecutionIntercomDetach } from "./execution-intercom-detach.ts";
-import {
-	appendRecentOutput,
-	emptyUsage,
-	modelFailureSignalByResult,
-	snapshotProgress,
-	snapshotResult,
-} from "./execution-utils.ts";
-export async function runSingleAttempt(
-	runtimeCwd: string,
-	agent: AgentConfig,
-	task: string,
-	model: string | undefined,
-	options: RunSyncOptions,
-	shared: RunSingleAttemptShared,
-): Promise<SingleResult> {
-	const modelArg = applyThinkingSuffix(model, agent.thinking);
-	const runCwd = options.cwd ?? runtimeCwd;
-	const fastMode = resolveSubagentModelFastMode({
-		model: modelArg,
-		cwd: runCwd,
-		settings: shared.fastModeSettings,
-		scope: shared.fastModeScope,
-	});
-	const supervisorAuthorization =
-		options.orchestratorIntercomTarget && options.intercomSessionName
-			? await requestSupervisorAuthorization(options.intercomEvents, options.intercomSessionName)
-			: undefined;
-	const {
-		args,
-		env: sharedEnv,
-		tempDir,
-	} = buildPiArgs({
-		baseArgs: ["--mode", "json", "-p"],
-		task,
-		sessionEnabled: shared.sessionEnabled,
-		sessionDir: options.sessionDir,
-		sessionFile: options.sessionFile,
-		model,
-		thinking: agent.thinking,
-		systemPromptMode: agent.systemPromptMode,
-		inheritProjectContext: agent.inheritProjectContext,
-		inheritSkills: agent.inheritSkills,
-		tools: agent.tools,
-		extensions: agent.extensions,
-		systemPrompt: shared.systemPrompt,
-		mcpDirectTools: agent.mcpDirectTools,
-		cwd: runCwd,
-		promptFileStem: agent.name,
-		intercomSessionName: options.intercomSessionName,
-		orchestratorIntercomTarget: supervisorAuthorization ? options.orchestratorIntercomTarget : undefined,
-		intercomGroup: options.intercomGroup,
-		supervisorAuthorization,
-		runId: options.runId,
-		childAgentName: agent.name,
-		childIndex: options.index ?? 0,
-		parentEventSink: options.nestedRoute?.eventSink,
-		parentControlInbox: options.nestedRoute?.controlInbox,
-		parentRootRunId: options.nestedRoute?.rootRunId,
-		parentCapabilityToken: options.nestedRoute?.capabilityToken,
-		codexFastModeSettings: shared.fastModeSettings,
-		codexFastModeScope: shared.fastModeScope,
-		workflowSessionMetadata: options.workflowSessionMetadata,
-		structuredOutput: options.structuredOutput,
-	});
-	const result: SingleResult = {
-		agent: agent.name,
-		task: shared.originalTask ?? task,
-		exitCode: 0,
-		messages: [],
-		usage: emptyUsage(),
-		model: modelArg,
-		...(fastMode ? { fastMode } : {}),
-		artifactPaths: shared.artifactPaths,
-		skills: shared.resolvedSkillNames,
-		skillsWarning: shared.skillsWarning,
-	};
-	const startTime = Date.now();
-	if (options.structuredOutput) {
-		try {
-			if (existsSync(options.structuredOutput.outputPath)) unlinkSync(options.structuredOutput.outputPath);
-		} catch {
-			// Missing/stale structured-output files are handled after the child exits.
-		}
-	}
-	let interruptedByControl = false;
-	const progress: AgentProgress = {
-		index: options.index ?? 0,
-		agent: agent.name,
-		status: "running",
-		task,
-		skills: shared.resolvedSkillNames,
-		recentTools: [],
-		recentOutput: [...shared.attemptNotes],
-		toolCount: 0,
-		tokens: 0,
-		durationMs: 0,
-		lastActivityAt: startTime,
-	};
-	result.progress = progress;
-	const controlRuntime = createAttemptControlRuntime({ options, agent, result, progress, startTime });
-	const spawnEnv = buildSubagentSpawnEnv(
-		process.env,
-		sharedEnv,
-		getSubagentDepthEnv(options.maxSubagentDepth, {
-			workflowStageSubagentGuard: options.workflowStageSubagentGuard,
-		}),
-	);
-	const cwdValidation = validatePiSpawnCwd(runCwd);
-	if (!cwdValidation.ok) {
-		cleanupTempDir(tempDir);
-		result.error = cwdValidation.error;
-		return finalizeSingleAttempt({
-			result,
-			progress,
-			exitCode: 1,
-			interruptedByControl,
-			allControlEvents: controlRuntime.allControlEvents,
-			options,
-			shared,
-			startTime,
-		});
-	}
-	const exitCode = await new Promise<number>((resolve) => {
-		const spawnSpec = getPiSpawnCommand(args, options.piArgv1 ? { argv1: options.piArgv1 } : {});
-		const proc = spawn(spawnSpec.command, spawnSpec.args, {
-			cwd: runCwd,
-			env: spawnEnv,
-			stdio: ["ignore", "pipe", "pipe"],
-			windowsHide: true,
-		});
-		const jsonlWriter = createJsonlWriter(shared.jsonlPath, proc.stdout);
-		let buf = "";
-		let processClosed = false;
-		let settled = false;
-		let detached = false;
-		let assistantError: string | undefined;
-		let assistantFailureSignal: unknown;
-		let removeAbortListener: (() => void) | undefined;
-		let removeInterruptListener: (() => void) | undefined;
-		let activityTimer: NodeJS.Timeout | undefined;
-		const detachForIntercom = () => {
-			if (detached || processClosed) return;
-			detached = true;
-			result.detached = true;
-			result.detachedReason = "intercom coordination";
-			progress.status = "detached";
-			progress.durationMs = Date.now() - startTime;
-			result.progressSummary = {
-				toolCount: progress.toolCount,
-				tokens: progress.tokens,
-				durationMs: progress.durationMs,
-			};
-			// Settle foreground supervision while retaining process lifecycle ownership.
-			finish(-2, true);
-		};
-		const FINAL_STOP_GRACE_MS = 1000;
-		const HARD_KILL_MS = 3000;
-		let childExited = false;
-		let forcedTerminationSignal = false;
-		let cleanTerminalAssistantStopReceived = false;
-		let finalDrainTimer: NodeJS.Timeout | undefined;
-		let finalHardKillTimer: NodeJS.Timeout | undefined;
-		const clearFinalDrainTimers = () => {
-			if (finalDrainTimer) {
-				clearTimeout(finalDrainTimer);
-				finalDrainTimer = undefined;
-			}
-			if (finalHardKillTimer) {
-				clearTimeout(finalHardKillTimer);
-				finalHardKillTimer = undefined;
-			}
-		};
-		const startFinalDrain = () => {
-			if (childExited || finalDrainTimer || processClosed) return;
-			finalDrainTimer = setTimeout(() => {
-				if (processClosed) return;
-				const termSent = trySignalChild(proc, "SIGTERM");
-				if (!termSent) return;
-				forcedTerminationSignal = true;
-				if (!cleanTerminalAssistantStopReceived && !assistantError) {
-					result.error =
-						result.error ??
-						`Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its final message. Forcing termination.`;
-				}
-				finalHardKillTimer = setTimeout(() => {
-					if (processClosed) return;
-					forcedTerminationSignal = trySignalChild(proc, "SIGKILL") || forcedTerminationSignal;
-				}, HARD_KILL_MS);
-				finalHardKillTimer.unref?.();
-			}, FINAL_STOP_GRACE_MS);
-			finalDrainTimer.unref?.();
-		};
-		const finish = (code: number, retainLifecycleOwner = false) => {
-			if (settled) return;
-			settled = true;
-			if (!retainLifecycleOwner) {
-				clearFinalDrainTimers();
-				clearStdioGuard();
-				attemptWatchdog.clear();
-				removeAbortListener?.();
-				cleanupIntercomDetach();
-			}
-			if (activityTimer) {
-				clearInterval(activityTimer);
-				activityTimer = undefined;
-			}
-			removeInterruptListener?.();
-			resolve(code);
-		};
-		const cleanupIntercomDetach = registerExecutionIntercomDetach(options, {
-			isUnavailable: () => processClosed || options.signal?.aborted === true,
-			isDetached: () => detached,
-			detach: detachForIntercom,
-		});
-		let pendingToolResult: { tool: string; path?: string; mutates: boolean; startedAt?: number } | undefined;
-		const mutatingFailures = createMutatingFailureState();
-		const mutatingFailureWindowMs = 5 * 60_000;
-		const emitUpdateSnapshot = (text: string) => {
-			if (!options.onUpdate || processClosed) return;
-			const progressSnapshot = snapshotProgress(progress);
-			const resultSnapshot = snapshotResult(result, progressSnapshot);
-			options.onUpdate({
-				content: [{ type: "text", text }],
-				details: {
-					mode: "single",
-					results: [resultSnapshot],
-					progress: [progressSnapshot],
-					controlEvents: controlRuntime.drainPendingControlEvents(),
-				},
-			});
-		};
-		const fireUpdate = () => {
-			if (!options.onUpdate || processClosed) return;
-			progress.durationMs = Date.now() - startTime;
-			emitUpdateSnapshot(getFinalOutput(result.messages ?? []) || "(running...)");
-		};
-		const processLine = (line: string) => {
-			if (!line.trim()) return;
-			jsonlWriter.writeLine(line);
-			let evt: { type?: string; message?: Message; toolName?: string; args?: unknown };
-			try {
-				evt = JSON.parse(line) as { type?: string; message?: Message; toolName?: string; args?: unknown };
-			} catch {
-				return;
-			}
-
-			const now = Date.now();
-			progress.durationMs = now - startTime;
-			progress.lastActivityAt = now;
-			controlRuntime.updateActivityState(now);
-
-			if (evt.type === "tool_execution_start") {
-				const toolArgs =
-					evt.args && typeof evt.args === "object" && !Array.isArray(evt.args)
-						? (evt.args as Record<string, unknown>)
-						: {};
-				// Broker delivery is the authoritative detach trigger; tool-start observation
-				// is intentionally not required because the broker event may arrive first.
-				progress.toolCount++;
-				progress.currentTool = evt.toolName;
-				progress.currentToolArgs = extractToolArgsPreview(toolArgs);
-				progress.currentToolStartedAt = now;
-				progress.currentPath = resolveCurrentPath(evt.toolName, toolArgs);
-				pendingToolResult = {
-					tool: evt.toolName ?? "tool",
-					path: progress.currentPath,
-					mutates: isMutatingTool(evt.toolName, toolArgs),
-					startedAt: now,
-				};
-				fireUpdate();
-			}
-
-			if (evt.type === "tool_execution_end") {
-				if (progress.currentTool) {
-					progress.recentTools.push({
-						tool: progress.currentTool,
-						args: progress.currentToolArgs || "",
-						endMs: now,
-					});
-				}
-				progress.currentTool = undefined;
-				progress.currentToolArgs = undefined;
-				progress.currentToolStartedAt = undefined;
-				progress.currentPath = undefined;
-				fireUpdate();
-			}
-
-			if (evt.type === "message_end" && evt.message) {
-				result.messages?.push(evt.message);
-				if (evt.message.role === "assistant") {
-					result.usage.turns++;
-					progress.turnCount = result.usage.turns;
-					const u = evt.message.usage;
-					if (u) {
-						result.usage.input += u.input || 0;
-						result.usage.output += u.output || 0;
-						result.usage.cacheRead += u.cacheRead || 0;
-						result.usage.cacheWrite += u.cacheWrite || 0;
-						result.usage.cost += u.cost?.total || 0;
-						progress.tokens = result.usage.input + result.usage.output;
-					}
-					if (!result.model && evt.message.model) result.model = evt.message.model;
-					const assistantText = extractTextFromContent(evt.message.content);
-					appendRecentOutput(progress, assistantText.split("\n").slice(-10));
-					const stopReason = assistantStopReason(evt.message);
-					if (evt.message.errorMessage) {
-						assistantError = evt.message.errorMessage;
-						assistantFailureSignal = evt.message;
-					}
-					if (isAssistantFailureStopReason(stopReason)) {
-						assistantError = modelFailureMessage(evt.message);
-						assistantFailureSignal = evt.message;
-					}
-					if (shouldStartSubagentFinalDrain(evt.message)) {
-						if (assistantText.trim()) {
-							assistantError = undefined;
-							assistantFailureSignal = undefined;
-						}
-						cleanTerminalAssistantStopReceived = true;
-						startFinalDrain();
-					}
-				}
-				controlRuntime.updateActivityState(now);
-				fireUpdate();
-			}
-
-			if (evt.type === "tool_result_end" && evt.message) {
-				result.messages?.push(evt.message);
-				const resultText = extractTextFromContent(evt.message.content);
-				appendRecentOutput(progress, resultText.split("\n").slice(-10));
-				const toolSnapshot = pendingToolResult;
-				pendingToolResult = undefined;
-				if (toolSnapshot?.mutates && didMutatingToolFail(resultText)) {
-					recordMutatingFailure(
-						mutatingFailures,
-						{
-							tool: toolSnapshot.tool,
-							path: toolSnapshot.path,
-							error:
-								resultText
-									.split("\n")
-									.find((row) => row.trim())
-									?.trim()
-									.slice(0, 180) ?? "mutating tool failed",
-							ts: now,
-						},
-						mutatingFailureWindowMs,
-					);
-					if (
-						shouldEscalateMutatingFailures(
-							mutatingFailures,
-							controlRuntime.config.failedToolAttemptsBeforeAttention,
-						)
-					) {
-						controlRuntime.emitNeedsAttention(now, {
-							message: `${agent.name} needs attention after repeated mutating tool failures`,
-							reason: "tool_failures",
-							currentTool: toolSnapshot.tool,
-							currentPath: toolSnapshot.path,
-							currentToolDurationMs: toolSnapshot.startedAt
-								? Math.max(0, now - toolSnapshot.startedAt)
-								: undefined,
-							recentFailureSummary: summarizeRecentMutatingFailures(mutatingFailures),
-						});
-					}
-				} else if (toolSnapshot?.mutates) {
-					resetMutatingFailureState(mutatingFailures);
-				}
-				fireUpdate();
-			}
-		};
-
-		if (controlRuntime.config.enabled) {
-			activityTimer = setInterval(() => {
-				if (processClosed || settled || detached) return;
-				const now = Date.now();
-				if (controlRuntime.updateActivityState(now)) {
-					progress.durationMs = now - startTime;
-					fireUpdate();
-				}
-			}, 1000);
-			activityTimer.unref?.();
-		}
-
-		let stderrBuf = "";
-		const clearStdioGuard = attachPostExitStdioGuard(proc, { idleMs: 2000, hardMs: 8000 });
-		const attemptWatchdog = createAttemptWatchdog({
-			child: proc,
-			isSettled: () => processClosed,
-			// A slow, quiet tool call (long build/test run) must not be mistaken for a
-			// stalled attempt: an in-flight tool execution counts as watchdog activity.
-			// Caveat: `progress.currentTool` is cleared on tool_execution_end, so if a
-			// tool ends abnormally without emitting its end event the idle watchdog is
-			// deferred indefinitely and the wall-clock cap becomes the sole backstop for
-			// this attempt — do not lower the wall cap assuming idle always fires.
-			isToolActive: () => progress.currentTool !== undefined,
-			onTimeout(message) {
-				forcedTerminationSignal = true;
-				result.error ??= message;
-				progress.error = message;
-			},
-		});
-		proc.stdout.on("data", (d) => {
-			attemptWatchdog.activity();
-			buf += d.toString();
-			const lines = buf.split("\n");
-			buf = lines.pop() || "";
-			lines.forEach(processLine);
-		});
-		proc.stderr.on("data", (d) => {
-			attemptWatchdog.activity();
-			stderrBuf += d.toString();
-		});
-		proc.on("exit", () => {
-			childExited = true;
-			clearFinalDrainTimers();
-		});
-		proc.on("close", (code, signal) => {
-			clearFinalDrainTimers();
-			clearStdioGuard();
-			attemptWatchdog.clear();
-			removeAbortListener?.();
-			removeAbortListener = undefined;
-			removeInterruptListener?.();
-			removeInterruptListener = undefined;
-			cleanupIntercomDetach();
-			void jsonlWriter.close().catch(() => undefined);
-			cleanupTempDir(tempDir);
-			if (buf.trim()) processLine(buf);
-			if (!result.error && assistantError) result.error = assistantError;
-			if (assistantFailureSignal !== undefined && result.error === assistantError) {
-				modelFailureSignalByResult.set(result, assistantFailureSignal);
-			}
-			const forcedDrainAfterFinalSuccess =
-				forcedTerminationSignal && cleanTerminalAssistantStopReceived && !result.error;
-			if (code !== 0 && stderrBuf.trim() && !result.error && !forcedDrainAfterFinalSuccess)
-				result.error = stderrBuf.trim();
-			const finalCode = forcedDrainAfterFinalSuccess
-				? 0
-				: forcedTerminationSignal || signal
-					? (code ?? 1)
-					: (code ?? 0);
-			if (detached) {
-				processClosed = true;
-				const recovered: SingleResult = { ...result, detached: undefined, detachedReason: undefined };
-				const recoveredProgress = recovered.progress ? { ...recovered.progress } : progress;
-				options.onDetachedExit?.(
-					finalizeSingleAttempt({
-						result: recovered,
-						progress: recoveredProgress,
-						exitCode: finalCode,
-						interruptedByControl,
-						allControlEvents: controlRuntime.allControlEvents,
-						options: { ...options, onUpdate: undefined },
-						shared,
-						startTime,
-					}),
-				);
-				return;
-			}
-			processClosed = true;
-			finish(finalCode);
-		});
-		proc.on("error", (error) => {
-			clearFinalDrainTimers();
-			clearStdioGuard();
-			attemptWatchdog.clear();
-			cleanupIntercomDetach();
-			void jsonlWriter.close().catch(() => undefined);
-			cleanupTempDir(tempDir);
-			if (!result.error) result.error = formatPiSpawnError(error, spawnSpec, runCwd);
-			finish(1);
-		});
-
-		if (options.signal) {
-			const kill = () => {
-				if (childExited) return;
-				trySignalChild(proc, "SIGTERM");
-				setTimeout(() => {
-					if (!childExited) trySignalChild(proc, "SIGKILL");
-				}, 3000).unref?.();
-			};
-			if (options.signal.aborted) kill();
-			else {
-				options.signal.addEventListener("abort", kill, { once: true });
-				removeAbortListener = () => options.signal?.removeEventListener("abort", kill);
-			}
-		}
-
-		if (options.interruptSignal) {
-			const interrupt = () => {
-				if (processClosed || detached || settled) return;
-				interruptedByControl = true;
-				progress.status = "running";
-				progress.durationMs = Date.now() - startTime;
-				result.interrupted = true;
-				result.finalOutput = "Interrupted. Waiting for explicit next action.";
-				progress.activityState = undefined;
-				fireUpdate();
-				trySignalChild(proc, "SIGINT");
-				setTimeout(() => {
-					if (settled || processClosed || detached) return;
-					trySignalChild(proc, "SIGTERM");
-				}, 1000).unref?.();
-			};
-			if (options.interruptSignal.aborted) interrupt();
-			else {
-				options.interruptSignal.addEventListener("abort", interrupt, { once: true });
-				removeInterruptListener = () => options.interruptSignal?.removeEventListener("abort", interrupt);
-			}
-		}
-	});
-
-	return finalizeSingleAttempt({
-		result,
-		progress,
-		exitCode,
-		interruptedByControl,
-		allControlEvents: controlRuntime.allControlEvents,
-		options,
-		shared,
-		startTime,
-	});
-}

package/dist/builtin/subagents/src/runs/foreground/execution-structured-retries.ts

@@ -1,83 +0,0 @@
-import type { AgentConfig } from "../../agents/agents.ts";
-import type { RunSyncOptions, SingleResult } from "../../shared/types.ts";
-import {
-	formatStructuredOutputCorrectionPrompt,
-	isStructuredOutputContractError,
-	latestStructuredOutputToolErrorFromMessages,
-	STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS,
-} from "../shared/structured-output.ts";
-import { runSingleAttempt } from "./execution-attempt.ts";
-import type { RunSingleAttemptShared } from "./execution-attempt-types.ts";
-import { type RunSyncUpdate, shouldSuppressIntermediateStructuredOutputFailureUpdate } from "./execution-updates.ts";
-import { emptyUsage, sumUsage } from "./execution-utils.ts";
-
-export async function runSingleAttemptWithStructuredOutputRetries(
-	runtimeCwd: string,
-	agent: AgentConfig,
-	task: string,
-	model: string | undefined,
-	options: RunSyncOptions,
-	shared: RunSingleAttemptShared,
-): Promise<SingleResult> {
-	let nextTask = task;
-	let correctiveAttempts = 0;
-	let finalResult: SingleResult | undefined;
-	const aggregateUsage = emptyUsage();
-	let totalToolCount = 0;
-	let totalDurationMs = 0;
-
-	while (true) {
-		const suppressIntermediateStructuredOutputFailure =
-			options.structuredOutput !== undefined &&
-			correctiveAttempts < STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS &&
-			options.onUpdate !== undefined;
-		const attemptOptions = suppressIntermediateStructuredOutputFailure
-			? {
-					...options,
-					onUpdate: (update: RunSyncUpdate) => {
-						if (shouldSuppressIntermediateStructuredOutputFailureUpdate(update)) return;
-						options.onUpdate?.(update);
-					},
-				}
-			: options;
-		const result = await runSingleAttempt(runtimeCwd, agent, nextTask, model, attemptOptions, shared);
-		finalResult = result;
-		sumUsage(aggregateUsage, result.usage);
-		totalToolCount += result.progressSummary?.toolCount ?? 0;
-		totalDurationMs += result.progressSummary?.durationMs ?? 0;
-
-		if (!options.structuredOutput || !isStructuredOutputContractError(result.error)) break;
-		const correctionError =
-			latestStructuredOutputToolErrorFromMessages(result.messages) ??
-			result.error ??
-			"Structured output contract failed.";
-		if (correctiveAttempts >= STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS) {
-			result.error = correctionError;
-			break;
-		}
-		correctiveAttempts += 1;
-		nextTask = formatStructuredOutputCorrectionPrompt({
-			originalTask: task,
-			error: correctionError,
-			attempt: correctiveAttempts,
-		});
-	}
-
-	const result =
-		finalResult ??
-		({
-			agent: agent.name,
-			task,
-			exitCode: 1,
-			messages: [],
-			usage: emptyUsage(),
-			error: "Subagent did not produce a result.",
-		} satisfies SingleResult);
-	result.usage = aggregateUsage;
-	result.progressSummary = {
-		toolCount: totalToolCount,
-		tokens: aggregateUsage.input + aggregateUsage.output,
-		durationMs: totalDurationMs,
-	};
-	return result;
-}