@bastani/atomic 0.8.26-alpha.1 → 0.8.26-alpha.10

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

@@ -48,7 +48,12 @@ import { outputEntryFromAsyncResult, resolveOutputReferences } from "../shared/c
 import { createStructuredOutputRuntime, readStructuredOutput } from "../shared/structured-output.ts";
 import { collectDynamicResults, DynamicFanoutError, materializeDynamicParallelStep, validateDynamicCollection } from "../shared/dynamic-fanout.ts";
 import { nestedSummaryFromAsyncStatus, writeNestedEvent } from "../shared/nested-events.ts";
-import { formatModelAttemptNote, isRetryableModelFailure } from "../shared/model-fallback.ts";
+import { formatModelAttemptNote, isRetryableModelFailure, modelFailureMessage } from "../shared/model-fallback.ts";
+import {
+	assistantStopReason,
+	isAssistantFailureStopReason,
+	shouldStartSubagentFinalDrain,
+} from "../shared/final-drain.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
 import { detectSubagentError, extractTextFromContent, extractToolArgsPreview, getFinalOutput } from "../../shared/utils.ts";
 import { evaluateCompletionMutationGuard } from "../shared/completion-guard.ts";
@@ -230,6 +235,7 @@ interface RunPiStreamingResult {
 	finalOutput: string;
 	interrupted?: boolean;
 	observedMutationAttempt?: boolean;
+	modelFailureSignal?: unknown;
 }
 
 function runPiStreaming(
@@ -270,6 +276,7 @@ function runPiStreaming(
 		let model: string | undefined;
 		let error: string | undefined;
 		let assistantError: string | undefined;
+		let assistantFailureSignal: unknown;
 		let interrupted = false;
 		let observedMutationAttempt = false;
 		const rawStdoutLines: string[] = [];
@@ -330,7 +337,6 @@ function runPiStreaming(
 
 				if (event.type !== "message_end" || event.message.role !== "assistant") return;
 				if (event.message.model) model = event.message.model;
-				if (event.message.errorMessage) assistantError = event.message.errorMessage;
 				const eventUsage = event.message.usage;
 				if (eventUsage) {
 					usage.turns++;
@@ -340,12 +346,21 @@ function runPiStreaming(
 					usage.cacheWrite += eventUsage.cacheWrite ?? 0;
 					usage.cost += eventUsage.cost?.total ?? 0;
 				}
-				const stopReason = (event.message as { stopReason?: string }).stopReason;
-				const hasToolCall = Array.isArray(event.message.content)
-					&& event.message.content.some((part) => (part as { type?: string }).type === "toolCall");
-				if (stopReason === "stop" && !hasToolCall) {
-					if (!event.message.errorMessage && extractTextFromContent(event.message.content).trim()) assistantError = undefined;
-					cleanTerminalAssistantStopReceived ||= !event.message.errorMessage;
+				const stopReason = assistantStopReason(event.message);
+				if (event.message.errorMessage) {
+					assistantError = event.message.errorMessage;
+					assistantFailureSignal = event.message;
+				}
+				if (isAssistantFailureStopReason(stopReason)) {
+					assistantError = modelFailureMessage(event.message);
+					assistantFailureSignal = event.message;
+				}
+				if (shouldStartSubagentFinalDrain(event.message)) {
+					if (extractTextFromContent(event.message.content).trim()) {
+						assistantError = undefined;
+						assistantFailureSignal = undefined;
+					}
+					cleanTerminalAssistantStopReceived = true;
 					startFinalDrain();
 				}
 			}
@@ -448,6 +463,9 @@ function runPiStreaming(
 				finalOutput,
 				interrupted,
 				observedMutationAttempt,
+				...(assistantFailureSignal !== undefined && finalError === assistantError
+					? { modelFailureSignal: assistantFailureSignal }
+					: {}),
 			});
 		});
 
@@ -459,7 +477,20 @@ function runPiStreaming(
 			outputStream.end();
 			const finalOutput = getFinalOutput(messages) || rawStdoutLines.join("\n").trim();
 			const spawnErrorMessage = spawnError instanceof Error ? spawnError.message : String(spawnError);
-			resolve({ stderr, exitCode: 1, messages, usage, model, error: error ?? assistantError ?? spawnErrorMessage, finalOutput, observedMutationAttempt });
+			const finalError = error ?? assistantError ?? spawnErrorMessage;
+			resolve({
+				stderr,
+				exitCode: 1,
+				messages,
+				usage,
+				model,
+				error: finalError,
+				finalOutput,
+				observedMutationAttempt,
+				...(assistantFailureSignal !== undefined && finalError === assistantError
+					? { modelFailureSignal: assistantFailureSignal }
+					: {}),
+			});
 		});
 	});
 }
