@bastani/atomic 0.9.11-alpha.8 → 0.9.11

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

@@ -1,4 +1,5 @@
 import type { Message } from "@earendil-works/pi-ai/compat";
+import type { SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
 import type {
 	ActivityState,
 	ArtifactConfig,
@@ -11,13 +12,12 @@ import type {
 	NestedRouteInfo,
 	ResolvedControlConfig,
 	SubagentRunMode,
+	TokenUsage,
 	Usage,
 	WorkflowGraphSnapshot,
 } from "../../shared/types.ts";
-import type { TokenUsage } from "../../shared/types.ts";
 import type { RunnerStep, RunnerSubagentStep as SubagentStep } from "../shared/parallel-utils.ts";
 import type { WorktreeSetup } from "../shared/worktree.ts";
-import type { SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
 
 export interface SubagentRunConfig {
 	id: string;
@@ -48,7 +48,12 @@ export interface SubagentRunConfig {
 	workflowGraph?: WorkflowGraphSnapshot;
 	nestedRoute?: NestedRouteInfo;
 	workflowStageSubagentGuard?: boolean;
-	nestedSelf?: { parentRunId: string; parentStepIndex?: number; depth: number; path?: Array<{ runId: string; stepIndex?: number; agent?: string }> };
+	nestedSelf?: {
+		parentRunId: string;
+		parentStepIndex?: number;
+		depth: number;
+		path?: Array<{ runId: string; stepIndex?: number; agent?: string }>;
+	};
 }
 
 export interface StepResult {
@@ -142,7 +147,10 @@ export type RunnerStatusStep = NonNullable<AsyncStatus["steps"]>[number] & {
 	exitCode?: number | null;
 };
 
-export type RunnerStatusPayload = Omit<AsyncStatus, "steps" | "parallelGroups" | "pid" | "cwd" | "currentStep" | "chainStepCount" | "lastUpdate"> & {
+export type RunnerStatusPayload = Omit<
+	AsyncStatus,
+	"steps" | "parallelGroups" | "pid" | "cwd" | "currentStep" | "chainStepCount" | "lastUpdate"
+> & {
 	pid: number;
 	cwd: string;
 	currentStep: number;
@@ -189,7 +197,9 @@ export interface RunnerExecutionState {
 	sessionEnabled: boolean;
 	statusPayload: RunnerStatusPayload;
 	flatIndex: number;
-	mutatingFailureStates: Array<ReturnType<typeof import("../shared/long-running-guard.ts").createMutatingFailureState>>;
+	mutatingFailureStates: Array<
+		ReturnType<typeof import("../shared/long-running-guard.ts").createMutatingFailureState>
+	>;
 	pendingToolResults: Array<{ tool: string; path?: string; mutates: boolean; startedAt?: number } | undefined>;
 	emittedControlEventKeys: Set<string>;
 	activeLongRunningSteps: Set<number>;
@@ -197,4 +207,4 @@ export interface RunnerExecutionState {
 
 export type ParallelGroup = Extract<RunnerStep, { parallel: SubagentStep[] }>;
 export type DynamicGroup = Extract<RunnerStep, { collect: { as: string } }>;
-export type { SubagentStep, RunnerStep, WorktreeSetup };
+export type { RunnerStep, SubagentStep, WorktreeSetup };

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

@@ -1,7 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { TokenUsage, Usage } from "../../shared/types.ts";
-import type { ModelAttempt } from "../../shared/types.ts";
+import type { ModelAttempt, TokenUsage, Usage } from "../../shared/types.ts";
 import type { RunnerStatusStep, SubagentStep } from "./subagent-runner-types.ts";
 
 export function findLatestSessionFile(sessionDir: string): string | null {
@@ -54,7 +53,7 @@ export function resetStepLiveDetail(step: RunnerStatusStep): void {
 }
 
 export function fastModeForStepAttempt(step: SubagentStep, model: string | undefined): boolean | undefined {
-	if (model && step.modelFastModes && Object.prototype.hasOwnProperty.call(step.modelFastModes, model)) {
+	if (model && step.modelFastModes && Object.hasOwn(step.modelFastModes, model)) {
 		return step.modelFastModes[model];
 	}
 	if (model === undefined || model === step.model) return step.fastMode;

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

@@ -15,14 +15,17 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 	startActivityTimer(state);
 	const onInterrupt = () => interruptRunner(state);
 	process.on(ASYNC_INTERRUPT_SIGNAL, onInterrupt);
-	appendJsonl(state.eventsPath, JSON.stringify({
-		type: "subagent.run.started",
-		ts: state.overallStartTime,
-		runId: state.id,
-		mode: state.statusPayload.mode,
-		cwd: state.cwd,
-		pid: process.pid,
-	}));
+	appendJsonl(
+		state.eventsPath,
+		JSON.stringify({
+			type: "subagent.run.started",
+			ts: state.overallStartTime,
+			runId: state.id,
+			mode: state.statusPayload.mode,
+			cwd: state.cwd,
+			pid: process.pid,
+		}),
+	);
 
 	try {
 		for (let stepIndex = 0; stepIndex < state.steps.length; stepIndex++) {

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

@@ -1,6 +1,6 @@
+import type { Details } from "../../shared/types.ts";
 import { compactForegroundDetails } from "../../shared/utils.ts";
 import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
-import type { Details } from "../../shared/types.ts";
 import type { ChainExecutionDetailsInput, ChainExecutionResult } from "./chain-execution-types.ts";
 
 export function buildChainExecutionDetails(input: ChainExecutionDetailsInput): Details {
@@ -26,7 +26,10 @@ export function buildChainExecutionDetails(input: ChainExecutionDetailsInput): D
 	});
 }
 
-export function buildChainExecutionErrorResult(message: string, input: ChainExecutionDetailsInput): ChainExecutionResult {
+export function buildChainExecutionErrorResult(
+	message: string,
+	input: ChainExecutionDetailsInput,
+): ChainExecutionResult {
 	return {
 		content: [{ type: "text", text: message }],
 		isError: true,

package/dist/builtin/subagents/src/runs/foreground/chain-execution-dynamic-step.ts

@@ -1,25 +1,25 @@
 import * as path from "node:path";
+import { buildChainSummary } from "../../shared/formatters.ts";
 import {
 	aggregateParallelOutputs,
 	createParallelDirs,
-	resolveParallelBehaviors,
-	suppressProgressForReadOnlyTask,
 	type DynamicParallelStep,
 	type ParallelStep,
 	type ParallelTaskResult,
+	resolveParallelBehaviors,
+	suppressProgressForReadOnlyTask,
 } from "../../shared/settings.ts";
 import { getSingleResultOutput } from "../../shared/utils.ts";
-import { buildChainSummary } from "../../shared/formatters.ts";
-import { buildChainExecutionDetails, buildChainExecutionErrorResult } from "./chain-execution-details.ts";
-import { ensureParallelProgressFile, runParallelChainTasks } from "./chain-execution-parallel-runner.ts";
-import { validateFileOnlyOutputMode } from "../shared/single-output.ts";
 import {
 	collectDynamicResults,
+	type DynamicCollectedResult,
 	DynamicFanoutError,
 	materializeDynamicParallelStep,
 	validateDynamicCollection,
-	type DynamicCollectedResult,
 } from "../shared/dynamic-fanout.ts";
+import { validateFileOnlyOutputMode } from "../shared/single-output.ts";
+import { buildChainExecutionDetails, buildChainExecutionErrorResult } from "./chain-execution-details.ts";
+import { ensureParallelProgressFile, runParallelChainTasks } from "./chain-execution-parallel-runner.ts";
 import type { ChainExecutionMutableState, ChainExecutionResult, ChainRuntimeContext } from "./chain-execution-types.ts";
 
 export async function runDynamicParallelChainStep(input: {
@@ -31,11 +31,17 @@ export async function runDynamicParallelChainStep(input: {
 	const { context, state, step, stepIndex } = input;
 	let materialized: ReturnType<typeof materializeDynamicParallelStep>;
 	try {
-		materialized = materializeDynamicParallelStep(step, state.outputs, stepIndex, { maxItems: context.params.dynamicFanoutMaxItems });
+		materialized = materializeDynamicParallelStep(step, state.outputs, stepIndex, {
+			maxItems: context.params.dynamicFanoutMaxItems,
+		});
 	} catch (error) {
-		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);
 		state.dynamicGroupStatuses[stepIndex] = { status: "failed", error: message };
-		return buildChainExecutionErrorResult(message, context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex }));
+		return buildChainExecutionErrorResult(
+			message,
+			context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex }),
+		);
 	}
 
 	state.dynamicChildren[stepIndex] = materialized.items.map((item, itemIndex) => ({
@@ -51,9 +57,17 @@ export async function runDynamicParallelChainStep(input: {
 		try {
 			validateDynamicCollection(step.collect.outputSchema, collection);
 		} catch (error) {
-			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);
 			state.dynamicGroupStatuses[stepIndex] = { status: "failed", error: message };
-			return buildChainExecutionErrorResult(message, context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex }));
+			return buildChainExecutionErrorResult(
+				message,
+				context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex }),
+			);
 		}
 		state.outputs[step.collect.as] = {
 			text: JSON.stringify(collection),
@@ -73,23 +87,51 @@ export async function runDynamicParallelChainStep(input: {
 		group: step.group,
 	};
 	const parallelTemplates = materialized.parallel.map((task) => task.task ?? "{previous}");
-	const parallelBehaviors = resolveParallelBehaviors(dynamicParallelStep.parallel, context.agents, stepIndex, context.chainSkills)
-		.map((behavior, taskIndex) => suppressProgressForReadOnlyTask(behavior, parallelTemplates[taskIndex] ?? dynamicParallelStep.parallel[taskIndex]?.task, context.originalTask));
+	const parallelBehaviors = resolveParallelBehaviors(
+		dynamicParallelStep.parallel,
+		context.agents,
+		stepIndex,
+		context.chainSkills,
+	).map((behavior, taskIndex) =>
+		suppressProgressForReadOnlyTask(
+			behavior,
+			parallelTemplates[taskIndex] ?? dynamicParallelStep.parallel[taskIndex]?.task,
+			context.originalTask,
+		),
+	);
 
 	for (let taskIndex = 0; taskIndex < dynamicParallelStep.parallel.length; taskIndex++) {
 		const behavior = parallelBehaviors[taskIndex]!;
-		const outputPath = typeof behavior.output === "string"
-			? (path.isAbsolute(behavior.output) ? behavior.output : path.join(context.chainDir, behavior.output))
-			: undefined;
-		const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Dynamic chain step ${stepIndex + 1} item ${taskIndex + 1} (${dynamicParallelStep.parallel[taskIndex]!.agent})`);
+		const outputPath =
+			typeof behavior.output === "string"
+				? path.isAbsolute(behavior.output)
+					? behavior.output
+					: path.join(context.chainDir, behavior.output)
+				: undefined;
+		const validationError = validateFileOnlyOutputMode(
+			behavior.outputMode,
+			outputPath,
+			`Dynamic chain step ${stepIndex + 1} item ${taskIndex + 1} (${dynamicParallelStep.parallel[taskIndex]!.agent})`,
+		);
 		if (validationError) {
 			state.dynamicGroupStatuses[stepIndex] = { status: "failed", error: validationError };
-			return buildChainExecutionErrorResult(validationError, context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: state.globalTaskIndex + taskIndex }));
+			return buildChainExecutionErrorResult(
+				validationError,
+				context.makeDetailsInput({
+					currentStepIndex: stepIndex,
+					currentFlatIndex: state.globalTaskIndex + taskIndex,
+				}),
+			);
 		}
 	}
 
 	state.progressCreated = ensureParallelProgressFile(context.chainDir, state.progressCreated, parallelBehaviors);
-	createParallelDirs(context.chainDir, stepIndex, dynamicParallelStep.parallel.length, dynamicParallelStep.parallel.map((task) => task.agent));
+	createParallelDirs(
+		context.chainDir,
+		stepIndex,
+		dynamicParallelStep.parallel.length,
+		dynamicParallelStep.parallel.map((task) => task.agent),
+	);
 	const parallelResults = await runParallelChainTasks({
 		step: dynamicParallelStep,
 		chainIntercomGroup: context.params.group,
@@ -146,38 +188,75 @@ export async function runDynamicParallelChainStep(input: {
 	const interrupted = interruptedIndexInStep >= 0 ? parallelResults[interruptedIndexInStep] : undefined;
 	if (interrupted) {
 		return {
-			content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${interrupted.agent}). Waiting for explicit next action.` }],
-			details: buildChainExecutionDetails(context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: baseFlatIndex + interruptedIndexInStep })),
+			content: [
+				{
+					type: "text",
+					text: `Chain paused after interrupt at step ${stepIndex + 1} (${interrupted.agent}). Waiting for explicit next action.`,
+				},
+			],
+			details: buildChainExecutionDetails(
+				context.makeDetailsInput({
+					currentStepIndex: stepIndex,
+					currentFlatIndex: baseFlatIndex + interruptedIndexInStep,
+				}),
+			),
 		};
 	}
 	const detachedIndexInStep = parallelResults.findIndex((result) => result.detached);
 	const detached = detachedIndexInStep >= 0 ? parallelResults[detachedIndexInStep] : undefined;
 	if (detached) {
 		return {
-			content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${detached.agent}). Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.` }],
-			details: buildChainExecutionDetails(context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: baseFlatIndex + detachedIndexInStep })),
+			content: [
+				{
+					type: "text",
+					text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${detached.agent}). Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.`,
+				},
+			],
+			details: buildChainExecutionDetails(
+				context.makeDetailsInput({
+					currentStepIndex: stepIndex,
+					currentFlatIndex: baseFlatIndex + detachedIndexInStep,
+				}),
+			),
 		};
 	}
-	const failures = parallelResults.map((result, originalIndex) => ({ ...result, originalIndex })).filter((result) => result.exitCode !== 0 && result.exitCode !== -1);
+	const failures = parallelResults
+		.map((result, originalIndex) => ({ ...result, originalIndex }))
+		.filter((result) => result.exitCode !== 0 && result.exitCode !== -1);
 	if (failures.length > 0) {
 		const failureSummary = failures
-			.map((failure) => `- Item ${failure.originalIndex + 1} (${failure.agent}, key ${materialized.items[failure.originalIndex]?.key ?? failure.originalIndex}): ${failure.error || "failed"}`)
+			.map(
+				(failure) =>
+					`- Item ${failure.originalIndex + 1} (${failure.agent}, key ${materialized.items[failure.originalIndex]?.key ?? failure.originalIndex}): ${failure.error || "failed"}`,
+			)
 			.join("\n");
 		const errorMsg = `Dynamic step ${stepIndex + 1} failed:\n${failureSummary}`;
 		state.dynamicGroupStatuses[stepIndex] = { status: "failed", error: errorMsg };
-		const summary = buildChainSummary(context.chainSteps, state.results, context.chainDir, "failed", { index: stepIndex, error: errorMsg });
+		const summary = buildChainSummary(context.chainSteps, state.results, context.chainDir, "failed", {
+			index: stepIndex,
+			error: errorMsg,
+		});
 		return {
 			content: [{ type: "text", text: summary }],
 			isError: true,
-			details: buildChainExecutionDetails(context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: baseFlatIndex + failures[0]!.originalIndex })),
+			details: buildChainExecutionDetails(
+				context.makeDetailsInput({
+					currentStepIndex: stepIndex,
+					currentFlatIndex: baseFlatIndex + failures[0]!.originalIndex,
+				}),
+			),
 		};
 	}
 	try {
 		validateDynamicCollection(step.collect.outputSchema, collected);
 	} catch (error) {
-		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);
 		state.dynamicGroupStatuses[stepIndex] = { status: "failed", error: message };
-		return buildChainExecutionErrorResult(message, context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: baseFlatIndex }));
+		return buildChainExecutionErrorResult(
+			message,
+			context.makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: baseFlatIndex }),
+		);
 	}
 	state.outputs[step.collect.as] = {
 		text: JSON.stringify(collected),
@@ -193,6 +272,9 @@ export async function runDynamicParallelChainStep(input: {
 		exitCode: result.exitCode,
 		error: result.error,
 	}));
-	state.prev = aggregateParallelOutputs(taskResults, (index, agent) => `=== Dynamic Item ${index + 1} (${agent}, key ${materialized.items[index]?.key ?? index}) ===`);
+	state.prev = aggregateParallelOutputs(
+		taskResults,
+		(index, agent) => `=== Dynamic Item ${index + 1} (${agent}, key ${materialized.items[index]?.key ?? index}) ===`,
+	);
 	return undefined;
 }

