@bastani/atomic 0.9.12 → 0.9.13-alpha.1

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

@@ -1,128 +0,0 @@
-import * as path from "node:path";
-import { appendJsonl } from "../../shared/artifacts.ts";
-import { writeAtomicJson } from "../../shared/atomic-json.ts";
-import { writeInitialProgressFile } from "../../shared/settings.ts";
-import { diffWorktrees, formatWorktreeDiffSummary, type WorktreeSetup } from "../shared/worktree.ts";
-import type { ParallelGroup, RunnerStatusPayload, StepResult, SubagentStep } from "./subagent-runner-types.ts";
-
-export function markParallelGroupSetupFailure(input: {
-	statusPayload: RunnerStatusPayload;
-	results: StepResult[];
-	group: ParallelGroup;
-	groupStartFlatIndex: number;
-	setupError: string;
-	failedAt: number;
-	statusPath: string;
-	eventsPath: string;
-	asyncDir: string;
-	runId: string;
-	stepIndex: number;
-}): void {
-	for (let taskIndex = 0; taskIndex < input.group.parallel.length; taskIndex++) {
-		const flatTaskIndex = input.groupStartFlatIndex + taskIndex;
-		input.statusPayload.steps[flatTaskIndex].status = "failed";
-		input.statusPayload.steps[flatTaskIndex].startedAt = input.failedAt;
-		input.statusPayload.steps[flatTaskIndex].endedAt = input.failedAt;
-		input.statusPayload.steps[flatTaskIndex].durationMs = 0;
-		input.statusPayload.steps[flatTaskIndex].exitCode = 1;
-		input.results.push({
-			agent: input.group.parallel[taskIndex].agent,
-			output: input.setupError,
-			success: false,
-			exitCode: 1,
-			sessionFile: input.group.parallel[taskIndex].sessionFile,
-		});
-	}
-	input.statusPayload.currentStep = input.groupStartFlatIndex;
-	input.statusPayload.lastUpdate = input.failedAt;
-	input.statusPayload.outputFile = path.join(input.asyncDir, `output-${input.groupStartFlatIndex}.log`);
-	writeAtomicJson(input.statusPath, input.statusPayload);
-	appendJsonl(
-		input.eventsPath,
-		JSON.stringify({
-			type: "subagent.parallel.completed",
-			ts: input.failedAt,
-			runId: input.runId,
-			stepIndex: input.stepIndex,
-			success: false,
-		}),
-	);
-}
-
-export function markParallelGroupRunning(input: {
-	statusPayload: RunnerStatusPayload;
-	group: ParallelGroup;
-	groupStartFlatIndex: number;
-	groupStartTime: number;
-	statusPath: string;
-	eventsPath: string;
-	asyncDir: string;
-	runId: string;
-	stepIndex: number;
-}): void {
-	for (let taskIndex = 0; taskIndex < input.group.parallel.length; taskIndex++) {
-		const flatTaskIndex = input.groupStartFlatIndex + taskIndex;
-		input.statusPayload.steps[flatTaskIndex].status = "pending";
-		input.statusPayload.steps[flatTaskIndex].startedAt = undefined;
-		input.statusPayload.steps[flatTaskIndex].endedAt = undefined;
-		input.statusPayload.steps[flatTaskIndex].durationMs = undefined;
-		input.statusPayload.steps[flatTaskIndex].lastActivityAt = undefined;
-		input.statusPayload.steps[flatTaskIndex].activityState = undefined;
-		input.statusPayload.steps[flatTaskIndex].error = undefined;
-	}
-	input.statusPayload.currentStep = input.groupStartFlatIndex;
-	input.statusPayload.activityState = undefined;
-	input.statusPayload.lastActivityAt = input.groupStartTime;
-	input.statusPayload.lastUpdate = input.groupStartTime;
-	input.statusPayload.outputFile = path.join(input.asyncDir, `output-${input.groupStartFlatIndex}.log`);
-	writeAtomicJson(input.statusPath, input.statusPayload);
-	appendJsonl(
-		input.eventsPath,
-		JSON.stringify({
-			type: "subagent.parallel.started",
-			ts: input.groupStartTime,
-			runId: input.runId,
-			stepIndex: input.stepIndex,
-			agents: input.group.parallel.map((task) => task.agent),
-			count: input.group.parallel.length,
-		}),
-	);
-}
-
-export function prepareParallelTaskRun(
-	task: SubagentStep,
-	cwd: string,
-	worktreeSetup: WorktreeSetup | undefined,
-	taskIndex: number,
-): { taskForRun: SubagentStep; taskCwd: string } {
-	if (!worktreeSetup) return { taskForRun: task, taskCwd: cwd };
-	return {
-		taskForRun: { ...task, cwd: undefined },
-		taskCwd: worktreeSetup.worktrees[taskIndex]!.agentCwd,
-	};
-}
-
-export function appendParallelWorktreeSummary(
-	previousOutput: string,
-	worktreeSetup: WorktreeSetup | undefined,
-	asyncDir: string,
-	stepIndex: number,
-	group: ParallelGroup,
-): string {
-	if (!worktreeSetup) return previousOutput;
-	const diffsDir = path.join(asyncDir, "worktree-diffs", `step-${stepIndex}`);
-	const diffs = diffWorktrees(
-		worktreeSetup,
-		group.parallel.map((task) => task.agent),
-		diffsDir,
-	);
-	const diffSummary = formatWorktreeDiffSummary(diffs);
-	if (!diffSummary) return previousOutput;
-	return `${previousOutput}\n\n${diffSummary}`;
-}
-
-export function ensureParallelProgressFile(cwd: string, group: ParallelGroup): void {
-	const progressPath = path.join(cwd, "progress.md");
-	if (!group.parallel.some((task) => task.task.includes(`Update progress at: ${progressPath}`))) return;
-	writeInitialProgressFile(cwd);
-}

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

