@bastani/atomic 0.9.10 → 0.9.11-alpha.10

package/dist/builtin/subagents/src/runs/foreground/subagent-executor.ts

@@ -1,18 +1,15 @@
-import { type ExtensionContext } from "@bastani/atomic";
+import type { ExtensionContext } from "@bastani/atomic";
 import { handleManagementAction } from "../../agents/agent-management.ts";
-import { buildDoctorReport } from "../../extension/doctor.ts";
 import { clearPendingForegroundControlNotices } from "../../extension/control-notices.ts";
+import { buildDoctorReport } from "../../extension/doctor.ts";
 import { resolveIntercomSessionTarget } from "../../intercom/intercom-bridge.ts";
 import { SUBAGENT_ACTIONS, type SubagentToolResult } from "../../shared/types.ts";
+import { type ResolvedSubagentRunId, resolveSubagentRunId } from "../background/run-id-resolver.ts";
 import { inspectSubagentStatus } from "../background/run-status.ts";
-import { resolveSubagentRunId, type ResolvedSubagentRunId } from "../background/run-id-resolver.ts";
 import { runAsyncPath } from "./subagent-executor-async.ts";
 import { runChainPath } from "./subagent-executor-chain.ts";
 import { checkDepthForExecution, prepareExecutionContext } from "./subagent-executor-context.ts";
