@bastani/atomic 0.9.11-alpha.8 → 0.9.11

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

@@ -1,11 +1,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { appendJsonl } from "../../shared/artifacts.ts";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import type { TokenUsage } from "../../shared/types.ts";
 import { extractTextFromContent, extractToolArgsPreview } from "../../shared/utils.ts";
-import { DEFAULT_CONTROL_CONFIG, buildControlEvent, claimControlNotification, deriveActivityState, formatControlIntercomMessage, formatControlNoticeMessage } from "../shared/subagent-control.ts";
-import { flattenSteps, isDynamicRunnerGroup, isParallelGroup } from "../shared/parallel-utils.ts";
-import { nestedSummaryFromAsyncStatus, writeNestedEvent } from "../shared/nested-events.ts";
 import {
 	createMutatingFailureState,
 	didMutatingToolFail,
@@ -17,13 +15,40 @@ import {
 	shouldEscalateMutatingFailures,
 	summarizeRecentMutatingFailures,
 } from "../shared/long-running-guard.ts";
-import type { TokenUsage } from "../../shared/types.ts";
-import type { ChildEvent, RunnerExecutionState, RunnerStatusPayload, RunnerStatusStep, SubagentRunConfig } from "./subagent-runner-types.ts";
+import { nestedSummaryFromAsyncStatus, writeNestedEvent } from "../shared/nested-events.ts";
+import { flattenSteps, isDynamicRunnerGroup, isParallelGroup } from "../shared/parallel-utils.ts";
+import {
+	buildControlEvent,
+	claimControlNotification,
+	DEFAULT_CONTROL_CONFIG,
+	deriveActivityState,
+	formatControlIntercomMessage,
+	formatControlNoticeMessage,
+} from "../shared/subagent-control.ts";
+import type {
+	ChildEvent,
+	RunnerExecutionState,
+	RunnerStatusPayload,
+	RunnerStatusStep,
+	SubagentRunConfig,
+} from "./subagent-runner-types.ts";
 import { appendRecentStepOutput, resetStepLiveDetail } from "./subagent-runner-utils.ts";
 
 const mutatingFailureWindowMs = 5 * 60_000;
 
-function initialStepStatus(step: { agent: string; phase?: string; label?: string; outputName?: string; structured?: boolean; sessionFile?: string; skills?: string[] | false; model?: string; thinking?: string; fastMode?: boolean; modelCandidates?: string[] }): RunnerStatusStep {
+function initialStepStatus(step: {
+	agent: string;
+	phase?: string;
+	label?: string;
+	outputName?: string;
+	structured?: boolean;
+	sessionFile?: string;
+	skills?: string[] | false;
+	model?: string;
+	thinking?: string;
+	fastMode?: boolean;
+	modelCandidates?: string[];
+}): RunnerStatusStep {
 	return {
 		agent: step.agent,
 		phase: step.phase,
@@ -36,14 +61,20 @@ function initialStepStatus(step: { agent: string; phase?: string; label?: string
 		model: step.model,
 		thinking: step.thinking,
 		...(step.fastMode ? { fastMode: true } : {}),
-		attemptedModels: step.modelCandidates && step.modelCandidates.length > 0 ? step.modelCandidates : step.model ? [step.model] : undefined,
+		attemptedModels:
+			step.modelCandidates && step.modelCandidates.length > 0
+				? step.modelCandidates
+				: step.model
+					? [step.model]
+					: undefined,
 		recentTools: [],
 		recentOutput: [],
 	};
 }
 
 export function createRunnerExecutionState(config: SubagentRunConfig): RunnerExecutionState {
-	const { id, steps, resultPath, cwd, placeholder, taskIndex, totalTasks, maxOutput, artifactsDir, artifactConfig } = config;
+	const { id, steps, resultPath, cwd, placeholder, taskIndex, totalTasks, maxOutput, artifactsDir, artifactConfig } =
+		config;
 	const overallStartTime = Date.now();
 	const shareEnabled = config.share === true;
 	const asyncDir = config.asyncDir;
@@ -79,9 +110,8 @@ export function createRunnerExecutionState(config: SubagentRunConfig): RunnerExe
 		}
 	}
 	const flatSteps = flattenSteps(steps);
-	const sessionEnabled = Boolean(config.sessionDir)
-		|| shareEnabled
-		|| flatSteps.some((step) => Boolean(step.sessionFile));
+	const sessionEnabled =
+		Boolean(config.sessionDir) || shareEnabled || flatSteps.some((step) => Boolean(step.sessionFile));
 	const statusPayload: RunnerStatusPayload = {
 		runId: id,
 		...(config.sessionId ? { sessionId: config.sessionId } : {}),
@@ -139,7 +169,10 @@ export function createRunnerExecutionState(config: SubagentRunConfig): RunnerExe
 	return state;
 }
 
-function emitNestedSelfEvent(state: RunnerExecutionState, type: "subagent.nested.updated" | "subagent.nested.completed"): void {
+function emitNestedSelfEvent(
+	state: RunnerExecutionState,
+	type: "subagent.nested.updated" | "subagent.nested.completed",
+): void {
 	const { config, statusPayload, asyncDir, id } = state;
 	if (!config.nestedRoute || !config.nestedSelf) return;
 	try {
@@ -167,7 +200,9 @@ function refreshWorkflowGraph(state: RunnerExecutionState): void {
 	const { config, statusPayload } = state;
 	if (!config.workflowGraph) return;
 	const graph = structuredClone(statusPayload.workflowGraph ?? config.workflowGraph);
-	const normalize = (status: RunnerStatusStep["status"]): "pending" | "running" | "completed" | "failed" | "paused" | "detached" => {
+	const normalize = (
+		status: RunnerStatusStep["status"],
+	): "pending" | "running" | "completed" | "failed" | "paused" | "detached" => {
 		if (status === "complete" || status === "completed") return "completed";
 		if (status === "running" || status === "failed" || status === "paused" || status === "pending") return status;
 		return "pending";
@@ -197,10 +232,20 @@ function refreshWorkflowGraph(state: RunnerExecutionState): void {
 export function writeStatusPayload(state: RunnerExecutionState): void {
 	refreshWorkflowGraph(state);
 	writeAtomicJson(state.statusPath, state.statusPayload);
-	emitNestedSelfEvent(state, state.statusPayload.state === "running" || state.statusPayload.state === "queued" ? "subagent.nested.updated" : "subagent.nested.completed");
+	emitNestedSelfEvent(
+		state,
+		state.statusPayload.state === "running" || state.statusPayload.state === "queued"
+			? "subagent.nested.updated"
+			: "subagent.nested.completed",
+	);
 }
 
-export function markDynamicGraphGroup(state: RunnerExecutionState, stepIndex: number, status: "completed" | "failed" | "running", error?: string): void {
+export function markDynamicGraphGroup(
+	state: RunnerExecutionState,
+	stepIndex: number,
+	status: "completed" | "failed" | "running",
+	error?: string,
+): void {
 	const groupNode = state.statusPayload.workflowGraph?.nodes.find((node) => node.id === `step-${stepIndex}`);
 	if (!groupNode) return;
 	groupNode.status = status;
@@ -214,7 +259,8 @@ function stepOutputActivityAt(state: RunnerExecutionState, index: number): numbe
 	try {
 		lastActivityAt = Math.max(lastActivityAt, fs.statSync(outputPath).mtimeMs);
 	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT") console.error(`Failed to inspect async output file '${outputPath}':`, error);
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT")
+			console.error(`Failed to inspect async output file '${outputPath}':`, error);
 	}
 	return lastActivityAt;
 }
@@ -223,25 +269,40 @@ function appendControlEvent(state: RunnerExecutionState, event: ReturnType<typeo
 	const { controlConfig, config, statusPayload, eventsPath } = state;
 	if (!controlConfig.enabled) return;
 	const childIntercomTarget = config.childIntercomTargets?.[event.index ?? statusPayload.currentStep];
-	const channels = event.type === "active_long_running"
-		? controlConfig.notifyChannels.filter((channel) => channel !== "intercom")
-		: controlConfig.notifyChannels;
-	if (channels.length === 0 || !claimControlNotification(controlConfig, event, state.emittedControlEventKeys, childIntercomTarget)) return;
-	appendJsonl(eventsPath, JSON.stringify({
-		type: "subagent.control",
-		event,
-		channels,
-		childIntercomTarget,
-		noticeText: formatControlNoticeMessage(event, childIntercomTarget),
-		...(config.controlIntercomTarget && channels.includes("intercom") ? {
-			intercom: { to: config.controlIntercomTarget, message: formatControlIntercomMessage(event, childIntercomTarget) },
-		} : {}),
-	}));
+	const channels =
+		event.type === "active_long_running"
+			? controlConfig.notifyChannels.filter((channel) => channel !== "intercom")
+			: controlConfig.notifyChannels;
+	if (
+		channels.length === 0 ||
+		!claimControlNotification(controlConfig, event, state.emittedControlEventKeys, childIntercomTarget)
+	)
+		return;
+	appendJsonl(
+		eventsPath,
+		JSON.stringify({
+			type: "subagent.control",
+			event,
+			channels,
+			childIntercomTarget,
+			noticeText: formatControlNoticeMessage(event, childIntercomTarget),
+			...(config.controlIntercomTarget && channels.includes("intercom")
+				? {
+						intercom: {
+							to: config.controlIntercomTarget,
+							message: formatControlIntercomMessage(event, childIntercomTarget),
+						},
+					}
+				: {}),
+		}),
+	);
 }
 
 function syncTopLevelCurrentTool(statusPayload: RunnerStatusPayload): void {
 	const activeStep = statusPayload.steps
-		.filter((step) => step.status === "running" && typeof step.currentTool === "string" && step.currentTool.length > 0)
+		.filter(
+			(step) => step.status === "running" && typeof step.currentTool === "string" && step.currentTool.length > 0,
+		)
 		.sort((left, right) => (right.currentToolStartedAt ?? 0) - (left.currentToolStartedAt ?? 0))[0];
 	statusPayload.currentTool = activeStep?.currentTool;
 	statusPayload.currentToolStartedAt = activeStep?.currentToolStartedAt;
@@ -252,23 +313,51 @@ function maybeEmitActiveLongRunning(state: RunnerExecutionState, flatIndex: numb
 	const { controlConfig, statusPayload, id } = state;
 	if (!controlConfig.enabled || state.activeLongRunningSteps.has(flatIndex)) return false;
 	const step = statusPayload.steps[flatIndex];
-	if (!step || step.status !== "running" || step.activityState === "needs_attention") return false;
-	const reason = nextLongRunningTrigger(controlConfig, { startedAt: step.startedAt ?? state.overallStartTime, now, turns: step.turnCount ?? 0, tokens: step.tokens?.total ?? 0 });
+	if (step?.status !== "running" || step.activityState === "needs_attention") return false;
+	const reason = nextLongRunningTrigger(controlConfig, {
+		startedAt: step.startedAt ?? state.overallStartTime,
+		now,
+		turns: step.turnCount ?? 0,
+		tokens: step.tokens?.total ?? 0,
+	});
 	if (!reason) return false;
 	state.activeLongRunningSteps.add(flatIndex);
 	const previous = step.activityState;
 	step.activityState = "active_long_running";
-	statusPayload.activityState = statusPayload.activityState === "needs_attention" ? "needs_attention" : "active_long_running";
-	appendControlEvent(state, buildControlEvent({
-		type: "active_long_running", from: previous, to: "active_long_running", runId: id, agent: step.agent, index: flatIndex, ts: now,
-		message: `${step.agent} is still active but long-running`, reason, turns: step.turnCount, tokens: step.tokens?.total, toolCount: step.toolCount,
-		currentTool: step.currentTool, currentToolDurationMs: step.currentToolStartedAt ? Math.max(0, now - step.currentToolStartedAt) : undefined,
-		currentPath: step.currentPath, elapsedMs: now - (step.startedAt ?? state.overallStartTime),
-	}));
+	statusPayload.activityState =
+		statusPayload.activityState === "needs_attention" ? "needs_attention" : "active_long_running";
+	appendControlEvent(
+		state,
+		buildControlEvent({
+			type: "active_long_running",
+			from: previous,
+			to: "active_long_running",
+			runId: id,
+			agent: step.agent,
+			index: flatIndex,
+			ts: now,
+			message: `${step.agent} is still active but long-running`,
+			reason,
+			turns: step.turnCount,
+			tokens: step.tokens?.total,
+			toolCount: step.toolCount,
+			currentTool: step.currentTool,
+			currentToolDurationMs: step.currentToolStartedAt ? Math.max(0, now - step.currentToolStartedAt) : undefined,
+			currentPath: step.currentPath,
+			elapsedMs: now - (step.startedAt ?? state.overallStartTime),
+		}),
+	);
 	return true;
 }
 
-export function updateStepModel(state: RunnerExecutionState, flatIndex: number, model: string | undefined, thinking: string | undefined, fastMode?: boolean, now = Date.now()): void {
+export function updateStepModel(
+	state: RunnerExecutionState,
+	flatIndex: number,
+	model: string | undefined,
+	thinking: string | undefined,
+	fastMode?: boolean,
+	now = Date.now(),
+): void {
 	const step = state.statusPayload.steps[flatIndex];
 	if (!step) return;
 	step.model = model;
@@ -311,12 +400,50 @@ export function updateStepFromChildEvent(state: RunnerExecutionState, flatIndex:
 		appendRecentStepOutput(step, resultText.split("\n").slice(-10));
 		if (toolSnapshot?.mutates && didMutatingToolFail(resultText)) {
 			const failureState = state.mutatingFailureStates[flatIndex]!;
-			recordMutatingFailure(failureState, { tool: toolSnapshot.tool, path: toolSnapshot.path, error: resultText.split("\n").find((line) => line.trim())?.trim().slice(0, 180) ?? "mutating tool failed", ts: now }, mutatingFailureWindowMs);
-			if (state.controlConfig.enabled && shouldEscalateMutatingFailures(failureState, state.controlConfig.failedToolAttemptsBeforeAttention) && step.activityState !== "needs_attention") {
+			recordMutatingFailure(
+				failureState,
+				{
+					tool: toolSnapshot.tool,
+					path: toolSnapshot.path,
+					error:
+						resultText
+							.split("\n")
+							.find((line) => line.trim())
+							?.trim()
+							.slice(0, 180) ?? "mutating tool failed",
+					ts: now,
+				},
+				mutatingFailureWindowMs,
+			);
+			if (
+				state.controlConfig.enabled &&
+				shouldEscalateMutatingFailures(failureState, state.controlConfig.failedToolAttemptsBeforeAttention) &&
+				step.activityState !== "needs_attention"
+			) {
 				const previous = step.activityState;
 				step.activityState = "needs_attention";
 				state.statusPayload.activityState = "needs_attention";
-				appendControlEvent(state, buildControlEvent({ type: "needs_attention", from: previous, to: "needs_attention", runId: state.id, agent: step.agent, index: flatIndex, ts: now, message: `${step.agent} needs attention after repeated mutating tool failures`, reason: "tool_failures", turns: step.turnCount, tokens: step.tokens?.total, toolCount: step.toolCount, currentTool: toolSnapshot.tool, currentToolDurationMs: toolSnapshot.startedAt ? Math.max(0, now - toolSnapshot.startedAt) : undefined, currentPath: toolSnapshot.path, recentFailureSummary: summarizeRecentMutatingFailures(failureState) }));
+				appendControlEvent(
+					state,
+					buildControlEvent({
+						type: "needs_attention",
+						from: previous,
+						to: "needs_attention",
+						runId: state.id,
+						agent: step.agent,
+						index: flatIndex,
+						ts: now,
+						message: `${step.agent} needs attention after repeated mutating tool failures`,
+						reason: "tool_failures",
+						turns: step.turnCount,
+						tokens: step.tokens?.total,
+						toolCount: step.toolCount,
+						currentTool: toolSnapshot.tool,
+						currentToolDurationMs: toolSnapshot.startedAt ? Math.max(0, now - toolSnapshot.startedAt) : undefined,
+						currentPath: toolSnapshot.path,
+						recentFailureSummary: summarizeRecentMutatingFailures(failureState),
+					}),
+				);
 			}
 		} else if (toolSnapshot?.mutates) {
 			resetMutatingFailureState(state.mutatingFailureStates[flatIndex]!);
@@ -330,10 +457,18 @@ export function updateStepFromChildEvent(state: RunnerExecutionState, flatIndex:
 			const output = usage.output ?? usage.outputTokens ?? 0;
 			const previousInput = step.tokens?.input ?? 0;
 			const previousOutput = step.tokens?.output ?? 0;
-			step.tokens = { input: previousInput + input, output: previousOutput + output, total: previousInput + previousOutput + input + output };
+			step.tokens = {
+				input: previousInput + input,
+				output: previousOutput + output,
+				total: previousInput + previousOutput + input + output,
+			};
 			const totalInput = state.statusPayload.totalTokens?.input ?? 0;
 			const totalOutput = state.statusPayload.totalTokens?.output ?? 0;
-			state.statusPayload.totalTokens = { input: totalInput + input, output: totalOutput + output, total: totalInput + totalOutput + input + output };
+			state.statusPayload.totalTokens = {
+				input: totalInput + input,
+				output: totalOutput + output,
+				total: totalInput + totalOutput + input + output,
+			};
 		}
 		state.statusPayload.turnCount = Math.max(state.statusPayload.turnCount ?? 0, step.turnCount);
 	}
@@ -358,12 +493,28 @@ export function updateRunnerActivityState(state: RunnerExecutionState, now: numb
 			step.lastActivityAt = lastActivityAt;
 			changed = true;
 		}
-		const idleState = deriveActivityState({ config: state.controlConfig, startedAt: step.startedAt ?? state.overallStartTime, lastActivityAt, now });
+		const idleState = deriveActivityState({
+			config: state.controlConfig,
+			startedAt: step.startedAt ?? state.overallStartTime,
+			lastActivityAt,
+			now,
+		});
 		if (idleState === "needs_attention") {
 			const previous = step.activityState;
 			step.activityState = "needs_attention";
 			if (previous !== "needs_attention") {
-				appendControlEvent(state, buildControlEvent({ from: previous, to: "needs_attention", runId: state.id, agent: step.agent, index, ts: now, lastActivityAt }));
+				appendControlEvent(
+					state,
+					buildControlEvent({
+						from: previous,
+						to: "needs_attention",
+						runId: state.id,
+						agent: step.agent,
+						index,
+						ts: now,
+						lastActivityAt,
+					}),
+				);
 				changed = true;
 			}
 		} else if (maybeEmitActiveLongRunning(state, index, now)) changed = true;

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

@@ -1,24 +1,30 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getArtifactPaths } from "../../shared/artifacts.ts";
-import { detectSubagentError } from "../../shared/utils.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
-import { captureSingleOutputSnapshot, finalizeSingleOutput, formatSavedOutputReference, resolveSingleOutput, type SingleOutputSnapshot } from "../shared/single-output.ts";
-import { buildPiArgs, cleanupTempDir } from "../shared/pi-args.ts";
+import type { ArtifactPaths, ModelAttempt } from "../../shared/types.ts";
+import { detectSubagentError } from "../../shared/utils.ts";
 import { outputEntryFromAsyncResult, resolveOutputReferences } from "../shared/chain-outputs.ts";
+import { formatModelAttemptNote, isRetryableModelFailure } from "../shared/model-fallback.ts";
+import { buildPiArgs, cleanupTempDir } from "../shared/pi-args.ts";
+import {
+	captureSingleOutputSnapshot,
+	finalizeSingleOutput,
+	formatSavedOutputReference,
+	resolveSingleOutput,
+	type SingleOutputSnapshot,
+} from "../shared/single-output.ts";
 import {
-	STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS,
 	createStructuredOutputRuntime,
 	formatStructuredOutputCorrectionPrompt,
 	isStructuredOutputContractError,
 	latestStructuredOutputToolErrorFromMessages,
 	readStructuredOutput,
+	STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS,
 } from "../shared/structured-output.ts";
-import { formatModelAttemptNote, isRetryableModelFailure } from "../shared/model-fallback.ts";
-import type { ArtifactPaths, ModelAttempt } from "../../shared/types.ts";
+import { runPiStreaming } from "./subagent-runner-streaming.ts";
 import type { RunPiStreamingResult, SingleStepContext, SubagentStep } from "./subagent-runner-types.ts";
 import { emptyUsage, fastModeForStepAttempt } from "./subagent-runner-utils.ts";
-import { runPiStreaming } from "./subagent-runner-streaming.ts";
 
 export { outputEntryFromAsyncResult };
 
@@ -42,9 +48,14 @@ export async function runSingleStep(
 	structuredOutputPath?: string;
 	structuredOutputSchemaPath?: string;
 }> {
-	const effectiveStructuredOutput = step.structuredOutput ?? (step.structuredOutputSchema
-		? createStructuredOutputRuntime(step.structuredOutputSchema, path.join(path.dirname(ctx.outputFile), "structured-output"))
-		: undefined);
+	const effectiveStructuredOutput =
+		step.structuredOutput ??
+		(step.structuredOutputSchema
+			? createStructuredOutputRuntime(
+					step.structuredOutputSchema,
+					path.join(path.dirname(ctx.outputFile), "structured-output"),
+				)
+			: undefined);
 	const placeholderRegex = new RegExp(ctx.placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
 	let task = step.task.replace(placeholderRegex, () => ctx.previousOutput);
 	task = resolveOutputReferences(task, ctx.outputs ?? {});
@@ -71,11 +82,12 @@ export async function runSingleStep(
 	// and run one default-model attempt instead of silently exiting with no attempt.
 	// The filtered-to-empty case is surfaced as an error below.
 	const preSkippedAttempts = step.modelAttempts ?? [];
-	const candidates = step.modelCandidates !== undefined && (step.modelCandidates.length > 0 || preSkippedAttempts.length > 0)
-		? step.modelCandidates
-		: step.model
-			? [step.model]
-			: [undefined];
+	const candidates =
+		step.modelCandidates !== undefined && (step.modelCandidates.length > 0 || preSkippedAttempts.length > 0)
+			? step.modelCandidates
+			: step.model
+				? [step.model]
+				: [undefined];
 	const attemptedModels: string[] = [];
 	const modelAttempts: ModelAttempt[] = [...preSkippedAttempts];
 	const attemptNotes: string[] = modelAttempts
@@ -90,7 +102,11 @@ export async function runSingleStep(
 	for (let index = 0; index < candidates.length; index++) {
 		const candidate = candidates[index];
 		const attemptFastMode = fastModeForStepAttempt(step, candidate);
-		ctx.onAttemptStart?.({ model: candidate, thinking: resolveEffectiveThinking(candidate, step.thinking), fastMode: attemptFastMode ? true : undefined });
+		ctx.onAttemptStart?.({
+			model: candidate,
+			thinking: resolveEffectiveThinking(candidate, step.thinking),
+			fastMode: attemptFastMode ? true : undefined,
+		});
 		if (candidate) attemptedModels.push(candidate);
 		let nextTask = task;
 		let correctiveAttempts = 0;
@@ -100,7 +116,8 @@ export async function runSingleStep(
 			const outputSnapshot = captureSingleOutputSnapshot(step.outputPath);
 			if (effectiveStructuredOutput) {
 				try {
-					if (fs.existsSync(effectiveStructuredOutput.outputPath)) fs.unlinkSync(effectiveStructuredOutput.outputPath);
+					if (fs.existsSync(effectiveStructuredOutput.outputPath))
+						fs.unlinkSync(effectiveStructuredOutput.outputPath);
 				} catch {
 					// Missing/stale structured-output files are handled after the child exits.
 				}
@@ -160,17 +177,18 @@ export async function runSingleStep(
 				else structuredOutput = structured.value;
 			}
 			const structuredContractError = structuredError
-				? latestStructuredOutputToolErrorFromMessages(run.messages) ?? structuredError
+				? (latestStructuredOutputToolErrorFromMessages(run.messages) ?? structuredError)
 				: undefined;
 			const effectiveExitCode = structuredContractError
 				? 1
 				: hiddenError?.hasError
-				? (hiddenError.exitCode ?? 1)
-				: run.error && run.exitCode === 0
-					? 1
-					: run.exitCode;
-			const error = structuredContractError
-				?? (hiddenError?.hasError
+					? (hiddenError.exitCode ?? 1)
+					: run.error && run.exitCode === 0
+						? 1
+						: run.exitCode;
+			const error =
+				structuredContractError ??
+				(hiddenError?.hasError
 					? hiddenError.details
 						? `${hiddenError.errorType} failed (exit ${effectiveExitCode}): ${hiddenError.details}`
 						: `${hiddenError.errorType} failed with exit code ${effectiveExitCode}`
@@ -187,12 +205,18 @@ export async function runSingleStep(
 			modelAttempts.push(attempt);
 			finalFastMode = attemptFastMode;
 			finalOutputSnapshot = outputSnapshot;
-			finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error, structuredOutput } as RunPiStreamingResult & { structuredOutput?: unknown };
+			finalResult = {
+				...run,
+				exitCode: effectiveExitCode,
+				model: candidate ?? run.model,
+				error,
+				structuredOutput,
+			} as RunPiStreamingResult & { structuredOutput?: unknown };
 			if (attempt.success) break;
 			if (
-				effectiveStructuredOutput
-				&& isStructuredOutputContractError(structuredContractError)
-				&& correctiveAttempts < STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS
+				effectiveStructuredOutput &&
+				isStructuredOutputContractError(structuredContractError) &&
+				correctiveAttempts < STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS
 			) {
 				correctiveAttempts += 1;
 				nextTask = formatStructuredOutputCorrectionPrompt({
@@ -204,10 +228,10 @@ export async function runSingleStep(
 			}
 			const retrySignal = run.modelFailureSignal ?? error;
 			if (
-				structuredContractError === undefined
-				&& hiddenError?.hasError !== true
-				&& isRetryableModelFailure(retrySignal)
-				&& index < candidates.length - 1
+				structuredContractError === undefined &&
+				hiddenError?.hasError !== true &&
+				isRetryableModelFailure(retrySignal) &&
+				index < candidates.length - 1
 			) {
 				pendingAttemptNotes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
 				tryNextModel = true;
@@ -232,11 +256,14 @@ export async function runSingleStep(
 
 	const rawOutput = finalResult?.finalOutput ?? "";
 	const outputForPersistence = rawOutput;
-	const resolvedOutput = step.outputPath && finalResult?.exitCode === 0
-		? resolveSingleOutput(step.outputPath, outputForPersistence, finalOutputSnapshot)
-		: { fullOutput: outputForPersistence };
+	const resolvedOutput =
+		step.outputPath && finalResult?.exitCode === 0
+			? resolveSingleOutput(step.outputPath, outputForPersistence, finalOutputSnapshot)
+			: { fullOutput: outputForPersistence };
 	const output = resolvedOutput.fullOutput;
-	const outputReference = resolvedOutput.savedPath ? formatSavedOutputReference(resolvedOutput.savedPath, output) : undefined;
+	const outputReference = resolvedOutput.savedPath
+		? formatSavedOutputReference(resolvedOutput.savedPath, output)
+		: undefined;
 	let outputForSummary = output;
 	if (attemptNotes.length > 0) {
 		outputForSummary = `${attemptNotes.join("\n")}\n\n${outputForSummary}`.trim();
@@ -261,18 +288,22 @@ export async function runSingleStep(
 		if (ctx.artifactConfig?.includeMetadata !== false) {
 			fs.writeFileSync(
 				artifactPaths.metadataPath,
-				JSON.stringify({
-					runId: ctx.id,
-					agent: step.agent,
-					task,
-					exitCode: effectiveFinalExitCode,
-					model: finalResult?.model,
-					...(finalFastMode ? { fastMode: true } : {}),
-					attemptedModels: attemptedModels.length > 0 ? attemptedModels : undefined,
-					modelAttempts,
-					skills: step.skills,
-					timestamp: Date.now(),
-				}, null, 2),
+				JSON.stringify(
+					{
+						runId: ctx.id,
+						agent: step.agent,
+						task,
+						exitCode: effectiveFinalExitCode,
+						model: finalResult?.model,
+						...(finalFastMode ? { fastMode: true } : {}),
+						attemptedModels: attemptedModels.length > 0 ? attemptedModels : undefined,
+						modelAttempts,
+						skills: step.skills,
+						timestamp: Date.now(),
+					},
+					null,
+					2,
+				),
 				"utf-8",
 			);
 		}
@@ -291,7 +322,8 @@ export async function runSingleStep(
 		modelAttempts,
 		artifactPaths,
 		interrupted: finalResult?.interrupted,
-		structuredOutput: (finalResult as (RunPiStreamingResult & { structuredOutput?: unknown }) | undefined)?.structuredOutput,
+		structuredOutput: (finalResult as (RunPiStreamingResult & { structuredOutput?: unknown }) | undefined)
+			?.structuredOutput,
 		structuredOutputPath: effectiveStructuredOutput?.outputPath,
 		structuredOutputSchemaPath: effectiveStructuredOutput?.schemaPath,
 	};

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

@@ -2,18 +2,24 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import type { Message } from "@earendil-works/pi-ai/compat";
 import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
-import { detectSubagentError, extractTextFromContent, extractToolArgsPreview, getFinalOutput } from "../../shared/utils.ts";
 import { getSubagentDepthEnv } from "../../shared/types.ts";
-import { formatPiSpawnError, getPiSpawnCommand, validatePiSpawnCwd } from "../shared/pi-spawn.ts";
+import {
+	detectSubagentError,
+	extractTextFromContent,
+	extractToolArgsPreview,
+	getFinalOutput,
+} from "../../shared/utils.ts";
+import { createAttemptWatchdog } from "../shared/attempt-watchdog.ts";
 import {
 	assistantStopReason,
 	isAssistantFailureStopReason,
 	shouldStartSubagentFinalDrain,
 } from "../shared/final-drain.ts";
 import { modelFailureMessage } from "../shared/model-fallback.ts";
-import { createAttemptWatchdog } from "../shared/attempt-watchdog.ts";
-import type { ChildEvent, ChildEventContext, RunPiStreamingResult } from "./subagent-runner-types.ts";
+import { formatPiSpawnError, getPiSpawnCommand, validatePiSpawnCwd } from "../shared/pi-spawn.ts";
+import { buildSubagentSpawnEnv } from "../shared/spawn-env.ts";
 import { createChildEventJournal } from "./async-event-journal.ts";
+import type { ChildEvent, ChildEventContext, RunPiStreamingResult } from "./subagent-runner-types.ts";
 import { emptyUsage } from "./subagent-runner-utils.ts";
 
 export function runPiStreaming(
@@ -42,11 +48,21 @@ export function runPiStreaming(
 	}
 	return new Promise((resolve) => {
 		const outputStream = fs.createWriteStream(outputFile, { flags: "w" });
-		const spawnEnv = {
-			...process.env,
-			...(env ?? {}),
-			...getSubagentDepthEnv(maxSubagentDepth, { workflowStageSubagentGuard }),
-		};
+		// A write stream with no `error` listener turns any failure to open or write
+		// the transcript -- a removed run directory, a full disk, EPERM -- into an
+		// uncaught exception that takes the host process down, asynchronously and
+		// long after the call that caused it returned. The transcript is diagnostic,
+		// so degrade the way the child-event journal beside it already does.
+		outputStream.on("error", (streamError) => {
+			console.error(
+				`Failed to write the subagent transcript to '${outputFile}'; continuing without it: ${String(streamError)}`,
+			);
+		});
+		const spawnEnv = buildSubagentSpawnEnv(
+			process.env,
+			env,
+			getSubagentDepthEnv(maxSubagentDepth, { workflowStageSubagentGuard }),
+		);
 		const spawnSpec = getPiSpawnCommand(args, {
 			...(piPackageRoot ? { piPackageRoot } : {}),
 			...(piArgv1 ? { argv1: piArgv1 } : {}),
@@ -260,10 +276,16 @@ export function runPiStreaming(
 			await childEventJournal.close();
 			const finalOutput = getFinalOutput(messages) || rawStdoutLines.join("\n").trim();
 			const finalError = error ?? assistantError ?? spawnErrorText;
-			const forcedDrainAfterFinalSuccess = forcedTerminationSignal && cleanTerminalAssistantStopReceived && !finalError;
+			const forcedDrainAfterFinalSuccess =
+				forcedTerminationSignal && cleanTerminalAssistantStopReceived && !finalError;
 			resolve({
 				stderr,
-				exitCode: interrupted || forcedDrainAfterFinalSuccess ? 0 : forcedTerminationSignal || signal ? (exitCode ?? 1) : exitCode,
+				exitCode:
+					interrupted || forcedDrainAfterFinalSuccess
+						? 0
+						: forcedTerminationSignal || signal
+							? (exitCode ?? 1)
+							: exitCode,
 				messages,
 				usage,
 				model,