@bastani/atomic 0.8.31-alpha.4 → 0.9.0-alpha.1

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

@@ -0,0 +1,215 @@
+import * as path from "node:path";
+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 { runSingleStep } from "./subagent-runner-step.ts";
+import type { RunnerExecutionState, RunnerStatusStep, RunnerStep, SubagentStep } from "./subagent-runner-types.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;
+	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);
+	} catch (error) {
+		const now = Date.now();
+		const message = error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
+		statusPayload.state = "failed";
+		statusPayload.error = message;
+		statusPayload.currentStep = state.flatIndex;
+		const placeholderStep = statusPayload.steps[groupStartFlatIndex];
+		if (placeholderStep) {
+			placeholderStep.status = "failed";
+			placeholderStep.error = message;
+			placeholderStep.startedAt = now;
+			placeholderStep.endedAt = now;
+			placeholderStep.durationMs = 0;
+			placeholderStep.exitCode = 1;
+		}
+		statusPayload.lastUpdate = now;
+		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 });
+		return false;
+	}
+
+	const dynamicStep = step as Parameters<typeof materializeDynamicParallelStep>[0];
+	const parallelTemplate = dynamicStep.parallel as unknown as SubagentStep;
+	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 };
+		statusPayload.outputs = outputs;
+		const placeholderStep = statusPayload.steps[groupStartFlatIndex];
+		if (placeholderStep) {
+			placeholderStep.status = "complete";
+			placeholderStep.startedAt = now;
+			placeholderStep.endedAt = now;
+			placeholderStep.durationMs = 0;
+		}
+		state.previousOutput = "Dynamic fanout produced 0 results.";
+		state.flatIndex++;
+		statusPayload.lastUpdate = now;
+		markDynamicGraphGroup(state, stepIndex, "completed");
+		writeStatusPayload(state);
+		return true;
+	}
+
+	const dynamicSteps: SubagentStep[] = materialized.parallel.map((task) => ({
+		...parallelTemplate,
+		task: task.task ?? parallelTemplate.task,
+		label: task.label ?? parallelTemplate.label,
+		structuredOutput: undefined,
+		structuredOutputSchema: parallelTemplate.structuredOutputSchema ?? parallelTemplate.structuredOutput?.schema,
+	}));
+	const dynamicStatusSteps: RunnerStatusStep[] = dynamicSteps.map((task) => ({
+		agent: task.agent,
+		phase: task.phase ?? dynamicStep.phase,
+		label: task.label,
+		outputName: undefined,
+		structured: Boolean(task.structuredOutputSchema),
+		status: "pending",
+		...(task.sessionFile ? { sessionFile: task.sessionFile } : {}),
+		skills: task.skills,
+		model: task.model,
+		thinking: task.thinking,
+		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));
+	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) {
+		if (group.stepIndex === stepIndex) {
+			group.start = groupStartFlatIndex;
+			group.count = dynamicStatusSteps.length;
+		} else if (group.start > groupStartFlatIndex) {
+			group.start += materializedDelta;
+		}
+	}
+	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.children) shiftFlatIndexes(node.children);
+			}
+		};
+		shiftFlatIndexes(statusPayload.workflowGraph.nodes);
+		const groupNode = statusPayload.workflowGraph.nodes.find((node) => node.id === `step-${stepIndex}`);
+		if (groupNode) {
+			groupNode.children = materialized.items.map((item, itemIndex) => ({
+				id: `step-${stepIndex}-item-${item.idKey}`,
+				kind: "agent",
+				agent: parallelTemplate.agent,
+				phase: dynamicSteps[itemIndex]?.phase ?? dynamicStep.phase,
+				label: dynamicSteps[itemIndex]?.label?.trim() || `${parallelTemplate.agent} ${item.key}`,
+				status: "pending",
+				flatIndex: groupStartFlatIndex + itemIndex,
+				stepIndex,
+				itemKey: item.key,
+				structured: Boolean(dynamicSteps[itemIndex]?.structuredOutputSchema),
+			}));
+		}
+	}
+	writeStatusPayload(state);
+
+	const concurrency = dynamicStep.concurrency ?? MAX_PARALLEL_CONCURRENCY;
+	const failFast = dynamicStep.failFast ?? false;
+	let aborted = false;
+	const parallelResults = await mapConcurrent(dynamicSteps, 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.lastUpdate = skippedAt;
+			writeStatusPayload(state);
+			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].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 singleResult = await runSingleStep(task, {
+			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),
+			outputFile: path.join(asyncDir, `output-${fi}.log`),
+			piPackageRoot: config.piPackageRoot,
+			piArgv1: config.piArgv1,
+			childIntercomTarget: config.childIntercomTargets?.[fi],
+			orchestratorIntercomTarget: config.controlIntercomTarget,
+			nestedRoute: config.nestedRoute,
+			registerInterrupt: (interrupt) => {
+				state.activeChildInterrupt = interrupt;
+			},
+			onAttemptStart: (attempt) => updateStepModel(state, fi, attempt.model, attempt.thinking),
+			onChildEvent: (event) => updateStepFromChildEvent(state, fi, event),
+		});
+		const taskEndTime = Date.now();
+		statusPayload.steps[fi].status = singleResult.exitCode === 0 ? "complete" : "failed";
+		statusPayload.steps[fi].endedAt = taskEndTime;
+		statusPayload.steps[fi].durationMs = taskEndTime - taskStartTime;
+		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].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: 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]);
+	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 };
+			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 });
+			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.");
+	statusPayload.lastUpdate = Date.now();
+	writeStatusPayload(state);
+	return !(failures.length > 0 || statusPayload.error);
+}

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