package/dist/builtin/subagents/src/runs/foreground/chain-execution-parallel-runner.ts

@@ -1,21 +1,21 @@
 import * as path from "node:path";
 import { INTERCOM_BRIDGE_MARKER } from "../../intercom/intercom-bridge.ts";
-import { mapConcurrent, resolveChildCwd } from "../../shared/utils.ts";
-import { MAX_CONCURRENCY, resolveChildMaxSubagentDepth, type SingleResult } from "../../shared/types.ts";
-import { workflowSessionMetadataFromContext } from "../../shared/types-depth.ts";
 import {
 	buildChainInstructions,
+	type ResolvedStepBehavior,
 	suppressProgressForReadOnlyTask,
 	writeInitialProgressFile,
-	type ResolvedStepBehavior,
 } from "../../shared/settings.ts";
-import { recordRun } from "../shared/run-history.ts";
+import { MAX_CONCURRENCY, resolveChildMaxSubagentDepth, type SingleResult } from "../../shared/types.ts";
+import { workflowSessionMetadataFromContext } from "../../shared/types-depth.ts";
+import { mapConcurrent, resolveChildCwd } from "../../shared/utils.ts";
+import { resolveOutputReferences } from "../shared/chain-outputs.ts";
+import { inheritedIntercomGroup, resolveChildIntercomGroup, sharedAutoGroupForSet } from "../shared/intercom-group.ts";
 import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
