@bastani/atomic 0.9.11-alpha.8 → 0.9.11

package/dist/builtin/subagents/src/runs/background/stale-run-reconciler.ts

@@ -2,9 +2,21 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { publishFileExclusive, unlinkIfPresent } from "../../shared/exclusive-file-publication.js";
-import { RESULTS_DIR, type AsyncParallelGroupStatus, type AsyncStatus, type NestedRunSummary, type SubagentRunMode } from "../../shared/types.ts";
+import {
+	type AsyncParallelGroupStatus,
+	type AsyncStatus,
+	type NestedRunSummary,
+	RESULTS_DIR,
+	type SubagentRunMode,
+} from "../../shared/types.ts";
+import {
+	type NestedRoute,
+	nestedSummaryFromAsyncStatus,
+	projectNestedEvents,
+	resolveNestedAsyncDir,
+	writeNestedEvent,
+} from "../shared/nested-events.ts";
 import { normalizeParallelGroups } from "./parallel-groups.ts";
-import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDir, writeNestedEvent, type NestedRoute } from "../shared/nested-events.ts";
 
 export type PidLiveness = "alive" | "dead" | "unknown";
 
@@ -44,10 +56,12 @@ function getErrorMessage(error: unknown): string {
 }
 
 function isNotFoundError(error: unknown): boolean {
-	return typeof error === "object"
-		&& error !== null
-		&& "code" in error
-		&& (error as NodeJS.ErrnoException).code === "ENOENT";
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		"code" in error &&
+		(error as NodeJS.ErrnoException).code === "ENOENT"
+	);
 }
 
 function appendJsonl(filePath: string, payload: object): void {
@@ -78,7 +92,11 @@ function retireObsoleteStage(resultPath: string): void {
 	const retiredPath = `${stagePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.retired`;
 	try {
 		fs.renameSync(stagePath, retiredPath);
-		try { fs.unlinkSync(retiredPath); } catch (error) { if (!isNotFoundError(error)) console.error(error); }
+		try {
+			fs.unlinkSync(retiredPath);
+		} catch (error) {
+			if (!isNotFoundError(error)) console.error(error);
+		}
 	} catch (error) {
 		if (!isNotFoundError(error)) console.error(error);
 	}
@@ -139,7 +157,12 @@ interface ResultRepairData {
 
 function readResultRepairData(resultPath: string): ResultRepairData | undefined {
 	try {
-		const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as { success?: boolean; state?: string; exitCode?: number; results?: ResultChildOutcome[] };
+		const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as {
+			success?: boolean;
+			state?: string;
+			exitCode?: number;
+			results?: ResultChildOutcome[];
+		};
 		const state = data.success ? "complete" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
 		return { state, ...(Array.isArray(data.results) ? { results: data.results } : {}) };
 	} catch (error) {
@@ -150,7 +173,10 @@ function readResultRepairData(resultPath: string): ResultRepairData | undefined
 	}
 }
 
-function childState(overallState: ResultRepairData["state"], child: ResultChildOutcome | undefined): "complete" | "failed" | "paused" {
+function childState(
+	overallState: ResultRepairData["state"],
+	child: ResultChildOutcome | undefined,
+): "complete" | "failed" | "paused" {
 	if (child?.success === true) return "complete";
 	if (child?.success === false) return "failed";
 	return overallState;
@@ -165,11 +191,14 @@ function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now:
 		const state = childState(repair.state, child);
 		return {
 			...step,
-			status: state === "complete" ? "complete" as const : state,
+			status: state === "complete" ? ("complete" as const) : state,
 			endedAt: step.endedAt ?? now,
-			durationMs: step.startedAt !== undefined && step.durationMs === undefined ? Math.max(0, now - step.startedAt) : step.durationMs,
+			durationMs:
+				step.startedAt !== undefined && step.durationMs === undefined
+					? Math.max(0, now - step.startedAt)
+					: step.durationMs,
 			exitCode: step.exitCode ?? (state === "complete" || state === "paused" ? 0 : 1),
-			error: state === "failed" ? step.error ?? child?.error : step.error,
+			error: state === "failed" ? (step.error ?? child?.error) : step.error,
 			sessionFile: step.sessionFile ?? child?.sessionFile,
 			model: step.model ?? child?.model,
 			fastMode: step.fastMode ?? child?.fastMode,
@@ -191,9 +220,10 @@ function buildStartedStatus(asyncDir: string, startedRun: StartedRunMetadata, no
 	const startedAt = startedRun.startedAt ?? now;
 	const agents = startedRun.agents?.length ? startedRun.agents : ["subagent"];
 	const chainStepCount = startedRun.chainStepCount;
-	const parallelGroups = chainStepCount !== undefined
-		? normalizeParallelGroups(startedRun.parallelGroups, agents.length, chainStepCount)
-		: [];
+	const parallelGroups =
+		chainStepCount !== undefined
+			? normalizeParallelGroups(startedRun.parallelGroups, agents.length, chainStepCount)
+			: [];
 	return {
 		runId: startedRun.runId || path.basename(asyncDir),
 		...(startedRun.sessionId ? { sessionId: startedRun.sessionId } : {}),
@@ -214,22 +244,34 @@ function buildStartedStatus(asyncDir: string, startedRun: StartedRunMetadata, no
 	};
 }
 
-function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, reason?: string): { status: AsyncStatus; result: object; message: string } {
+function buildFailedRepair(
+	status: AsyncStatus,
+	asyncDir: string,
+	now: number,
+	reason?: string,
+): { status: AsyncStatus; result: object; message: string } {
 	const runId = status.runId || path.basename(asyncDir);
 	const pid = typeof status.pid === "number" ? status.pid : "unknown";
-	const message = reason ?? `Async runner process ${pid} exited or disappeared before writing a result. Marked run failed by stale-run reconciliation.`;
+	const message =
+		reason ??
+		`Async runner process ${pid} exited or disappeared before writing a result. Marked run failed by stale-run reconciliation.`;
 	const steps = status.steps?.length ? status.steps : [{ agent: "subagent", status: "running" as const }];
-	const repairedSteps = steps.map((step) => step.status === "running" || step.status === "pending"
-		? {
-			...step,
-			status: "failed" as const,
-			activityState: undefined,
-			endedAt: step.endedAt ?? now,
-			durationMs: step.startedAt !== undefined && step.durationMs === undefined ? Math.max(0, now - step.startedAt) : step.durationMs,
-			exitCode: step.exitCode ?? 1,
-			error: step.error ?? message,
-		}
-		: step);
+	const repairedSteps = steps.map((step) =>
+		step.status === "running" || step.status === "pending"
+			? {
+					...step,
+					status: "failed" as const,
+					activityState: undefined,
+					endedAt: step.endedAt ?? now,
+					durationMs:
+						step.startedAt !== undefined && step.durationMs === undefined
+							? Math.max(0, now - step.startedAt)
+							: step.durationMs,
+					exitCode: step.exitCode ?? 1,
+					error: step.error ?? message,
+				}
+			: step,
+	);
 	const repairedStatus: AsyncStatus = {
 		...status,
 		state: "failed",
@@ -252,7 +294,7 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 			results: repairedSteps.map((step) => ({
 				agent: step.agent,
 				output: step.status === "complete" || step.status === "completed" ? "" : message,
-				error: step.status === "complete" || step.status === "completed" ? undefined : step.error ?? message,
+				error: step.status === "complete" || step.status === "completed" ? undefined : (step.error ?? message),
 				success: step.status === "complete" || step.status === "completed",
 				model: step.model,
 				fastMode: step.fastMode,
@@ -270,7 +312,14 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 	};
 }
 
-function writeFailedRepair(asyncDir: string, status: AsyncStatus, resultPath: string, now: number, reason?: string, publish?: ReconcileAsyncRunOptions["publish"]): ReconcileAsyncRunResult {
+function writeFailedRepair(
+	asyncDir: string,
+	status: AsyncStatus,
+	resultPath: string,
+	now: number,
+	reason?: string,
+	publish?: ReconcileAsyncRunOptions["publish"],
+): ReconcileAsyncRunResult {
 	const repair = buildFailedRepair(status, asyncDir, now, reason);
 	// Stage the exact public payload beside its destination. Publication consumes
 	// the hidden stage with one atomic rename after terminal status is durable.
@@ -286,7 +335,9 @@ function writeFailedRepair(asyncDir: string, status: AsyncStatus, resultPath: st
 			message: repair.message,
 		});
 	} catch (error) {
-		console.error(`Failed to append stale-repair event for '${asyncDir}'; publishing the recoverable result: ${getErrorMessage(error)}`);
+		console.error(
+			`Failed to append stale-repair event for '${asyncDir}'; publishing the recoverable result: ${getErrorMessage(error)}`,
+		);
 	}
 	return publishStagedRepair(resultPath, repair.status, repair.result, publish);
 }
@@ -340,9 +391,10 @@ export function checkPidLiveness(pid: number, kill: KillFn = process.kill): PidL
 		kill(pid, 0);
 		return "alive";
 	} catch (error) {
-		const code = typeof error === "object" && error !== null && "code" in error
-			? (error as NodeJS.ErrnoException).code
-			: undefined;
+		const code =
+			typeof error === "object" && error !== null && "code" in error
+				? (error as NodeJS.ErrnoException).code
+				: undefined;
 		if (code === "ESRCH") return "dead";
 		if (code === "EPERM") return "unknown";
 		return "unknown";
@@ -352,7 +404,8 @@ export function checkPidLiveness(pid: number, kill: KillFn = process.kill): PidL
 export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOptions = {}): ReconcileAsyncRunResult {
 	const now = options.now?.() ?? Date.now();
 	const status = readStatusFile(asyncDir);
-	const startedStatus = !status && options.startedRun ? buildStartedStatus(asyncDir, options.startedRun, now) : undefined;
+	const startedStatus =
+		!status && options.startedRun ? buildStartedStatus(asyncDir, options.startedRun, now) : undefined;
 	const effectiveStatus = status ?? startedStatus;
 	if (!effectiveStatus) return { status: null, repaired: false };
 
@@ -360,12 +413,18 @@ export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOp
 	const resultPath = path.join(options.resultsDir ?? RESULTS_DIR, `${runId}.json`);
 	if (fs.existsSync(resultPath)) {
 		retireObsoleteStage(resultPath);
-		const terminalStatus = effectiveStatus.state === "running" || effectiveStatus.state === "queued"
-			? terminalStatusFromResult(effectiveStatus, resultPath, now)
-			: undefined;
+		const terminalStatus =
+			effectiveStatus.state === "running" || effectiveStatus.state === "queued"
+				? terminalStatusFromResult(effectiveStatus, resultPath, now)
+				: undefined;
 		if (terminalStatus) {
 			writeAtomicJson(path.join(asyncDir, "status.json"), terminalStatus);
-			return { status: terminalStatus, repaired: true, resultPath, message: "Existing async result file was used to repair stale running status." };
+			return {
+				status: terminalStatus,
+				repaired: true,
+				resultPath,
+				message: "Existing async result file was used to repair stale running status.",
+			};
 		}
 		return { status: effectiveStatus, repaired: false, resultPath };
 	}

package/dist/builtin/subagents/src/runs/background/subagent-runner-dynamic.ts

@@ -1,25 +1,61 @@
 import * as path from "node:path";
+import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
+import type { SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
 import { appendJsonl } from "../../shared/artifacts.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
-import { aggregateParallelOutputs, mapConcurrent, MAX_PARALLEL_CONCURRENCY } from "../shared/parallel-utils.ts";
-import { collectDynamicResults, DynamicFanoutError, materializeDynamicParallelStep, validateDynamicCollection } from "../shared/dynamic-fanout.ts";
+import {
+	collectDynamicResults,
+	DynamicFanoutError,
+	materializeDynamicParallelStep,
+	validateDynamicCollection,
+} from "../shared/dynamic-fanout.ts";
+import { createMutatingFailureState } from "../shared/long-running-guard.ts";
+import { aggregateParallelOutputs, MAX_PARALLEL_CONCURRENCY, mapConcurrent } from "../shared/parallel-utils.ts";
+import {
+	markDynamicGraphGroup,
+	resetStepLiveDetail,
+	updateStepFromChildEvent,
+	updateStepModel,
+	writeStatusPayload,
+} from "./subagent-runner-state.ts";
 import { runSingleStep } from "./subagent-runner-step.ts";
 import type { RunnerExecutionState, RunnerStatusStep, RunnerStep, SubagentStep } from "./subagent-runner-types.ts";
-import type { SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
-import { createMutatingFailureState } from "../shared/long-running-guard.ts";
-import { markDynamicGraphGroup, resetStepLiveDetail, updateStepFromChildEvent, updateStepModel, writeStatusPayload } from "./subagent-runner-state.ts";
 
-export async function runDynamicGroup(state: RunnerExecutionState, step: RunnerStep, stepIndex: number): Promise<boolean> {
-	const { outputs, statusPayload, asyncDir, id, cwd, placeholder, sessionEnabled, config, artifactsDir, artifactConfig } = state;
+export async function runDynamicGroup(
+	state: RunnerExecutionState,
+	step: RunnerStep,
+	stepIndex: number,
+): Promise<boolean> {
+	const {
+		outputs,
+		statusPayload,
+		asyncDir,
+		id,
+		cwd,
+		placeholder,
+		sessionEnabled,
+		config,
+		artifactsDir,
+		artifactConfig,
+	} = state;
 	const groupStartFlatIndex = state.flatIndex;
 	let materialized: ReturnType<typeof materializeDynamicParallelStep>;
 	try {
-		materialized = materializeDynamicParallelStep(step as Parameters<typeof materializeDynamicParallelStep>[0], outputs, stepIndex, { maxItems: config.dynamicFanoutMaxItems, allowRunnerFields: true });
-		if (materialized.collectedOnEmpty) validateDynamicCollection((step as Parameters<typeof materializeDynamicParallelStep>[0]).collect.outputSchema, materialized.collectedOnEmpty);
+		materialized = materializeDynamicParallelStep(
+			step as Parameters<typeof materializeDynamicParallelStep>[0],
+			outputs,
+			stepIndex,
+			{ maxItems: config.dynamicFanoutMaxItems, allowRunnerFields: true },
+		);
+		if (materialized.collectedOnEmpty)
+			validateDynamicCollection(
+				(step as Parameters<typeof materializeDynamicParallelStep>[0]).collect.outputSchema,
+				materialized.collectedOnEmpty,
+			);
 	} catch (error) {
 		const now = Date.now();
-		const message = error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
+		const message =
+			error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
 		statusPayload.state = "failed";
 		statusPayload.error = message;
 		statusPayload.currentStep = state.flatIndex;
@@ -36,7 +72,13 @@ export async function runDynamicGroup(state: RunnerExecutionState, step: RunnerS
 		markDynamicGraphGroup(state, stepIndex, "failed", message);
 		writeStatusPayload(state);
 		const dynamicStep = step as Parameters<typeof materializeDynamicParallelStep>[0];
-		state.results.push({ agent: dynamicStep.parallel.agent, output: message, error: message, success: false, exitCode: 1 });
+		state.results.push({
+			agent: dynamicStep.parallel.agent,
+			output: message,
+			error: message,
+			success: false,
+			exitCode: 1,
+		});
 		return false;
 	}
 
@@ -45,7 +87,12 @@ export async function runDynamicGroup(state: RunnerExecutionState, step: RunnerS
 	if (materialized.parallel.length === 0) {
 		const now = Date.now();
 		const collection = materialized.collectedOnEmpty ?? [];
-		outputs[dynamicStep.collect.as] = { text: JSON.stringify(collection), structured: collection, agent: dynamicStep.parallel.agent, stepIndex };
+		outputs[dynamicStep.collect.as] = {
+			text: JSON.stringify(collection),
+			structured: collection,
+			agent: dynamicStep.parallel.agent,
+			stepIndex,
+		};
 		statusPayload.outputs = outputs;
 		const placeholderStep = statusPayload.steps[groupStartFlatIndex];
 		if (placeholderStep) {
@@ -80,24 +127,35 @@ export async function runDynamicGroup(state: RunnerExecutionState, step: RunnerS
 		skills: task.skills,
 		model: task.model,
 		thinking: task.thinking,
-		attemptedModels: task.modelCandidates && task.modelCandidates.length > 0 ? task.modelCandidates : task.model ? [task.model] : undefined,
+		attemptedModels:
+			task.modelCandidates && task.modelCandidates.length > 0
+				? task.modelCandidates
+				: task.model
+					? [task.model]
+					: undefined,
 		recentTools: [],
 		recentOutput: [],
 	}));
 	statusPayload.steps.splice(groupStartFlatIndex, 1, ...dynamicStatusSteps);
-	if (config.childIntercomTargets) config.childIntercomTargets = statusPayload.steps.map((statusStep, index) => resolveSubagentIntercomTarget(id, statusStep.agent, index));
+	if (config.childIntercomTargets)
+		config.childIntercomTargets = statusPayload.steps.map((statusStep, index) =>
+			resolveSubagentIntercomTarget(id, statusStep.agent, index),
+		);
 	const dynamicAuthorizations = config.dynamicSupervisorAuthorizations?.[stepIndex];
 	if (dynamicAuthorizations) {
-		const authorizations = config.supervisorAuthorizations
-			?? new Array<SupervisorAuthorization | undefined>(statusPayload.steps.length - dynamicStatusSteps.length + 1).fill(undefined);
-		authorizations.splice(
-			groupStartFlatIndex,
-			1,
-			...dynamicSteps.map((_, index) => dynamicAuthorizations[index]),
-		);
+		const authorizations =
+			config.supervisorAuthorizations ??
+			new Array<SupervisorAuthorization | undefined>(
+				statusPayload.steps.length - dynamicStatusSteps.length + 1,
+			).fill(undefined);
+		authorizations.splice(groupStartFlatIndex, 1, ...dynamicSteps.map((_, index) => dynamicAuthorizations[index]));
 		config.supervisorAuthorizations = authorizations;
 	}
-	state.mutatingFailureStates.splice(groupStartFlatIndex, 1, ...dynamicStatusSteps.map(() => createMutatingFailureState()));
+	state.mutatingFailureStates.splice(
+		groupStartFlatIndex,
+		1,
+		...dynamicStatusSteps.map(() => createMutatingFailureState()),
+	);
 	state.pendingToolResults.splice(groupStartFlatIndex, 1, ...dynamicStatusSteps.map(() => undefined));
 	const materializedDelta = dynamicStatusSteps.length - 1;
 	for (const group of statusPayload.parallelGroups) {
@@ -111,7 +169,13 @@ export async function runDynamicGroup(state: RunnerExecutionState, step: RunnerS
 	if (statusPayload.workflowGraph) {
 		const shiftFlatIndexes = (nodes: NonNullable<typeof statusPayload.workflowGraph>["nodes"]): void => {
 			for (const node of nodes) {
-				if (node.stepIndex !== undefined && node.stepIndex > stepIndex && node.flatIndex !== undefined && node.flatIndex >= groupStartFlatIndex) node.flatIndex += dynamicStatusSteps.length;
+				if (
+					node.stepIndex !== undefined &&
+					node.stepIndex > stepIndex &&
+					node.flatIndex !== undefined &&
+					node.flatIndex >= groupStartFlatIndex
+				)
+					node.flatIndex += dynamicStatusSteps.length;
 				if (node.children) shiftFlatIndexes(node.children);
 			}
 		};
@@ -163,12 +227,28 @@ export async function runDynamicGroup(state: RunnerExecutionState, step: RunnerS
 		statusPayload.lastActivityAt = taskStartTime;
 		statusPayload.lastUpdate = taskStartTime;
 		writeStatusPayload(state);
-		appendJsonl(state.eventsPath, JSON.stringify({ type: "subagent.step.started", ts: taskStartTime, runId: id, stepIndex: fi, agent: task.agent }));
+		appendJsonl(
+			state.eventsPath,
+			JSON.stringify({
+				type: "subagent.step.started",
+				ts: taskStartTime,
+				runId: id,
+				stepIndex: fi,
+				agent: task.agent,
+			}),
+		);
 		const singleResult = await runSingleStep(task, {
-			previousOutput: state.previousOutput, placeholder, cwd, sessionEnabled, outputs,
+			previousOutput: state.previousOutput,
+			placeholder,
+			cwd,
+			sessionEnabled,
+			outputs,
 			sessionDir: config.sessionDir ? path.join(config.sessionDir, `dynamic-${stepIndex}-${taskIdx}`) : undefined,
-			artifactsDir, artifactConfig, id,
-			flatIndex: fi, flatStepCount: Math.max(statusPayload.steps.length, 1),
+			artifactsDir,
+			artifactConfig,
+			id,
+			flatIndex: fi,
+			flatStepCount: Math.max(statusPayload.steps.length, 1),
 			outputFile: path.join(asyncDir, `output-${fi}.log`),
 			piPackageRoot: config.piPackageRoot,
 			piArgv1: config.piArgv1,
@@ -197,31 +277,99 @@ export async function runDynamicGroup(state: RunnerExecutionState, step: RunnerS
 		statusPayload.steps[fi].structuredOutputSchemaPath = singleResult.structuredOutputSchemaPath;
 		statusPayload.lastUpdate = taskEndTime;
 		writeStatusPayload(state);
-		appendJsonl(state.eventsPath, JSON.stringify({ type: singleResult.exitCode === 0 ? "subagent.step.completed" : "subagent.step.failed", ts: taskEndTime, runId: id, stepIndex: fi, agent: task.agent, exitCode: singleResult.exitCode, durationMs: taskEndTime - taskStartTime }));
+		appendJsonl(
+			state.eventsPath,
+			JSON.stringify({
+				type: singleResult.exitCode === 0 ? "subagent.step.completed" : "subagent.step.failed",
+				ts: taskEndTime,
+				runId: id,
+				stepIndex: fi,
+				agent: task.agent,
+				exitCode: singleResult.exitCode,
+				durationMs: taskEndTime - taskStartTime,
+			}),
+		);
 		if (singleResult.exitCode !== 0 && failFast) aborted = true;
 		return { ...singleResult, skipped: false };
 	});
 
 	state.flatIndex += dynamicSteps.length;
-	for (const pr of parallelResults) state.results.push({ agent: pr.agent, output: pr.output, error: pr.error, success: pr.exitCode === 0, exitCode: pr.exitCode, skipped: pr.skipped, sessionFile: pr.sessionFile, intercomTarget: pr.intercomTarget, model: pr.model, attemptedModels: pr.attemptedModels, modelAttempts: pr.modelAttempts, artifactPaths: pr.artifactPaths, structuredOutput: pr.structuredOutput, structuredOutputPath: pr.structuredOutputPath, structuredOutputSchemaPath: pr.structuredOutputSchemaPath });
-	const collection = collectDynamicResults(dynamicStep as Parameters<typeof collectDynamicResults>[0], materialized.items, parallelResults as Parameters<typeof collectDynamicResults>[2]);
+	for (const pr of parallelResults)
+		state.results.push({
+			agent: pr.agent,
+			output: pr.output,
+			error: pr.error,
+			success: pr.exitCode === 0,
+			exitCode: pr.exitCode,
+			skipped: pr.skipped,
+			sessionFile: pr.sessionFile,
+			intercomTarget: pr.intercomTarget,
+			model: pr.model,
+			attemptedModels: pr.attemptedModels,
+			modelAttempts: pr.modelAttempts,
+			artifactPaths: pr.artifactPaths,
+			structuredOutput: pr.structuredOutput,
+			structuredOutputPath: pr.structuredOutputPath,
+			structuredOutputSchemaPath: pr.structuredOutputSchemaPath,
+		});
+	const collection = collectDynamicResults(
+		dynamicStep as Parameters<typeof collectDynamicResults>[0],
+		materialized.items,
+		parallelResults as Parameters<typeof collectDynamicResults>[2],
+	);
 	const failures = parallelResults.filter((result) => result.exitCode !== 0 && result.exitCode !== -1);
 	if (failures.length === 0) {
 		try {
 			validateDynamicCollection(dynamicStep.collect.outputSchema, collection);
-			outputs[dynamicStep.collect.as] = { text: JSON.stringify(collection), structured: collection, agent: parallelTemplate.agent, stepIndex };
+			outputs[dynamicStep.collect.as] = {
+				text: JSON.stringify(collection),
+				structured: collection,
+				agent: parallelTemplate.agent,
+				stepIndex,
+			};
 			statusPayload.outputs = outputs;
 			markDynamicGraphGroup(state, stepIndex, "completed");
 		} catch (error) {
-			const message = error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
-			state.results.push({ agent: parallelTemplate.agent, output: message, error: message, success: false, exitCode: 1, structuredOutput: collection });
+			const message =
+				error instanceof DynamicFanoutError
+					? error.message
+					: error instanceof Error
+						? error.message
+						: String(error);
+			state.results.push({
+				agent: parallelTemplate.agent,
+				output: message,
+				error: message,
+				success: false,
+				exitCode: 1,
+				structuredOutput: collection,
+			});
 			statusPayload.error = message;
 			markDynamicGraphGroup(state, stepIndex, "failed", message);
 		}
 	}
-	state.previousOutput = aggregateParallelOutputs(parallelResults.map((r, i) => ({ agent: r.agent, taskIndex: i, output: r.output, exitCode: r.exitCode, error: r.error })), (i, agent) => `=== Dynamic Item ${i + 1} (${agent}, key ${materialized.items[i]?.key ?? i}) ===`);
-	appendJsonl(state.eventsPath, JSON.stringify({ type: "subagent.dynamic.completed", ts: Date.now(), runId: id, stepIndex, success: failures.length === 0 }));
-	if (failures.length > 0) markDynamicGraphGroup(state, stepIndex, "failed", failures[0]?.error ?? "Dynamic fanout child failed.");
+	state.previousOutput = aggregateParallelOutputs(
+		parallelResults.map((r, i) => ({
+			agent: r.agent,
+			taskIndex: i,
+			output: r.output,
+			exitCode: r.exitCode,
+			error: r.error,
+		})),
+		(i, agent) => `=== Dynamic Item ${i + 1} (${agent}, key ${materialized.items[i]?.key ?? i}) ===`,
+	);
+	appendJsonl(
+		state.eventsPath,
+		JSON.stringify({
+			type: "subagent.dynamic.completed",
+			ts: Date.now(),
+			runId: id,
+			stepIndex,
+			success: failures.length === 0,
+		}),
+	);
+	if (failures.length > 0)
+		markDynamicGraphGroup(state, stepIndex, "failed", failures[0]?.error ?? "Dynamic fanout child failed.");
 	statusPayload.lastUpdate = Date.now();
 	writeStatusPayload(state);
 	return !(failures.length > 0 || statusPayload.error);

package/dist/builtin/subagents/src/runs/background/subagent-runner-finalize.ts

@@ -1,11 +1,11 @@
 import * as path from "node:path";
-import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { appendJsonl } from "../../shared/artifacts.ts";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { DEFAULT_MAX_OUTPUT, truncateOutput } from "../../shared/types.ts";
 import { createShareLink, exportSessionHtml, writeRunLog } from "./subagent-runner-output.ts";
-import { findLatestSessionFile } from "./subagent-runner-utils.ts";
 import { cleanupActivityTimer, writeStatusPayload } from "./subagent-runner-state.ts";
 import type { RunnerExecutionState } from "./subagent-runner-types.ts";
+import { findLatestSessionFile } from "./subagent-runner-utils.ts";
 
 export async function finalizeRun(state: RunnerExecutionState): Promise<void> {
 	const { config, results, maxOutput, flatSteps, statusPayload, artifactsDir, cwd, asyncDir, id } = state;
@@ -23,11 +23,12 @@ export async function finalizeRun(state: RunnerExecutionState): Promise<void> {
 	}
 
 	const resultMode = config.resultMode ?? statusPayload.mode;
-	const agentName = flatSteps.length === 1
-		? flatSteps[0].agent
-		: resultMode === "parallel"
-			? `parallel:${flatSteps.map((s) => s.agent).join("+")}`
-			: `chain:${flatSteps.map((s) => s.agent).join("->")}`;
+	const agentName =
+		flatSteps.length === 1
+			? flatSteps[0].agent
+			: resultMode === "parallel"
+				? `parallel:${flatSteps.map((s) => s.agent).join("+")}`
+				: `chain:${flatSteps.map((s) => s.agent).join("->")}`;
 	let sessionFile: string | undefined;
 	let shareUrl: string | undefined;
 	let gistUrl: string | undefined;
@@ -70,14 +71,27 @@ export async function finalizeRun(state: RunnerExecutionState): Promise<void> {
 		if (failedStep?.agent) statusPayload.error = `Step failed: ${failedStep.agent}`;
 	}
 	writeStatusPayload(state);
-	appendJsonl(state.eventsPath, JSON.stringify({ type: "subagent.run.completed", ts: runEndedAt, runId: id, status: statusPayload.state, durationMs: runEndedAt - state.overallStartTime }));
+	appendJsonl(
+		state.eventsPath,
+		JSON.stringify({
+			type: "subagent.run.completed",
+			ts: runEndedAt,
+			runId: id,
+			status: statusPayload.state,
+			durationMs: runEndedAt - state.overallStartTime,
+		}),
+	);
 	writeRunLog(state.logPath, {
 		id,
 		mode: statusPayload.mode,
 		cwd,
 		startedAt: state.overallStartTime,
 		endedAt: runEndedAt,
-		steps: statusPayload.steps.map((step) => ({ agent: step.agent, status: step.status, durationMs: step.durationMs })),
+		steps: statusPayload.steps.map((step) => ({
+			agent: step.agent,
+			status: step.status,
+			durationMs: step.durationMs,
+		})),
 		summary,
 		truncated,
 		artifactsDir,

package/dist/builtin/subagents/src/runs/background/subagent-runner-output.ts

@@ -2,9 +2,9 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
+import type { SubagentRunMode } from "../../shared/types.ts";
 import { PI_CODING_AGENT_PACKAGE, resolveInstalledPiPackageRoot } from "../shared/pi-spawn.ts";
 import { formatDuration } from "./subagent-runner-utils.ts";
-import type { SubagentRunMode } from "../../shared/types.ts";
 
 function resolvePiPackageRootFallback(): string {
 	const root = resolveInstalledPiPackageRoot();
@@ -12,7 +12,11 @@ function resolvePiPackageRootFallback(): string {
 	throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
 }
 
-export async function exportSessionHtml(sessionFile: string, outputDir: string, piPackageRoot?: string): Promise<string> {
+export async function exportSessionHtml(
+	sessionFile: string,
+	outputDir: string,
+	piPackageRoot?: string,
+): Promise<string> {
 	const pkgRoot = piPackageRoot ?? resolvePiPackageRootFallback();
 	const exportModulePath = path.join(pkgRoot, "dist", "core", "export-html", "index.js");
 	const moduleUrl = pathToFileURL(exportModulePath).href;