-import {
-	toExecutionErrorResult,
-	withForkContext,
-} from "./subagent-executor-input.ts";
+import { toExecutionErrorResult, withForkContext } from "./subagent-executor-input.ts";
 import { runParallelPath } from "./subagent-executor-parallel.ts";
 import {
 	interruptAsyncRun,
@@ -28,15 +25,11 @@ import {
 	getForegroundControl,
 	retainedForegroundStatusResult,
 } from "./subagent-executor-status.ts";
-import type {
-	ExecutorDeps,
-	ResolvedExecutorDeps,
-	SubagentParamsLike,
-} from "./subagent-executor-types.ts";
+import type { ExecutorDeps, ResolvedExecutorDeps, SubagentParamsLike } from "./subagent-executor-types.ts";
 
 const MUTATING_MANAGEMENT_ACTIONS = new Set(["create", "update", "delete"]);
 
-export type { SubagentParamsLike, SubagentExecutorRuntimeDeps } from "./subagent-executor-types.ts";
+export type { SubagentExecutorRuntimeDeps, SubagentParamsLike } from "./subagent-executor-types.ts";
 
 async function handleManagementRequest(input: {
 	params: SubagentParamsLike;
@@ -48,7 +41,11 @@ async function handleManagementRequest(input: {
 	const { params, paramsWithResolvedCwd, requestCwd, ctx, deps } = input;
 	const action = params.action;
 	if (!action) {
-		return { content: [{ type: "text", text: "Missing action." }], isError: true, details: { mode: "management", results: [] } };
+		return {
+			content: [{ type: "text", text: "Missing action." }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
 	}
 	if (action === "doctor") {
 		let currentSessionFile: string | null = null;
@@ -65,21 +62,23 @@ async function handleManagementRequest(input: {
 			orchestratorTarget = resolveIntercomSessionTarget(deps.pi.getSessionName(), ctx.sessionManager.getSessionId());
 		} catch {}
 		return {
-			content: [{
-				type: "text",
-				text: buildDoctorReport({
-					cwd: requestCwd,
-					config: deps.config,
-					state: deps.state,
-					context: paramsWithResolvedCwd.context,
-					requestedSessionDir: paramsWithResolvedCwd.sessionDir,
-					currentSessionFile,
-					currentSessionId,
-					orchestratorTarget,
-					sessionError,
-					expandTilde: deps.expandTilde,
-				}),
-			}],
+			content: [
+				{
+					type: "text",
+					text: buildDoctorReport({
+						cwd: requestCwd,
+						config: deps.config,
+						state: deps.state,
+						context: paramsWithResolvedCwd.context,
+						requestedSessionDir: paramsWithResolvedCwd.sessionDir,
+						currentSessionFile,
+						currentSessionId,
+						orchestratorTarget,
+						sessionError,
+						expandTilde: deps.expandTilde,
+					}),
+				},
+			],
 			details: { mode: "management", results: [] },
 		};
 	}
@@ -97,18 +96,25 @@ async function handleManagementRequest(input: {
 				}
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
-				return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
+				return {
+					content: [{ type: "text", text: message }],
+					isError: true,
+					details: { mode: "management", results: [] },
+				};
 			}
 		} else {
 			const foreground = getForegroundControl(deps.state, undefined);
 			if (foreground) return foregroundStatusResult(foreground);
 		}
-		return inspectSubagentStatus({
-			action: "status",
-			id: paramsWithResolvedCwd.id,
-			runId: paramsWithResolvedCwd.runId,
-			dir: paramsWithResolvedCwd.dir,
-		}, { state: deps.state, nested: nestedResolutionScopeForExecutor(deps) });
+		return inspectSubagentStatus(
+			{
+				action: "status",
+				id: paramsWithResolvedCwd.id,
+				runId: paramsWithResolvedCwd.runId,
+				dir: paramsWithResolvedCwd.dir,
+			},
+			{ state: deps.state, nested: nestedResolutionScopeForExecutor(deps) },
+		);
 	}
 	if (action === "resume") {
 		return resumeAsyncRun({ params: paramsWithResolvedCwd, requestCwd, ctx, deps });
@@ -142,10 +148,17 @@ async function handleInterruptRequest(input: {
 	let resolved: ResolvedSubagentRunId | undefined;
 	if (targetRunId) {
 		try {
-			resolved = resolveSubagentRunId(targetRunId, { state: deps.state, nested: nestedResolutionScopeForExecutor(deps) });
+			resolved = resolveSubagentRunId(targetRunId, {
+				state: deps.state,
+				nested: nestedResolutionScopeForExecutor(deps),
+			});
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
+			return {
+				content: [{ type: "text", text: message }],
+				isError: true,
+				details: { mode: "management", results: [] },
+			};
 		}
 	}
 	if (resolved?.kind === "nested") return interruptNestedRun(resolved);
@@ -183,10 +196,12 @@ function inferExecutionMode(params: SubagentParamsLike): "single" | "parallel" |
 
 function duplicateSubagentCallResult(params: SubagentParamsLike): SubagentToolResult {
 	return {
-		content: [{
-			type: "text",
-			text: "Rejected: a subagent call is already in progress. Issue exactly ONE subagent call per turn.",
-		}],
+		content: [
+			{
+				type: "text",
+				text: "Rejected: a subagent call is already in progress. Issue exactly ONE subagent call per turn.",
+			},
+		],
 		isError: true,
 		details: { mode: inferExecutionMode(params), results: [] },
 	};
@@ -262,11 +277,14 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 			}
 		}
 
-		return withForkContext({
-			content: [{ type: "text", text: "Invalid params" }],
-			isError: true,
-			details: { mode: "single" as const, results: [] },
-		}, prepared.effectiveParams.context);
+		return withForkContext(
+			{
+				content: [{ type: "text", text: "Invalid params" }],
+				isError: true,
+				details: { mode: "single" as const, results: [] },
+			},
+			prepared.effectiveParams.context,
+		);
 	};
 
 	const executeWithSingleDispatchGuard = async (

package/dist/builtin/subagents/src/runs/shared/chain-outputs.ts

@@ -1,7 +1,12 @@
-import { isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
+import { type ChainStep, isDynamicParallelStep, isParallelStep, type SequentialStep } from "../../shared/settings.ts";
 import type { ChainOutputMap, ChainOutputMapEntry, SingleResult } from "../../shared/types.ts";
 import { getSingleResultOutput } from "../../shared/utils.ts";
-import { DynamicFanoutError, hasDynamicFanoutFields, type DynamicFanoutConfig, validateDynamicStepShape } from "./dynamic-fanout.ts";
+import {
+	type DynamicFanoutConfig,
+	DynamicFanoutError,
+	hasDynamicFanoutFields,
+	validateDynamicStepShape,
+} from "./dynamic-fanout.ts";
 
 const OUTPUT_REF_PATTERN = /\{outputs\.([^}]*)\}/g;
 const SAFE_OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -9,7 +14,8 @@ const SAFE_OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 export class ChainOutputValidationError extends Error {}
 
 function outputNamesForStep(step: ChainStep): string[] {
-	if (isParallelStep(step)) return step.parallel.map((task) => task.as).filter((name): name is string => Boolean(name));
+	if (isParallelStep(step))
+		return step.parallel.map((task) => task.as).filter((name): name is string => Boolean(name));
 	if (isDynamicParallelStep(step)) return [step.collect.as];
 	const name = (step as SequentialStep).as;
 	return name ? [name] : [];
@@ -17,7 +23,8 @@ function outputNamesForStep(step: ChainStep): string[] {
 
 function taskTemplatesForStep(step: ChainStep): string[] {
 	if (isParallelStep(step)) return step.parallel.map((task) => task.task ?? "{previous}");
-	if (isDynamicParallelStep(step)) return [step.parallel.task ?? "{previous}", step.parallel.label ?? ""].filter(Boolean);
+	if (isDynamicParallelStep(step))
+		return [step.parallel.task ?? "{previous}", step.parallel.label ?? ""].filter(Boolean);
 	return [(step as SequentialStep).task ?? "{previous}"];
 }
 
@@ -28,7 +35,9 @@ export function validateChainOutputBindings(steps: ChainStep[], dynamicFanoutCon
 		const step = steps[stepIndex]!;
 		if (hasDynamicFanoutFields(step)) {
 			if (!isDynamicParallelStep(step)) {
-				throw new ChainOutputValidationError(`Dynamic chain step ${stepIndex + 1} requires expand, a single parallel template object, and collect; dynamic expand/collect cannot be mixed with static parallel arrays.`);
+				throw new ChainOutputValidationError(
+					`Dynamic chain step ${stepIndex + 1} requires expand, a single parallel template object, and collect; dynamic expand/collect cannot be mixed with static parallel arrays.`,
+				);
 			}
 			try {
 				validateDynamicStepShape(step, stepIndex, dynamicFanoutConfig);
@@ -37,12 +46,16 @@ export function validateChainOutputBindings(steps: ChainStep[], dynamicFanoutCon
 				throw error;
 			}
 			if (!available.has(step.expand.from.output)) {
-				throw new ChainOutputValidationError(`Dynamic chain step ${stepIndex + 1} references unknown output '${step.expand.from.output}'. Named outputs are only available after producing step/group completes.`);
+				throw new ChainOutputValidationError(
+					`Dynamic chain step ${stepIndex + 1} references unknown output '${step.expand.from.output}'. Named outputs are only available after producing step/group completes.`,
+				);
 			}
 		}
 		for (const name of outputNamesForStep(step)) {
 			if (!SAFE_OUTPUT_NAME_PATTERN.test(name)) {
-				throw new ChainOutputValidationError(`Invalid chain output name '${name}' at step ${stepIndex + 1}. Use /^[A-Za-z_][A-Za-z0-9_]*$/.`);
+				throw new ChainOutputValidationError(
+					`Invalid chain output name '${name}' at step ${stepIndex + 1}. Use /^[A-Za-z_][A-Za-z0-9_]*$/.`,
+				);
 			}
 			if (seen.has(name)) {
 				throw new ChainOutputValidationError(`Duplicate chain output name '${name}'. Each as name must be unique.`);
@@ -54,10 +67,14 @@ export function validateChainOutputBindings(steps: ChainStep[], dynamicFanoutCon
 				const rawReference = match[0];
 				const name = match[1]!;
 				if (!SAFE_OUTPUT_NAME_PATTERN.test(name)) {
-					throw new ChainOutputValidationError(`Invalid chain output reference '${rawReference}' at step ${stepIndex + 1}. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`);
+					throw new ChainOutputValidationError(
+						`Invalid chain output reference '${rawReference}' at step ${stepIndex + 1}. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`,
+					);
 				}
 				if (!available.has(name)) {
-					throw new ChainOutputValidationError(`Unknown chain output reference '${rawReference}' at step ${stepIndex + 1}. Named outputs are only available after producing step/group completes.`);
+					throw new ChainOutputValidationError(
+						`Unknown chain output reference '${rawReference}' at step ${stepIndex + 1}. Named outputs are only available after producing step/group completes.`,
+					);
 				}
 			}
 		}
@@ -70,7 +87,9 @@ export function validateChainOutputBindings(steps: ChainStep[], dynamicFanoutCon
 export function resolveOutputReferences(template: string, outputs: ChainOutputMap): string {
 	return template.replace(OUTPUT_REF_PATTERN, (rawReference, name: string) => {
 		if (!SAFE_OUTPUT_NAME_PATTERN.test(name)) {
-			throw new ChainOutputValidationError(`Invalid chain output reference '${rawReference}'. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`);
+			throw new ChainOutputValidationError(
+				`Invalid chain output reference '${rawReference}'. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`,
+			);
 		}
 		const entry = outputs[name];
 		if (!entry) throw new ChainOutputValidationError(`Unknown chain output reference '${rawReference}'.`);
@@ -84,14 +103,20 @@ function compactStructuredText(value: unknown): string {
 
 export function outputEntryFromResult(result: SingleResult, stepIndex: number): ChainOutputMapEntry {
 	return {
-		text: result.structuredOutput !== undefined ? compactStructuredText(result.structuredOutput) : getSingleResultOutput(result),
+		text:
+			result.structuredOutput !== undefined
+				? compactStructuredText(result.structuredOutput)
+				: getSingleResultOutput(result),
 		...(result.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),
 		agent: result.agent,
 		stepIndex,
 	};
 }
 
-export function outputEntryFromAsyncResult(result: { agent: string; output: string; structuredOutput?: unknown }, stepIndex: number): ChainOutputMapEntry {
+export function outputEntryFromAsyncResult(
+	result: { agent: string; output: string; structuredOutput?: unknown },
+	stepIndex: number,
+): ChainOutputMapEntry {
 	return {
 		text: result.structuredOutput !== undefined ? compactStructuredText(result.structuredOutput) : result.output,
 		...(result.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),

package/dist/builtin/subagents/src/runs/shared/dynamic-fanout.ts

@@ -45,12 +45,39 @@ const RUNNER_DYNAMIC_STEP_KEYS = new Set(DYNAMIC_STEP_KEYS);
 const REMOVED_LEGACY_DYNAMIC_KEYS = new Set(["acceptance"]);
 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", "output", "outputMode", "reads", "progress", "skill", "model"]);
+const DYNAMIC_PARALLEL_KEYS = new Set([
+	"agent",
+	"task",
+	"phase",
+	"label",
+	"outputSchema",
+	"cwd",
+	"output",
+	"outputMode",
+	"reads",
+	"progress",
+	"skill",
+	"model",
+]);
 const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
 	...DYNAMIC_PARALLEL_KEYS,
-	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "maxSubagentDepth",
-	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "mcpDirectTools", "systemPrompt",
-	"systemPromptMode", "thinking", "modelCandidates", "sessionFile",
+	"outputName",
+	"structured",
+	"inheritProjectContext",
+	"inheritSkills",
+	"skills",
+	"outputPath",
+	"maxSubagentDepth",
+	"structuredOutput",
+	"structuredOutputSchema",
+	"tools",
+	"extensions",
+	"mcpDirectTools",
+	"systemPrompt",
+	"systemPromptMode",
+	"thinking",
+	"modelCandidates",
+	"sessionFile",
 ]);
 const DYNAMIC_COLLECT_KEYS = new Set(["as", "outputSchema"]);
 
@@ -93,7 +120,7 @@ export function resolveJsonPointer(value: unknown, pointer: string, label: strin
 			throw new DynamicFanoutError(`${label} does not exist.`);
 		}
 		const record = current as Record<string, unknown>;
-		if (!Object.prototype.hasOwnProperty.call(record, segment)) {
+		if (!Object.hasOwn(record, segment)) {
 			throw new DynamicFanoutError(`${label} does not exist.`);
 		}
 		current = record[segment];
@@ -130,7 +157,10 @@ function valueToTemplateText(value: unknown, reference: string): string {
 
 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("/")}`;
+	const pointer = `/${pathText
+		.split(".")
+		.map((segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1"))
+		.join("/")}`;
 	return resolveJsonPointer(item, pointer, reference);
 }
 
@@ -145,7 +175,8 @@ export function resolveItemTemplate(template: string, itemName: string, item: un
 }
 
 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.`);
+	if (!value || typeof value !== "object" || Array.isArray(value))
+		throw new DynamicFanoutError(`${label} must be an object.`);
 	for (const key of Object.keys(value)) {
 		if (REMOVED_LEGACY_DYNAMIC_KEYS.has(key)) continue;
 		if (!allowed.has(key)) throw new DynamicFanoutError(`${label} does not support field '${key}'.`);
@@ -154,7 +185,7 @@ function assertOnlyKeys(value: unknown, allowed: Set<string>, label: string): vo
 
 function stripRemovedLegacyDynamicKeys<T extends object>(value: T): T {
 	const entries = Object.entries(value).filter(([key]) => !REMOVED_LEGACY_DYNAMIC_KEYS.has(key));
-	return entries.length === Object.keys(value).length ? value : Object.fromEntries(entries) as T;
+	return entries.length === Object.keys(value).length ? value : (Object.fromEntries(entries) as T);
 }
 
 export function assertNoUnresolvedItemReferences(template: string, itemName: string, label: string): void {
@@ -181,21 +212,31 @@ export function assertNoUnresolvedItemReferences(template: string, itemName: str
 }
 
 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"));
+	return (
+		!!step &&
+		typeof step === "object" &&
+		!Array.isArray(step) &&
+		(Object.hasOwn(step, "expand") || Object.hasOwn(step, "collect"))
+	);
 }
 
-export function validateDynamicStepShape(step: DynamicParallelStep, stepIndex: number, config: DynamicFanoutConfig = {}): void {
+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.`);
+	if (!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}'.`);
+	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 (!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.`);
 	}
@@ -205,11 +246,20 @@ export function validateDynamicStepShape(step: DynamicParallelStep, stepIndex: n
 	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 || 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.`);
+	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],
@@ -219,33 +269,60 @@ export function validateDynamicStepShape(step: DynamicParallelStep, stepIndex: n
 	}
 }
 
-export function resolveDynamicFanoutItems(step: DynamicParallelStep, outputs: ChainOutputMap, stepIndex: number, config: DynamicFanoutConfig = {}): DynamicMaterializedItem[] {
+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.`);
+	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}.`);
+	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}'.`);
+		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}'.`);
+		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 {
+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") {
@@ -257,7 +334,9 @@ export function materializeDynamicParallelStep(step: DynamicParallelStep, output
 	const parallelTemplate = stripRemovedLegacyDynamicKeys(step.parallel);
 	const parallel = items.map((entry) => {
 		const task = resolveItemTemplate(parallelTemplate.task ?? "{previous}", itemName, entry.item);
-		const label = parallelTemplate.label ? resolveItemTemplate(parallelTemplate.label, itemName, entry.item) : undefined;
+		const label = parallelTemplate.label
+			? resolveItemTemplate(parallelTemplate.label, itemName, entry.item)
+			: undefined;
 		return {
 			...parallelTemplate,
 			task,
@@ -270,12 +349,19 @@ export function materializeDynamicParallelStep(step: DynamicParallelStep, output
 export function collectDynamicResults(
 	step: DynamicParallelStep,
 	items: DynamicMaterializedItem[],
-	results: Array<Pick<SingleResult, "agent" | "exitCode" | "error" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & { output?: string; finalOutput?: string }>,
+	results: Array<
+		Pick<SingleResult, "agent" | "exitCode" | "error" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & {
+			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))
+			? "output" in result && typeof result.output === "string"
+				? result.output
+				: getSingleResultOutput(result as SingleResult)
 			: "";
 		return {
 			key: entry.key,

package/dist/builtin/subagents/src/runs/shared/final-drain.ts

@@ -14,10 +14,13 @@ export function isAssistantFailureStopReason(stopReason: string | undefined): bo
 }
 
 export function assistantMessageHasToolCall(message: SubagentAssistantDrainMessage): boolean {
-	return Array.isArray(message.content)
-		&& message.content.some((part) => part !== null
-			&& typeof part === "object"
-			&& (part as { readonly type?: unknown }).type === "toolCall");
+	return (
+		Array.isArray(message.content) &&
+		message.content.some(
+			(part) =>
+				part !== null && typeof part === "object" && (part as { readonly type?: unknown }).type === "toolCall",
+		)
+	);
 }
 
 function assistantMessageHasError(message: SubagentAssistantDrainMessage): boolean {
@@ -28,7 +31,9 @@ function assistantMessageHasError(message: SubagentAssistantDrainMessage): boole
 
 export function shouldStartSubagentFinalDrain(message: SubagentAssistantDrainMessage): boolean {
 	if (message.role !== undefined && message.role !== "assistant") return false;
-	return assistantStopReason(message) === "stop"
-		&& !assistantMessageHasError(message)
-		&& !assistantMessageHasToolCall(message);
+	return (
+		assistantStopReason(message) === "stop" &&
+		!assistantMessageHasError(message) &&
+		!assistantMessageHasToolCall(message)
+	);
 }

package/dist/builtin/subagents/src/runs/shared/intercom-group.ts

@@ -44,7 +44,8 @@ export function sharedAutoGroupForSet(
 	setGroup: string | true | undefined,
 	items: ReadonlyArray<{ group?: string | true }>,
 ): string | undefined {
-	const needsAuto = normalizeAutoGroupSentinel(setGroup) === true
-		|| items.some((item) => normalizeAutoGroupSentinel(item.group) === true);
+	const needsAuto =
+		normalizeAutoGroupSentinel(setGroup) === true ||
+		items.some((item) => normalizeAutoGroupSentinel(item.group) === true);
 	return needsAuto ? randomUUID() : undefined;
 }

package/dist/builtin/subagents/src/runs/shared/long-running-guard.ts

@@ -52,7 +52,10 @@ const MUTATING_FAILURE_HINTS = [
 	"could not",
 ];
 
-export function resolveCurrentPath(toolName: string | undefined, args: Record<string, unknown> | undefined): string | undefined {
+export function resolveCurrentPath(
+	toolName: string | undefined,
+	args: Record<string, unknown> | undefined,
+): string | undefined {
 	if (!toolName || !args) return undefined;
 	const direct = ["path", "file", "filename", "target", "cwd"];
 	for (const key of direct) {
@@ -119,8 +122,10 @@ export function nextLongRunningTrigger(
 	metrics: LongRunningNoticeMetrics,
 ): LongRunningTriggerReason | undefined {
 	if (metrics.now - metrics.startedAt >= config.activeNoticeAfterMs) return "time_threshold";
-	if (config.activeNoticeAfterTurns !== undefined && metrics.turns >= config.activeNoticeAfterTurns) return "turn_threshold";
-	if (config.activeNoticeAfterTokens !== undefined && metrics.tokens >= config.activeNoticeAfterTokens) return "token_threshold";
+	if (config.activeNoticeAfterTurns !== undefined && metrics.turns >= config.activeNoticeAfterTurns)
+		return "turn_threshold";
+	if (config.activeNoticeAfterTokens !== undefined && metrics.tokens >= config.activeNoticeAfterTokens)
+		return "token_threshold";
 	return undefined;
 }