@@ -1,309 +0,0 @@
-import * as path from "node:path";
-import { appendJsonl } from "../../shared/artifacts.ts";
-import { resolveEffectiveThinking } from "../../shared/model-info.ts";
-import { parseSessionTokens } from "../../shared/session-tokens.ts";
-import { aggregateParallelOutputs, MAX_PARALLEL_CONCURRENCY, mapConcurrent } from "../shared/parallel-utils.ts";
-import {
-	cleanupWorktrees,
-	createWorktrees,
-	findWorktreeTaskCwdConflict,
-	formatWorktreeTaskCwdConflict,
-	type WorktreeSetup,
-} from "../shared/worktree.ts";
-import {
-	appendParallelWorktreeSummary,
-	ensureParallelProgressFile,
-	markParallelGroupRunning,
-	markParallelGroupSetupFailure,
-	prepareParallelTaskRun,
-} from "./subagent-runner-parallel-helpers.ts";
-import {
-	resetStepLiveDetail,
-	updateStepFromChildEvent,
-	updateStepModel,
-	writeStatusPayload,
-} from "./subagent-runner-state.ts";
-import { outputEntryFromAsyncResult, runSingleStep } from "./subagent-runner-step.ts";
-import type { ParallelGroup, RunnerExecutionState } from "./subagent-runner-types.ts";
-import { tokenUsageFromAttempts } from "./subagent-runner-utils.ts";
-
-export async function runParallelGroup(
-	state: RunnerExecutionState,
-	group: ParallelGroup,
-	stepIndex: number,
-): Promise<boolean> {
-	const { cwd, asyncDir, id, placeholder, sessionEnabled, outputs, config, artifactsDir, artifactConfig, flatSteps } =
-		state;
-	const { statusPayload } = state;
-	const concurrency = group.concurrency ?? MAX_PARALLEL_CONCURRENCY;
-	const failFast = group.failFast ?? false;
-	const groupStartFlatIndex = state.flatIndex;
-	let aborted = false;
-	let worktreeSetup: WorktreeSetup | undefined;
-	if (group.worktree) {
-		const worktreeTaskCwdConflict = findWorktreeTaskCwdConflict(group.parallel, cwd);
-		if (worktreeTaskCwdConflict) {
-			const failedAt = Date.now();
-			markParallelGroupSetupFailure({
-				statusPayload,
-				results: state.results,
-				group,
-				groupStartFlatIndex,
-				setupError: formatWorktreeTaskCwdConflict(worktreeTaskCwdConflict, cwd),
-				failedAt,
-				statusPath: state.statusPath,
-				eventsPath: state.eventsPath,
-				asyncDir,
-				runId: id,
-				stepIndex,
-			});
-			state.flatIndex += group.parallel.length;
-			return false;
-		}
-		try {
-			worktreeSetup = createWorktrees(cwd, `${id}-s${stepIndex}`, group.parallel.length, {
-				agents: group.parallel.map((task) => task.agent),
-				setupHook: config.worktreeSetupHook
-					? { hookPath: config.worktreeSetupHook, timeoutMs: config.worktreeSetupHookTimeoutMs }
-					: undefined,
-			});
-		} catch (error) {
-			const setupError = error instanceof Error ? error.message : String(error);
-			const failedAt = Date.now();
-			markParallelGroupSetupFailure({
-				statusPayload,
-				results: state.results,
-				group,
-				groupStartFlatIndex,
-				setupError,
-				failedAt,
-				statusPath: state.statusPath,
-				eventsPath: state.eventsPath,
-				asyncDir,
-				runId: id,
-				stepIndex,
-			});
-			state.flatIndex += group.parallel.length;
-			return false;
-		}
-	}
-
-	try {
-		if (group.worktree) ensureParallelProgressFile(cwd, group);
-		const groupStartTime = Date.now();
-		markParallelGroupRunning({
-			statusPayload,
-			group,
-			groupStartFlatIndex,
-			groupStartTime,
-			statusPath: state.statusPath,
-			eventsPath: state.eventsPath,
-			asyncDir,
-			runId: id,
-			stepIndex,
-		});
-		const parallelResults = await mapConcurrent(group.parallel, concurrency, async (task, taskIdx) => {
-			const fi = groupStartFlatIndex + taskIdx;
-			if (aborted && failFast) {
-				const skippedAt = Date.now();
-				statusPayload.steps[fi].status = "failed";
-				statusPayload.steps[fi].error = "Skipped due to fail-fast";
-				statusPayload.steps[fi].startedAt = skippedAt;
-				statusPayload.steps[fi].endedAt = skippedAt;
-				statusPayload.steps[fi].durationMs = 0;
-				statusPayload.steps[fi].exitCode = -1;
-				statusPayload.steps[fi].activityState = undefined;
-				statusPayload.lastUpdate = skippedAt;
-				writeStatusPayload(state);
-				appendJsonl(
-					state.eventsPath,
-					JSON.stringify({
-						type: "subagent.step.failed",
-						ts: skippedAt,
-						runId: id,
-						stepIndex: fi,
-						agent: task.agent,
-						exitCode: -1,
-						durationMs: 0,
-					}),
-				);
-				return { agent: task.agent, output: "(skipped — fail-fast)", exitCode: -1 as number | null, skipped: true };
-			}
-
-			const taskStartTime = Date.now();
-			statusPayload.currentStep = fi;
-			statusPayload.steps[fi].status = "running";
-			statusPayload.steps[fi].error = undefined;
-			statusPayload.steps[fi].activityState = undefined;
-			resetStepLiveDetail(statusPayload.steps[fi]);
-			statusPayload.steps[fi].startedAt = taskStartTime;
-			statusPayload.steps[fi].endedAt = undefined;
-			statusPayload.steps[fi].durationMs = undefined;
-			statusPayload.steps[fi].lastActivityAt = taskStartTime;
-			statusPayload.outputFile = path.join(asyncDir, `output-${fi}.log`);
-			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,
-				}),
-			);
-
-			const taskSessionDir = config.sessionDir ? path.join(config.sessionDir, `parallel-${taskIdx}`) : undefined;
-			const { taskForRun, taskCwd } = prepareParallelTaskRun(task, cwd, worktreeSetup, taskIdx);
-			const singleResult = await runSingleStep(taskForRun, {
-				previousOutput: state.previousOutput,
-				placeholder,
-				cwd: taskCwd,
-				sessionEnabled,
-				outputs,
-				sessionDir: taskSessionDir,
-				artifactsDir,
-				artifactConfig,
-				id,
-				flatIndex: fi,
-				flatStepCount: flatSteps.length,
-				outputFile: path.join(asyncDir, `output-${fi}.log`),
-				piPackageRoot: config.piPackageRoot,
-				piArgv1: config.piArgv1,
-				childIntercomTarget: config.childIntercomTargets?.[fi],
-				orchestratorIntercomTarget: config.controlIntercomTarget,
-				supervisorAuthorization: config.supervisorAuthorizations?.[fi],
-				nestedRoute: config.nestedRoute,
-				registerInterrupt: (interrupt) => {
-					state.activeChildInterrupt = interrupt;
-				},
-				onAttemptStart: (attempt) => updateStepModel(state, fi, attempt.model, attempt.thinking, attempt.fastMode),
-				onChildEvent: (event) => updateStepFromChildEvent(state, fi, event),
-				workflowStageSubagentGuard: config.workflowStageSubagentGuard,
-			});
-			if (task.sessionFile) state.latestSessionFile = task.sessionFile;
-
-			const taskEndTime = Date.now();
-			const taskDuration = taskEndTime - taskStartTime;
-			statusPayload.steps[fi].status = singleResult.exitCode === 0 ? "complete" : "failed";
-			statusPayload.steps[fi].endedAt = taskEndTime;
-			statusPayload.steps[fi].durationMs = taskDuration;
-			statusPayload.steps[fi].exitCode = singleResult.exitCode;
-			statusPayload.steps[fi].model = singleResult.model;
-			statusPayload.steps[fi].thinking = resolveEffectiveThinking(
-				singleResult.model,
-				statusPayload.steps[fi].thinking,
-			);
-			statusPayload.steps[fi].fastMode = singleResult.fastMode ? true : undefined;
-			statusPayload.steps[fi].attemptedModels = singleResult.attemptedModels;
-			statusPayload.steps[fi].modelAttempts = singleResult.modelAttempts;
-			statusPayload.steps[fi].error = singleResult.error;
-			statusPayload.steps[fi].structuredOutput = singleResult.structuredOutput;
-			statusPayload.steps[fi].structuredOutputPath = singleResult.structuredOutputPath;
-			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: taskDuration,
-				}),
-			);
-			if (singleResult.exitCode !== 0 && failFast) aborted = true;
-			return { ...singleResult, skipped: false };
-		});
-
-		state.flatIndex += group.parallel.length;
-		for (let t = 0; t < group.parallel.length; t++) {
-			const fi = groupStartFlatIndex + t;
-			const sessionTokens = config.sessionDir
-				? parseSessionTokens(path.join(config.sessionDir, `parallel-${t}`))
-				: null;
-			const taskTokens = sessionTokens ?? tokenUsageFromAttempts(parallelResults[t]?.modelAttempts);
-			if (!taskTokens) continue;
-			statusPayload.steps[fi].tokens = taskTokens;
-			state.previousCumulativeTokens = {
-				input: state.previousCumulativeTokens.input + taskTokens.input,
-				output: state.previousCumulativeTokens.output + taskTokens.output,
-				total: state.previousCumulativeTokens.total + taskTokens.total,
-			};
-		}
-		statusPayload.totalTokens = { ...state.previousCumulativeTokens };
-		statusPayload.lastUpdate = Date.now();
-		writeStatusPayload(state);
-
-		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,
-				fastMode: pr.fastMode,
-				attemptedModels: pr.attemptedModels,
-				modelAttempts: pr.modelAttempts,
-				artifactPaths: pr.artifactPaths,
-				structuredOutput: pr.structuredOutput,
-				structuredOutputPath: pr.structuredOutputPath,
-				structuredOutputSchemaPath: pr.structuredOutputSchemaPath,
-			});
-		}
-		for (let t = 0; t < group.parallel.length; t++) {
-			const outputName = group.parallel[t]?.outputName;
-			if (outputName)
-				outputs[outputName] = outputEntryFromAsyncResult(
-					{
-						agent: parallelResults[t]!.agent,
-						output: parallelResults[t]!.output,
-						structuredOutput: parallelResults[t]!.structuredOutput,
-					},
-					stepIndex,
-				);
-		}
-		statusPayload.outputs = outputs;
-
-		state.previousOutput = aggregateParallelOutputs(
-			parallelResults.map((r) => ({
-				agent: r.agent,
-				output: r.output,
-				exitCode: r.exitCode,
-				error: r.error,
-				model: r.model,
-				fastMode: r.fastMode,
-				attemptedModels: r.attemptedModels,
-			})),
-		);
-		state.previousOutput = appendParallelWorktreeSummary(
-			state.previousOutput,
-			worktreeSetup,
-			asyncDir,
-			stepIndex,
-			group,
-		);
-		appendJsonl(
-			state.eventsPath,
-			JSON.stringify({
-				type: "subagent.parallel.completed",
-				ts: Date.now(),
-				runId: id,
-				stepIndex,
-				success: parallelResults.every((r) => r.exitCode === 0 || r.exitCode === -1),
-			}),
-		);
-		return !parallelResults.some((r) => r.exitCode !== 0 && r.exitCode !== -1);
-	} finally {
-		if (worktreeSetup) cleanupWorktrees(worktreeSetup);
-	}
-}

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