@@ -650,6 +681,7 @@ async function runSingleStep(
 	const attemptedModels: string[] = [];
 	const modelAttempts: ModelAttempt[] = [];
 	const attemptNotes: string[] = [];
+	const pendingAttemptNotes: string[] = [];
 	const eventsPath = path.join(path.dirname(ctx.outputFile), "events.jsonl");
 	let finalResult: RunPiStreamingResult | undefined;
 	let finalFastMode: boolean | undefined;
@@ -768,9 +800,20 @@ async function runSingleStep(
 		finalFastMode = attemptFastMode;
 		finalOutputSnapshot = outputSnapshot;
 		finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error, structuredOutput } as RunPiStreamingResult & { structuredOutput?: unknown };
-		if (attempt.success || completionGuardTriggered) break;
-		if (!isRetryableModelFailure(error) || index === candidates.length - 1) break;
-		attemptNotes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
+		if (attempt.success) break;
+		const retrySignal = run.modelFailureSignal ?? error;
+		if (
+			!completionGuardTriggered
+			&& structuredError === undefined
+			&& hiddenError?.hasError !== true
+			&& isRetryableModelFailure(retrySignal)
+			&& index < candidates.length - 1
+		) {
+			pendingAttemptNotes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
+			continue;
+		}
+		attemptNotes.push(...pendingAttemptNotes);
+		break;
 	}
 
 	const rawOutput = finalResult?.finalOutput ?? "";

package/dist/builtin/subagents/src/runs/foreground/execution.ts