@@ -0,0 +1,136 @@
+import * as path from "node:path";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { appendJsonl } from "../../shared/artifacts.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";
+
+export async function finalizeRun(state: RunnerExecutionState): Promise<void> {
+	const { config, results, maxOutput, flatSteps, statusPayload, artifactsDir, cwd, asyncDir, id } = state;
+	let summary = results.map((r) => `${r.agent}:\n${r.output}`).join("\n\n");
+	let truncated = false;
+
+	if (maxOutput) {
+		const config = { ...DEFAULT_MAX_OUTPUT, ...maxOutput };
+		const lastArtifactPath = results[results.length - 1]?.artifactPaths?.outputPath;
+		const truncResult = truncateOutput(summary, config, lastArtifactPath);
+		if (truncResult.truncated) {
+			summary = truncResult.text;
+			truncated = true;
+		}
+	}
+
+	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("->")}`;
+	let sessionFile: string | undefined;
+	let shareUrl: string | undefined;
+	let gistUrl: string | undefined;
+	let shareError: string | undefined;
+
+	if (state.shareEnabled) {
+		sessionFile = config.sessionDir ? (findLatestSessionFile(config.sessionDir) ?? undefined) : undefined;
+		if (!sessionFile && state.latestSessionFile) sessionFile = state.latestSessionFile;
+		if (sessionFile) {
+			try {
+				const exportDir = config.sessionDir ?? path.dirname(sessionFile);
+				const htmlPath = await exportSessionHtml(sessionFile, exportDir, config.piPackageRoot);
+				const share = createShareLink(htmlPath);
+				if ("error" in share) shareError = share.error;
+				else {
+					shareUrl = share.shareUrl;
+					gistUrl = share.gistUrl;
+				}
+			} catch (err) {
+				shareError = String(err);
+			}
+		} else {
+			shareError = "Session file not found.";
+		}
+	}
+
+	cleanupActivityTimer(state);
+	const effectiveSessionFile = sessionFile ?? state.latestSessionFile;
+	const runEndedAt = Date.now();
+	statusPayload.state = state.interrupted ? "paused" : results.every((r) => r.success) ? "complete" : "failed";
+	statusPayload.activityState = undefined;
+	statusPayload.endedAt = runEndedAt;
+	statusPayload.lastUpdate = runEndedAt;
+	statusPayload.sessionFile = effectiveSessionFile;
+	statusPayload.shareUrl = shareUrl;
+	statusPayload.gistUrl = gistUrl;
+	statusPayload.shareError = shareError;
+	if (statusPayload.state === "failed" && !statusPayload.error) {
+		const failedStep = statusPayload.steps.find((s) => s.status === "failed");
+		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 }));
+	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 })),
+		summary,
+		truncated,
+		artifactsDir,
+		sessionFile: effectiveSessionFile,
+		shareUrl,
+		shareError,
+	});
+
+	try {
+		writeAtomicJson(state.resultPath, {
+			id,
+			agent: agentName,
+			mode: resultMode,
+			success: !state.interrupted && results.every((r) => r.success),
+			state: state.interrupted ? "paused" : results.every((r) => r.success) ? "complete" : "failed",
+			summary: state.interrupted ? "Paused after interrupt. Waiting for explicit next action." : summary,
+			results: results.map((r) => ({
+				agent: r.agent,
+				output: r.output,
+				error: r.error,
+				success: r.success,
+				skipped: r.skipped || undefined,
+				sessionFile: r.sessionFile,
+				intercomTarget: r.intercomTarget,
+				model: r.model,
+				fastMode: r.fastMode,
+				attemptedModels: r.attemptedModels,
+				modelAttempts: r.modelAttempts,
+				artifactPaths: r.artifactPaths,
+				truncated: r.truncated,
+				structuredOutput: r.structuredOutput,
+				structuredOutputPath: r.structuredOutputPath,
+				structuredOutputSchemaPath: r.structuredOutputSchemaPath,
+			})),
+			outputs: state.outputs,
+			workflowGraph: statusPayload.workflowGraph,
+			exitCode: state.interrupted || results.every((r) => r.success) ? 0 : 1,
+			timestamp: runEndedAt,
+			durationMs: runEndedAt - state.overallStartTime,
+			truncated,
+			artifactsDir,
+			cwd,
+			asyncDir,
+			sessionId: config.sessionId,
+			sessionFile: effectiveSessionFile,
+			intercomTarget: config.controlIntercomTarget,
+			shareUrl,
+			gistUrl,
+			shareError,
+			...(state.taskIndex !== undefined && { taskIndex: state.taskIndex }),
+			...(state.totalTasks !== undefined && { totalTasks: state.totalTasks }),
+		});
+	} catch (err) {
+		console.error(`Failed to write result file ${state.resultPath}:`, err);
+	}
+}

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

@@ -0,0 +1,105 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+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();
+	if (root) return root;
+	throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
+}
+
+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;
+	const mod = await import(moduleUrl);
+	const exportFromFile = (mod as { exportFromFile?: (inputPath: string, options?: { outputPath?: string }) => string })
+		.exportFromFile;
+	if (typeof exportFromFile !== "function") {
+		throw new Error("exportFromFile not available");
+	}
+	const outputPath = path.join(outputDir, `${path.basename(sessionFile, ".jsonl")}.html`);
+	return exportFromFile(sessionFile, { outputPath });
+}
+
+export function createShareLink(htmlPath: string): { shareUrl: string; gistUrl: string } | { error: string } {
+	try {
+		const auth = spawnSync("gh", ["auth", "status"], { encoding: "utf-8" });
+		if (auth.status !== 0) {
+			return { error: "GitHub CLI is not logged in. Run 'gh auth login' first." };
+		}
+	} catch {
+		return { error: "GitHub CLI (gh) is not installed." };
+	}
+
+	try {
+		const result = spawnSync("gh", ["gist", "create", htmlPath], { encoding: "utf-8" });
+		if (result.status !== 0) {
+			const err = (result.stderr || "").trim() || "Failed to create gist.";
+			return { error: err };
+		}
+		const gistUrl = (result.stdout || "").trim();
+		const gistId = gistUrl.split("/").pop();
+		if (!gistId) return { error: "Failed to parse gist ID." };
+		const shareUrl = `https://shittycodingagent.ai/session/?${gistId}`;
+		return { shareUrl, gistUrl };
+	} catch (err) {
+		return { error: String(err) };
+	}
+}
+
+export function writeRunLog(
+	logPath: string,
+	input: {
+		id: string;
+		mode: SubagentRunMode;
+		cwd: string;
+		startedAt: number;
+		endedAt: number;
+		steps: Array<{
+			agent: string;
+			status: string;
+			durationMs?: number;
+		}>;
+		summary: string;
+		truncated: boolean;
+		artifactsDir?: string;
+		sessionFile?: string;
+		shareUrl?: string;
+		shareError?: string;
+	},
+): void {
+	const lines: string[] = [];
+	lines.push(`# Subagent run ${input.id}`);
+	lines.push("");
+	lines.push(`- **Mode:** ${input.mode}`);
+	lines.push(`- **CWD:** ${input.cwd}`);
+	lines.push(`- **Started:** ${new Date(input.startedAt).toISOString()}`);
+	lines.push(`- **Ended:** ${new Date(input.endedAt).toISOString()}`);
+	lines.push(`- **Duration:** ${formatDuration(input.endedAt - input.startedAt)}`);
+	if (input.sessionFile) lines.push(`- **Session:** ${input.sessionFile}`);
+	if (input.shareUrl) lines.push(`- **Share:** ${input.shareUrl}`);
+	if (input.shareError) lines.push(`- **Share error:** ${input.shareError}`);
+	if (input.artifactsDir) lines.push(`- **Artifacts:** ${input.artifactsDir}`);
+	lines.push("");
+	lines.push("## Steps");
+	lines.push("| Step | Agent | Status | Duration |");
+	lines.push("| --- | --- | --- | --- |");
+	input.steps.forEach((step, i) => {
+		const duration = step.durationMs !== undefined ? formatDuration(step.durationMs) : "-";
+		lines.push(`| ${i + 1} | ${step.agent} | ${step.status} | ${duration} |`);
+	});
+	lines.push("");
+	lines.push("## Summary");
+	if (input.truncated) {
+		lines.push("_Output truncated_");
+		lines.push("");
+	}
+	lines.push(input.summary.trim() || "(no output)");
+	lines.push("");
+	fs.writeFileSync(logPath, lines.join("\n"), "utf-8");
+}

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

@@ -0,0 +1,112 @@
+import * as path from "node:path";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { appendJsonl } from "../../shared/artifacts.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);
+}