@@ -1,173 +0,0 @@
-import * as path from "node:path";
-import { appendJsonl } from "../../shared/artifacts.ts";
-import { resolveEffectiveThinking } from "../../shared/model-info.ts";
-import { parseSessionTokens } from "../../shared/session-tokens.ts";
-import {
-	resetStepLiveDetail,
-	updateStepFromChildEvent,
-	updateStepModel,
-	writeStatusPayload,
-} from "./subagent-runner-state.ts";
-import { outputEntryFromAsyncResult, runSingleStep } from "./subagent-runner-step.ts";
-import type { RunnerExecutionState, SubagentStep } from "./subagent-runner-types.ts";
-import { tokenUsageFromAttempts } from "./subagent-runner-utils.ts";
-
-export async function runSequentialStep(
-	state: RunnerExecutionState,
-	seqStep: SubagentStep,
-	stepIndex: number,
-): Promise<boolean> {
-	const {
-		statusPayload,
-		asyncDir,
-		id,
-		cwd,
-		placeholder,
-		sessionEnabled,
-		outputs,
-		config,
-		artifactsDir,
-		artifactConfig,
-		flatSteps,
-	} = state;
-	const flatIndex = state.flatIndex;
-	const stepStartTime = Date.now();
-	statusPayload.currentStep = flatIndex;
-	statusPayload.steps[flatIndex].status = "running";
-	statusPayload.steps[flatIndex].activityState = undefined;
-	statusPayload.activityState = undefined;
-	resetStepLiveDetail(statusPayload.steps[flatIndex]);
-	statusPayload.steps[flatIndex].skills = seqStep.skills;
-	statusPayload.steps[flatIndex].startedAt = stepStartTime;
-	statusPayload.steps[flatIndex].lastActivityAt = stepStartTime;
-	statusPayload.lastActivityAt = stepStartTime;
-	statusPayload.lastUpdate = stepStartTime;
-	statusPayload.outputFile = path.join(asyncDir, `output-${flatIndex}.log`);
-	writeStatusPayload(state);
-
-	appendJsonl(
-		state.eventsPath,
-		JSON.stringify({
-			type: "subagent.step.started",
-			ts: stepStartTime,
-			runId: id,
-			stepIndex: flatIndex,
-			agent: seqStep.agent,
-		}),
-	);
-
-	const singleResult = await runSingleStep(seqStep, {
-		previousOutput: state.previousOutput,
-		placeholder,
-		cwd,
-		sessionEnabled,
-		outputs,
-		sessionDir: config.sessionDir,
-		artifactsDir,
-		artifactConfig,
-		id,
-		flatIndex,
-		flatStepCount: flatSteps.length,
-		outputFile: path.join(asyncDir, `output-${flatIndex}.log`),
-		piPackageRoot: config.piPackageRoot,
-		piArgv1: config.piArgv1,
-		childIntercomTarget: config.childIntercomTargets?.[flatIndex],
-		orchestratorIntercomTarget: config.controlIntercomTarget,
-		supervisorAuthorization: config.supervisorAuthorizations?.[flatIndex],
-		nestedRoute: config.nestedRoute,
-		registerInterrupt: (interrupt) => {
-			state.activeChildInterrupt = interrupt;
-		},
-		onAttemptStart: (attempt) => updateStepModel(state, flatIndex, attempt.model, attempt.thinking, attempt.fastMode),
-		onChildEvent: (event) => updateStepFromChildEvent(state, flatIndex, event),
-		workflowStageSubagentGuard: config.workflowStageSubagentGuard,
-	});
-	if (seqStep.sessionFile) state.latestSessionFile = seqStep.sessionFile;
-
-	state.previousOutput = singleResult.output;
-	state.results.push({
-		agent: singleResult.agent,
-		output: singleResult.output,
-		error: singleResult.error,
-		success: singleResult.exitCode === 0,
-		exitCode: singleResult.exitCode,
-		sessionFile: singleResult.sessionFile,
-		intercomTarget: singleResult.intercomTarget,
-		model: singleResult.model,
-		fastMode: singleResult.fastMode,
-		attemptedModels: singleResult.attemptedModels,
-		modelAttempts: singleResult.modelAttempts,
-		artifactPaths: singleResult.artifactPaths,
-		structuredOutput: singleResult.structuredOutput,
-		structuredOutputPath: singleResult.structuredOutputPath,
-		structuredOutputSchemaPath: singleResult.structuredOutputSchemaPath,
-	});
-	if (seqStep.outputName) {
-		outputs[seqStep.outputName] = outputEntryFromAsyncResult(
-			{ agent: singleResult.agent, output: singleResult.output, structuredOutput: singleResult.structuredOutput },
-			stepIndex,
-		);
-	}
-	statusPayload.outputs = outputs;
-
-	const cumulativeTokens = config.sessionDir ? parseSessionTokens(config.sessionDir) : null;
-	let stepTokens = cumulativeTokens
-		? {
-				input: cumulativeTokens.input - state.previousCumulativeTokens.input,
-				output: cumulativeTokens.output - state.previousCumulativeTokens.output,
-				total: cumulativeTokens.total - state.previousCumulativeTokens.total,
-			}
-		: null;
-	if (cumulativeTokens) {
-		state.previousCumulativeTokens = cumulativeTokens;
-	} else {
-		stepTokens = tokenUsageFromAttempts(singleResult.modelAttempts);
-		if (stepTokens) {
-			state.previousCumulativeTokens = {
-				input: state.previousCumulativeTokens.input + stepTokens.input,
-				output: state.previousCumulativeTokens.output + stepTokens.output,
-				total: state.previousCumulativeTokens.total + stepTokens.total,
-			};
-		}
-	}
-
-	const stepEndTime = Date.now();
-	statusPayload.steps[flatIndex].status = singleResult.exitCode === 0 ? "complete" : "failed";
-	statusPayload.steps[flatIndex].endedAt = stepEndTime;
-	statusPayload.steps[flatIndex].durationMs = stepEndTime - stepStartTime;
-	statusPayload.steps[flatIndex].exitCode = singleResult.exitCode;
-	statusPayload.steps[flatIndex].model = singleResult.model;
-	statusPayload.steps[flatIndex].thinking = resolveEffectiveThinking(
-		singleResult.model,
-		statusPayload.steps[flatIndex].thinking,
-	);
-	statusPayload.steps[flatIndex].fastMode = singleResult.fastMode ? true : undefined;
-	statusPayload.steps[flatIndex].attemptedModels = singleResult.attemptedModels;
-	statusPayload.steps[flatIndex].modelAttempts = singleResult.modelAttempts;
-	statusPayload.steps[flatIndex].error = singleResult.error;
-	statusPayload.steps[flatIndex].structuredOutput = singleResult.structuredOutput;
-	statusPayload.steps[flatIndex].structuredOutputPath = singleResult.structuredOutputPath;
-	statusPayload.steps[flatIndex].structuredOutputSchemaPath = singleResult.structuredOutputSchemaPath;
-	if (stepTokens) {
-		statusPayload.steps[flatIndex].tokens = stepTokens;
-		statusPayload.totalTokens = { ...state.previousCumulativeTokens };
-	}
-	statusPayload.lastUpdate = stepEndTime;
-	writeStatusPayload(state);
-
-	appendJsonl(
-		state.eventsPath,
-		JSON.stringify({
-			type: singleResult.exitCode === 0 ? "subagent.step.completed" : "subagent.step.failed",
-			ts: stepEndTime,
-			runId: id,
-			stepIndex: flatIndex,
-			agent: seqStep.agent,
-			exitCode: singleResult.exitCode,
-			durationMs: stepEndTime - stepStartTime,
-			tokens: stepTokens,
-		}),
-	);
-	state.flatIndex++;
-	return singleResult.exitCode === 0;
-}