@@ -17,6 +17,7 @@ import {
 	type AgentProgress,
 	type ArtifactPaths,
 	type ControlEvent,
+	type Details,
 	type ModelAttempt,
 	type RunSyncOptions,
 	type SingleResult,
@@ -53,7 +54,13 @@ import {
 	buildModelCandidates,
 	formatModelAttemptNote,
 	isRetryableModelFailure,
+	modelFailureMessage,
 } from "../shared/model-fallback.ts";
+import {
+	assistantStopReason,
+	isAssistantFailureStopReason,
+	shouldStartSubagentFinalDrain,
+} from "../shared/final-drain.ts";
 import {
 	createMutatingFailureState,
 	didMutatingToolFail,
@@ -75,6 +82,7 @@ import { acceptanceFailureMessage, evaluateAcceptance, formatAcceptancePrompt, r
 
 const artifactOutputByResult = new WeakMap<SingleResult, string>();
 const acceptanceOutputByResult = new WeakMap<SingleResult, string>();
+const modelFailureSignalByResult = new WeakMap<SingleResult, unknown>();
 
 function emptyUsage(): Usage {
 	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
@@ -139,6 +147,29 @@ function snapshotResult(result: SingleResult, progress: AgentProgress): SingleRe
 	};
 }
 
+type RunSyncUpdate = import("@earendil-works/pi-agent-core").AgentToolResult<Details>;
+
+function extractUpdateText(update: RunSyncUpdate): string | undefined {
+	const text = update.content
+		.map((item) => item.type === "text" ? item.text : undefined)
+		.filter((item): item is string => Boolean(item?.trim()))
+		.join("\n");
+	return text || undefined;
+}
+
+export function shouldSuppressIntermediateRetryableFailureUpdate(update: RunSyncUpdate): boolean {
+	const result = update.details?.results?.[0];
+	if (!result) return false;
+	const progress = update.details?.progress?.[0];
+	const status = result.progress?.status ?? progress?.status;
+	if (status !== "failed") return false;
+	const failureText = result.error
+		?? result.progress?.error
+		?? progress?.error
+		?? extractUpdateText(update);
+	return isRetryableModelFailure(failureText);
+}
+
 async function runSingleAttempt(
 	runtimeCwd: string,
 	agent: AgentConfig,
@@ -269,6 +300,7 @@ async function runSingleAttempt(
 		let detached = false;
 		let intercomStarted = false;
 		let assistantError: string | undefined;
+		let assistantFailureSignal: unknown;
 		let removeAbortListener: (() => void) | undefined;
 		let removeInterruptListener: (() => void) | undefined;
 		let activityTimer: NodeJS.Timeout | undefined;
@@ -520,16 +552,25 @@ async function runSingleAttempt(
 						progress.tokens = result.usage.input + result.usage.output;
 					}
 					if (!result.model && evt.message.model) result.model = evt.message.model;
-					if (evt.message.errorMessage) assistantError = evt.message.errorMessage;
 					const assistantText = extractTextFromContent(evt.message.content);
 					appendRecentOutput(progress, assistantText.split("\n").slice(-10));
-					// Final assistant message: start the exit drain window.
-					const stopReason = (evt.message as { stopReason?: string }).stopReason;
-					const hasToolCall = Array.isArray(evt.message.content)
-						&& evt.message.content.some((part) => (part as { type?: string }).type === "toolCall");
-					if (stopReason === "stop" && !hasToolCall) {
-						if (!evt.message.errorMessage && assistantText.trim()) assistantError = undefined;
-						cleanTerminalAssistantStopReceived ||= !evt.message.errorMessage;
+					// Clean final assistant stops start the exit drain window; provider error/aborted
+					// stop reasons remain failure evidence so pi-ai can auto-retry before exit.
+					const stopReason = assistantStopReason(evt.message);
+					if (evt.message.errorMessage) {
+						assistantError = evt.message.errorMessage;
+						assistantFailureSignal = evt.message;
+					}
+					if (isAssistantFailureStopReason(stopReason)) {
+						assistantError = modelFailureMessage(evt.message);
+						assistantFailureSignal = evt.message;
+					}
+					if (shouldStartSubagentFinalDrain(evt.message)) {
+						if (assistantText.trim()) {
+							assistantError = undefined;
+							assistantFailureSignal = undefined;
+						}
+						cleanTerminalAssistantStopReceived = true;
 						startFinalDrain();
 					}
 				}
@@ -609,6 +650,9 @@ async function runSingleAttempt(
 			processClosed = true;
 			if (buf.trim()) processLine(buf);
 			if (!result.error && assistantError) result.error = assistantError;
+			if (assistantFailureSignal !== undefined && result.error === assistantError) {
+				modelFailureSignalByResult.set(result, assistantFailureSignal);
+			}
 			const forcedDrainAfterFinalSuccess = forcedTerminationSignal && cleanTerminalAssistantStopReceived && !result.error;
 			if (code !== 0 && stderrBuf.trim() && !result.error && !forcedDrainAfterFinalSuccess) {
 				result.error = stderrBuf.trim();
@@ -875,6 +919,7 @@ export async function runSync(
 	const modelAttempts: ModelAttempt[] = [];
 	const aggregateUsage = emptyUsage();
 	const attemptNotes: string[] = [];
+	const pendingAttemptNotes: string[] = [];
 	let totalToolCount = 0;
 	let totalDurationMs = 0;
 
@@ -897,7 +942,18 @@ export async function runSync(
 		const candidate = modelsToTry[i];
 		if (candidate) attemptedModels.push(candidate);
 		const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
-		const result = await runSingleAttempt(runtimeCwd, agent, taskWithAcceptance, candidate, options, {
+		let attemptOptions = options;
+		if (i < modelsToTry.length - 1 && options.onUpdate) {
+			const forwardUpdate = options.onUpdate;
+			attemptOptions = {
+				...options,
+				onUpdate: (update) => {
+					if (shouldSuppressIntermediateRetryableFailureUpdate(update)) return;
+					forwardUpdate(update);
+				},
+			};
+		}
+		const result = await runSingleAttempt(runtimeCwd, agent, taskWithAcceptance, candidate, attemptOptions, {
 			sessionEnabled,
 			systemPrompt,
 			resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
@@ -928,10 +984,13 @@ export async function runSync(
 		if (attemptSucceeded) {
 			break;
 		}
-		if (!isRetryableModelFailure(result.error) || i === modelsToTry.length - 1) {
-			break;
+		const retrySignal = modelFailureSignalByResult.get(result) ?? result.error;
+		if (isRetryableModelFailure(retrySignal) && i < modelsToTry.length - 1) {
+			pendingAttemptNotes.push(formatModelAttemptNote(attempt, modelsToTry[i + 1]));
+			continue;
 		}
-		attemptNotes.push(formatModelAttemptNote(attempt, modelsToTry[i + 1]));
+		attemptNotes.push(...pendingAttemptNotes);
+		break;
 	}
 
 	const result = lastResult ?? {

package/dist/builtin/subagents/src/runs/shared/acceptance.ts

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { spawnSync } from "node:child_process";
 import * as path from "node:path";
+import { createGitEnvironment } from "@bastani/atomic";
 import type {
 	AcceptanceConfig,
 	AcceptanceEvidenceKind,
@@ -399,7 +400,7 @@ function reportEvidencePresent(report: AcceptanceReport, kind: AcceptanceEvidenc
 }
 
 function checkNoStagedFiles(cwd: string): AcceptanceRuntimeCheck {
-	const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8" });
+	const result = spawnSync("git", ["status", "--short"], { cwd, env: createGitEnvironment(), encoding: "utf-8" });
 	if (result.status !== 0) {
 		return { id: "no-staged-files", status: "not-applicable", message: "git status unavailable; no staged-files check skipped" };
 	}

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

@@ -0,0 +1,34 @@
+export interface SubagentAssistantDrainMessage {
+	readonly role?: unknown;
+	readonly content?: unknown;
+	readonly stopReason?: unknown;
+	readonly errorMessage?: unknown;
+}
+
+export function assistantStopReason(message: SubagentAssistantDrainMessage): string | undefined {
+	return typeof message.stopReason === "string" ? message.stopReason : undefined;
+}
+
+export function isAssistantFailureStopReason(stopReason: string | undefined): boolean {
+	return stopReason === "error" || stopReason === "aborted";
+}
+
+export function assistantMessageHasToolCall(message: SubagentAssistantDrainMessage): boolean {
+	return Array.isArray(message.content)
+		&& message.content.some((part) => part !== null
+			&& typeof part === "object"
+			&& (part as { readonly type?: unknown }).type === "toolCall");
+}
+
+function assistantMessageHasError(message: SubagentAssistantDrainMessage): boolean {
+	const errorMessage = message.errorMessage;
+	if (typeof errorMessage === "string") return errorMessage.trim().length > 0;
+	return errorMessage !== undefined && errorMessage !== null;
+}
+
+export function shouldStartSubagentFinalDrain(message: SubagentAssistantDrainMessage): boolean {
+	if (message.role !== undefined && message.role !== "assistant") return false;
+	return assistantStopReason(message) === "stop"
+		&& !assistantMessageHasError(message)
+		&& !assistantMessageHasToolCall(message);
+}