+import { recordRun } from "../shared/run-history.ts";
+import { createStructuredOutputRuntime } from "../shared/structured-output.ts";
 import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
 import { diffWorktrees, formatWorktreeDiffSummary, type WorktreeSetup } from "../shared/worktree.ts";
-import { resolveOutputReferences } from "../shared/chain-outputs.ts";
-import { createStructuredOutputRuntime } from "../shared/structured-output.ts";
-import { inheritedIntercomGroup, resolveChildIntercomGroup, sharedAutoGroupForSet } from "../shared/intercom-group.ts";
 import type { ParallelChainRunInput } from "./chain-execution-types.ts";
 
 export function ensureParallelProgressFile(
@@ -71,7 +71,11 @@ export async function runParallelChainTasks(input: ParallelChainRunInput): Promi
 		}
 
 		const taskTemplate = input.parallelTemplates[taskIndex] ?? "{previous}";
-		const behavior = suppressProgressForReadOnlyTask(input.parallelBehaviors[taskIndex]!, taskTemplate, input.originalTask);
+		const behavior = suppressProgressForReadOnlyTask(
+			input.parallelBehaviors[taskIndex]!,
+			taskTemplate,
+			input.originalTask,
+		);
 		const templateHasPrevious = taskTemplate.includes("{previous}");
 		const { prefix, suffix } = buildChainInstructions(
 			behavior,
@@ -89,15 +93,18 @@ export async function runParallelChainTasks(input: ParallelChainRunInput): Promi
 
 		const taskAgentConfig = input.agents.find((agent) => agent.name === task.agent);
 		const effectiveModel =
-			(task.model ? resolveModelCandidate(task.model, input.availableModels, input.ctx.model?.provider) : null)
-			?? resolveModelCandidate(taskAgentConfig?.model, input.availableModels, input.ctx.model?.provider);
+			(task.model ? resolveModelCandidate(task.model, input.availableModels, input.ctx.model?.provider) : null) ??
+			resolveModelCandidate(taskAgentConfig?.model, input.availableModels, input.ctx.model?.provider);
 		const maxSubagentDepth = resolveChildMaxSubagentDepth(input.maxSubagentDepth, taskAgentConfig?.maxSubagentDepth);
 		const taskCwd = input.worktreeSetup
 			? input.worktreeSetup.worktrees[taskIndex]!.agentCwd
 			: resolveChildCwd(input.cwd ?? input.ctx.cwd, task.cwd);
-		const outputPath = typeof behavior.output === "string"
-			? (path.isAbsolute(behavior.output) ? behavior.output : path.join(input.chainDir, behavior.output))
-			: undefined;
+		const outputPath =
+			typeof behavior.output === "string"
+				? path.isAbsolute(behavior.output)
+					? behavior.output
+					: path.join(input.chainDir, behavior.output)
+				: undefined;
 		const interruptController = new AbortController();
 		if (input.foregroundControl) {
 			input.foregroundControl.currentAgent = task.agent;
@@ -154,47 +161,49 @@ export async function runParallelChainTasks(input: ParallelChainRunInput): Promi
 			preferredModelProvider: input.ctx.model?.provider,
 			skills: behavior.skills === false ? [] : behavior.skills,
 			structuredOutput: structuredRuntime,
-			onUpdate: input.onUpdate ? (progressUpdate) => {
-				const stepResults = progressUpdate.details?.results || [];
-				const stepProgress = progressUpdate.details?.progress || [];
-				if (input.foregroundControl && stepProgress.length > 0) {
-					const current = stepProgress[0];
-					input.foregroundControl.currentAgent = task.agent;
-					input.foregroundControl.currentIndex = input.globalTaskIndex + taskIndex;
-					input.foregroundControl.currentActivityState = current?.activityState;
-					input.foregroundControl.lastActivityAt = current?.lastActivityAt;
-					input.foregroundControl.currentTool = current?.currentTool;
-					input.foregroundControl.currentToolStartedAt = current?.currentToolStartedAt;
-					input.foregroundControl.currentPath = current?.currentPath;
-					input.foregroundControl.turnCount = current?.turnCount;
-					input.foregroundControl.tokens = current?.tokens;
-					input.foregroundControl.toolCount = current?.toolCount;
-					input.foregroundControl.updatedAt = Date.now();
-				}
-				input.onUpdate?.({
-					...progressUpdate,
-					details: {
-						mode: "chain",
-						results: input.results.concat(stepResults),
-						progress: input.allProgress.concat(stepProgress),
-						controlEvents: progressUpdate.details?.controlEvents,
-						chainAgents: input.chainAgents,
-						totalSteps: input.totalSteps,
-						currentStepIndex: input.stepIndex,
-						outputs: input.outputs,
-						workflowGraph: buildWorkflowGraphSnapshot({
-							runId: input.runId,
-							mode: "chain",
-							steps: input.chainSteps,
-							results: input.results.concat(stepResults),
-							currentStepIndex: input.stepIndex,
-							currentFlatIndex: input.globalTaskIndex + taskIndex,
-							dynamicChildren: input.dynamicChildren,
-							dynamicGroupStatuses: input.dynamicGroupStatuses,
-						}),
-					},
-				});
-			} : undefined,
+			onUpdate: input.onUpdate
+				? (progressUpdate) => {
+						const stepResults = progressUpdate.details?.results || [];
+						const stepProgress = progressUpdate.details?.progress || [];
+						if (input.foregroundControl && stepProgress.length > 0) {
+							const current = stepProgress[0];
+							input.foregroundControl.currentAgent = task.agent;
+							input.foregroundControl.currentIndex = input.globalTaskIndex + taskIndex;
+							input.foregroundControl.currentActivityState = current?.activityState;
+							input.foregroundControl.lastActivityAt = current?.lastActivityAt;
+							input.foregroundControl.currentTool = current?.currentTool;
+							input.foregroundControl.currentToolStartedAt = current?.currentToolStartedAt;
+							input.foregroundControl.currentPath = current?.currentPath;
+							input.foregroundControl.turnCount = current?.turnCount;
+							input.foregroundControl.tokens = current?.tokens;
+							input.foregroundControl.toolCount = current?.toolCount;
+							input.foregroundControl.updatedAt = Date.now();
+						}
+						input.onUpdate?.({
+							...progressUpdate,
+							details: {
+								mode: "chain",
+								results: input.results.concat(stepResults),
+								progress: input.allProgress.concat(stepProgress),
+								controlEvents: progressUpdate.details?.controlEvents,
+								chainAgents: input.chainAgents,
+								totalSteps: input.totalSteps,
+								currentStepIndex: input.stepIndex,
+								outputs: input.outputs,
+								workflowGraph: buildWorkflowGraphSnapshot({
+									runId: input.runId,
+									mode: "chain",
+									steps: input.chainSteps,
+									results: input.results.concat(stepResults),
+									currentStepIndex: input.stepIndex,
+									currentFlatIndex: input.globalTaskIndex + taskIndex,
+									dynamicChildren: input.dynamicChildren,
+									dynamicGroupStatuses: input.dynamicGroupStatuses,
+								}),
+							},
+						});
+					}
+				: undefined,
 		});
 		if (input.foregroundControl?.currentIndex === input.globalTaskIndex + taskIndex) {
 			input.foregroundControl.interrupt = undefined;