@bastani/atomic 0.8.29 → 0.8.30-alpha.1

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

@@ -66,7 +66,6 @@ import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
 import { ChainOutputValidationError, outputEntryFromResult, resolveOutputReferences, validateChainOutputBindings } from "../shared/chain-outputs.ts";
 import { createStructuredOutputRuntime } from "../shared/structured-output.ts";
 import { collectDynamicResults, DynamicFanoutError, materializeDynamicParallelStep, validateDynamicCollection, type DynamicCollectedResult } from "../shared/dynamic-fanout.ts";
-import { acceptanceFailureMessage, aggregateAcceptanceReport, evaluateAcceptance, resolveEffectiveAcceptance } from "../shared/acceptance.ts";
 import type { ChainOutputMap } from "../../shared/types.ts";
 
 type RunSyncDependency = typeof runSync;
@@ -100,7 +99,7 @@ interface ChainExecutionDetailsInput {
 	outputs?: ChainOutputMap;
 	currentFlatIndex?: number;
 	dynamicChildren?: Record<number, Array<{ agent: string; label?: string; flatIndex: number; itemKey: string; outputName?: string; structured?: boolean; error?: string }>>;
-	dynamicGroupStatuses?: Record<number, { status: "pending" | "running" | "completed" | "failed" | "paused" | "detached"; error?: string; acceptance?: SingleResult["acceptance"] }>;
+	dynamicGroupStatuses?: Record<number, { status: "pending" | "running" | "completed" | "failed" | "paused" | "detached"; error?: string }>;
 }
 
 interface ParallelChainRunInput {
@@ -297,8 +296,6 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				preferredModelProvider: input.ctx.model?.provider,
 				skills: behavior.skills === false ? [] : behavior.skills,
 				structuredOutput: structuredRuntime,
-				acceptance: task.acceptance,
-				acceptanceContext: { mode: "chain" },
 				onUpdate: input.onUpdate
 					? (progressUpdate) => {
 						const stepResults = progressUpdate.details?.results || [];
@@ -785,30 +782,6 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 					stepIndex,
 				};
 				dynamicGroupStatuses[stepIndex] = { status: "completed" };
-				if (step.acceptance !== undefined) {
-					const effectiveGroupAcceptance = resolveEffectiveAcceptance({
-						explicit: step.acceptance,
-						agentName: step.parallel.agent,
-						task: step.parallel.task ?? originalTask,
-						mode: "chain",
-						dynamicGroup: true,
-					});
-					const groupAcceptance = await evaluateAcceptance({
-						acceptance: effectiveGroupAcceptance,
-						output: "",
-						report: aggregateAcceptanceReport({
-							results: [],
-							notes: "Dynamic fanout produced 0 results.",
-						}),
-						cwd: cwd ?? ctx.cwd,
-					});
-					dynamicGroupStatuses[stepIndex].acceptance = groupAcceptance;
-					const groupAcceptanceFailure = acceptanceFailureMessage(groupAcceptance);
-					if (groupAcceptanceFailure) {
-						dynamicGroupStatuses[stepIndex] = { status: "failed", error: groupAcceptanceFailure, acceptance: groupAcceptance };
-						return buildChainExecutionErrorResult(groupAcceptanceFailure, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
-					}
-				}
 				prev = "Dynamic fanout produced 0 results.";
 				continue;
 			}
@@ -942,28 +915,6 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				stepIndex,
 			};
 			dynamicGroupStatuses[stepIndex] = { status: "completed" };
-			const effectiveGroupAcceptance = resolveEffectiveAcceptance({
-				explicit: step.acceptance,
-				agentName: step.parallel.agent,
-				task: step.parallel.task ?? originalTask,
-				mode: "chain",
-				dynamicGroup: true,
-			});
-			const groupAcceptance = await evaluateAcceptance({
-				acceptance: effectiveGroupAcceptance,
-				output: "",
-				report: aggregateAcceptanceReport({
-					results: parallelResults,
-					notes: `Dynamic fanout collected ${collected.length} result(s) into ${step.collect.as}.`,
-				}),
-				cwd: cwd ?? ctx.cwd,
-			});
-			dynamicGroupStatuses[stepIndex].acceptance = groupAcceptance;
-			const groupAcceptanceFailure = acceptanceFailureMessage(groupAcceptance);
-			if (groupAcceptanceFailure) {
-				dynamicGroupStatuses[stepIndex] = { status: "failed", error: groupAcceptanceFailure, acceptance: groupAcceptance };
-				return buildChainExecutionErrorResult(groupAcceptanceFailure, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex - dynamicParallelStep.parallel.length }));
-			}
 			const taskResults: ParallelTaskResult[] = parallelResults.map((result, i) => ({
 				agent: result.agent,
 				taskIndex: i,
@@ -1078,8 +1029,6 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				preferredModelProvider: ctx.model?.provider,
 				skills: behavior.skills === false ? [] : behavior.skills,
 				structuredOutput: structuredRuntime,
-				acceptance: seqStep.acceptance,
-				acceptanceContext: { mode: "chain" },
 				onUpdate: onUpdate
 					? (p) => {
 						const stepResults = p.details?.results || [];

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

@@ -43,12 +43,17 @@ import {
 	extractTextFromContent,
 } from "../../shared/utils.ts";
 import { buildSkillInjection, resolveSkillsWithFallback } from "../../agents/skills.ts";
-import { evaluateCompletionMutationGuard } from "../shared/completion-guard.ts";
 import { getPiSpawnCommand } from "../shared/pi-spawn.ts";
 import { createJsonlWriter } from "../../shared/jsonl-writer.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
 import { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "../shared/pi-args.ts";
-import { readStructuredOutput } from "../shared/structured-output.ts";
+import {
+	STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS,
+	formatStructuredOutputCorrectionPrompt,
+	isStructuredOutputContractError,
+	latestStructuredOutputToolErrorFromMessages,
+	readStructuredOutput,
+} from "../shared/structured-output.ts";
 import { captureSingleOutputSnapshot, formatSavedOutputReference, resolveSingleOutput, validateFileOnlyOutputMode, type SingleOutputSnapshot } from "../shared/single-output.ts";
 import {
 	buildModelCandidates,
@@ -78,10 +83,8 @@ import {
 	resolveSubagentModelFastMode,
 } from "../../shared/fast-mode.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
-import { acceptanceFailureMessage, evaluateAcceptance, formatAcceptancePrompt, resolveEffectiveAcceptance, stripAcceptanceReport } from "../shared/acceptance.ts";
 
 const artifactOutputByResult = new WeakMap<SingleResult, string>();
-const acceptanceOutputByResult = new WeakMap<SingleResult, string>();
 const modelFailureSignalByResult = new WeakMap<SingleResult, unknown>();
 
 function emptyUsage(): Usage {
@@ -105,17 +108,6 @@ function appendRecentOutput(progress: AgentProgress, lines: string[]): void {
 	}
 }
 
-function stripAcceptanceReportsFromMessages(messages: Message[] | undefined): void {
-	for (const message of messages ?? []) {
-		if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
-		for (const part of message.content) {
-			if (part.type === "text" && "text" in part && typeof part.text === "string") {
-				part.text = stripAcceptanceReport(part.text);
-			}
-		}
-	}
-}
-
 function snapshotProgress(progress: AgentProgress): AgentProgress {
 	return {
 		...progress,
@@ -157,38 +149,47 @@ function extractUpdateText(update: RunSyncUpdate): string | undefined {
 	return text || undefined;
 }
 
-export function shouldSuppressIntermediateRetryableFailureUpdate(update: RunSyncUpdate): boolean {
+function terminalUpdateFailureText(update: RunSyncUpdate): string | undefined {
 	const result = update.details?.results?.[0];
-	if (!result) return false;
+	if (!result) return undefined;
 	const progress = update.details?.progress?.[0];
 	const status = result.progress?.status ?? progress?.status;
-	if (status !== "failed") return false;
-	const failureText = result.error
+	if (status !== "failed") return undefined;
+	return result.error
 		?? result.progress?.error
 		?? progress?.error
 		?? extractUpdateText(update);
-	return isRetryableModelFailure(failureText);
 }
 
+export function shouldSuppressIntermediateRetryableFailureUpdate(update: RunSyncUpdate): boolean {
+	return isRetryableModelFailure(terminalUpdateFailureText(update));
+}
+
+export function shouldSuppressIntermediateStructuredOutputFailureUpdate(update: RunSyncUpdate): boolean {
+	return isStructuredOutputContractError(terminalUpdateFailureText(update));
+}
+
+type RunSingleAttemptShared = {
+	sessionEnabled: boolean;
+	systemPrompt: string;
+	resolvedSkillNames?: string[];
+	skillsWarning?: string;
+	jsonlPath?: string;
+	artifactPaths?: ArtifactPaths;
+	attemptNotes: string[];
+	outputSnapshot?: SingleOutputSnapshot;
+	fastModeSettings: CodexFastModeResolvedSettings;
+	fastModeScope: CodexFastModeScope;
+	originalTask?: string;
+};
+
 async function runSingleAttempt(
 	runtimeCwd: string,
 	agent: AgentConfig,
 	task: string,
 	model: string | undefined,
 	options: RunSyncOptions,
-	shared: {
-		sessionEnabled: boolean;
-		systemPrompt: string;
-		resolvedSkillNames?: string[];
-		skillsWarning?: string;
-		jsonlPath?: string;
-		artifactPaths?: ArtifactPaths;
-		attemptNotes: string[];
-		outputSnapshot?: SingleOutputSnapshot;
-		fastModeSettings: CodexFastModeResolvedSettings;
-		fastModeScope: CodexFastModeScope;
-		originalTask?: string;
-	},
+	shared: RunSingleAttemptShared,
 ): Promise<SingleResult> {
 	const modelArg = applyThinkingSuffix(model, agent.thinking);
 	const runCwd = options.cwd ?? runtimeCwd;
@@ -283,8 +284,6 @@ async function runSingleAttempt(
 			workflowStageSubagentGuard: options.workflowStageSubagentGuard,
 		}),
 	};
-	let observedMutationAttempt = false;
-
 	const exitCode = await new Promise<number>((resolve) => {
 		const spawnSpec = getPiSpawnCommand(args);
 		const proc = spawn(spawnSpec.command, spawnSpec.args, {
@@ -517,7 +516,6 @@ async function runSingleAttempt(
 				progress.currentToolStartedAt = now;
 				progress.currentPath = resolveCurrentPath(evt.toolName, toolArgs);
 				const mutates = isMutatingTool(evt.toolName, toolArgs);
-				observedMutationAttempt = observedMutationAttempt || mutates;
 				pendingToolResult = { tool: evt.toolName ?? "tool", path: progress.currentPath, mutates, startedAt: now };
 				fireUpdate();
 			}
@@ -774,36 +772,10 @@ async function runSingleAttempt(
 		durationMs: progress.durationMs,
 	};
 
-	const acceptanceOutput = getFinalOutput(result.messages ?? []);
-	let fullOutput = stripAcceptanceReport(acceptanceOutput);
-	const completionGuard = result.exitCode === 0 && !result.error && agent.completionGuard !== false
-		? evaluateCompletionMutationGuard({
-			agent: agent.name,
-			task: shared.originalTask ?? task,
-			messages: result.messages ?? [],
-			tools: agent.tools,
-			mcpDirectTools: agent.mcpDirectTools,
-		})
-		: undefined;
-	if (completionGuard?.triggered && !observedMutationAttempt) {
-		result.exitCode = 1;
-		result.error = "Subagent completed without making edits for an implementation task.\nIt appears to have returned planning or scratchpad output instead of applying changes.";
-		progress.status = "failed";
-		progress.error = result.error;
-		emitControlEvent(buildControlEvent({
-			from: progress.activityState,
-			to: "needs_attention",
-			runId: options.runId ?? agent.name,
-			agent: agent.name,
-			index: options.index,
-			ts: Date.now(),
-			message: `${agent.name} completed without making edits for an implementation task`,
-			reason: "completion_guard",
-		}));
-	}
+	let fullOutput = getFinalOutput(result.messages ?? []);
 	if (options.outputPath && result.exitCode === 0) {
 		const resolvedOutput = resolveSingleOutput(options.outputPath, fullOutput, shared.outputSnapshot);
-		fullOutput = stripAcceptanceReport(resolvedOutput.fullOutput);
+		fullOutput = resolvedOutput.fullOutput;
 		result.savedOutputPath = resolvedOutput.savedPath;
 		result.outputSaveError = resolvedOutput.saveError;
 		if (resolvedOutput.savedPath) {
@@ -811,7 +783,6 @@ async function runSingleAttempt(
 		}
 	}
 	artifactOutputByResult.set(result, fullOutput);
-	acceptanceOutputByResult.set(result, acceptanceOutput);
 	result.outputMode = options.outputMode ?? "inline";
 	result.finalOutput = options.outputMode === "file-only" && result.savedOutputPath && result.outputReference
 		? result.outputReference.message
@@ -834,6 +805,71 @@ async function runSingleAttempt(
 	return result;
 }
 
+async function runSingleAttemptWithStructuredOutputRetries(
+	runtimeCwd: string,
+	agent: AgentConfig,
+	task: string,
+	model: string | undefined,
+	options: RunSyncOptions,
+	shared: RunSingleAttemptShared,
+): Promise<SingleResult> {
+	let nextTask = task;
+	let correctiveAttempts = 0;
+	let finalResult: SingleResult | undefined;
+	const aggregateUsage = emptyUsage();
+	let totalToolCount = 0;
+	let totalDurationMs = 0;
+
+	while (true) {
+		const suppressIntermediateStructuredOutputFailure = options.structuredOutput !== undefined
+			&& correctiveAttempts < STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS
+			&& options.onUpdate !== undefined;
+		const attemptOptions = suppressIntermediateStructuredOutputFailure
+			? {
+				...options,
+				onUpdate: (update: RunSyncUpdate) => {
+					if (shouldSuppressIntermediateStructuredOutputFailureUpdate(update)) return;
+					options.onUpdate?.(update);
+				},
+			}
+			: options;
+		const result = await runSingleAttempt(runtimeCwd, agent, nextTask, model, attemptOptions, shared);
+		finalResult = result;
+		sumUsage(aggregateUsage, result.usage);
+		totalToolCount += result.progressSummary?.toolCount ?? 0;
+		totalDurationMs += result.progressSummary?.durationMs ?? 0;
+
+		if (!options.structuredOutput || !isStructuredOutputContractError(result.error)) break;
+		const correctionError = latestStructuredOutputToolErrorFromMessages(result.messages) ?? result.error ?? "Structured output contract failed.";
+		if (correctiveAttempts >= STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS) {
+			result.error = correctionError;
+			break;
+		}
+		correctiveAttempts += 1;
+		nextTask = formatStructuredOutputCorrectionPrompt({
+			originalTask: task,
+			error: correctionError,
+			attempt: correctiveAttempts,
+		});
+	}
+
+	const result = finalResult ?? {
+		agent: agent.name,
+		task,
+		exitCode: 1,
+		messages: [],
+		usage: emptyUsage(),
+		error: "Subagent did not produce a result.",
+	} satisfies SingleResult;
+	result.usage = aggregateUsage;
+	result.progressSummary = {
+		toolCount: totalToolCount,
+		tokens: aggregateUsage.input + aggregateUsage.output,
+		durationMs: totalDurationMs,
+	};
+	return result;
+}
+
 /**
  * Run a subagent synchronously (blocking until complete)
  */
@@ -869,17 +905,6 @@ export async function runSync(
 	}
 
 	const shareEnabled = options.share === true;
-	const effectiveAcceptance = resolveEffectiveAcceptance({
-		explicit: options.acceptance,
-		agentName,
-		task,
-		mode: options.acceptanceContext?.mode ?? "single",
-		async: options.acceptanceContext?.async,
-		dynamic: options.acceptanceContext?.dynamic,
-		dynamicGroup: options.acceptanceContext?.dynamicGroup,
-	});
-	const acceptancePrompt = formatAcceptancePrompt(effectiveAcceptance);
-	const taskWithAcceptance = acceptancePrompt ? `${task}\n${acceptancePrompt}` : task;
 	const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
 	const skillNames = options.skills ?? agent.skills ?? [];
 	const skillCwd = options.cwd ?? runtimeCwd;
@@ -925,7 +950,7 @@ export async function runSync(
 		artifactPathsResult = getArtifactPaths(options.artifactsDir, options.runId, agentName, options.index);
 		ensureArtifactsDir(options.artifactsDir);
 		if (options.artifactConfig?.includeInput !== false) {
-				writeArtifact(artifactPathsResult.inputPath, `# Task for ${agentName}\n\n${taskWithAcceptance}`);
+			writeArtifact(artifactPathsResult.inputPath, `# Task for ${agentName}\n\n${task}`);
 		}
 		if (options.artifactConfig?.includeJsonl !== false) {
 			jsonlPath = artifactPathsResult.jsonlPath;
@@ -949,7 +974,7 @@ export async function runSync(
 				},
 			};
 		}
-		const result = await runSingleAttempt(runtimeCwd, agent, taskWithAcceptance, candidate, attemptOptions, {
+		const result = await runSingleAttemptWithStructuredOutputRetries(runtimeCwd, agent, task, candidate, attemptOptions, {
 			sessionEnabled,
 			systemPrompt,
 			resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
@@ -1056,21 +1081,5 @@ export async function runSync(
 		if (sessionFile) result.sessionFile = sessionFile;
 	}
 
-		result.acceptance = await evaluateAcceptance({
-			acceptance: effectiveAcceptance,
-			output: acceptanceOutputByResult.get(result) ?? result.finalOutput ?? "",
-			cwd: options.cwd ?? runtimeCwd,
-		});
-		const acceptanceFailure = acceptanceFailureMessage(result.acceptance);
-		stripAcceptanceReportsFromMessages(result.messages);
-		if (acceptanceFailure && result.acceptance.explicit && result.exitCode === 0 && !result.detached && !result.interrupted) {
-		result.exitCode = 1;
-		result.error = result.error ? `${result.error}\n${acceptanceFailure}` : acceptanceFailure;
-		if (result.progress) {
-			result.progress.status = "failed";
-			result.progress.error = result.error;
-		}
-	}
-
 	return result;
 }

package/dist/builtin/subagents/src/runs/foreground/subagent-executor.ts

@@ -64,7 +64,6 @@ import {
 } from "../shared/worktree.ts";
 import {
 	type AgentProgress,
-	type AcceptanceInput,
 	type ArtifactConfig,
 	type ArtifactPaths,
 	type ControlConfig,
@@ -109,7 +108,6 @@ interface TaskParam {
 	progress?: boolean;
 	model?: string;
 	skill?: string | string[] | boolean;
-	acceptance?: AcceptanceInput;
 }
 
 export interface SubagentParamsLike {
@@ -143,7 +141,6 @@ export interface SubagentParamsLike {
 	outputMode?: "inline" | "file-only";
 	agentScope?: string;
 	chainDir?: string;
-	acceptance?: AcceptanceInput;
 }
 
 export interface SubagentExecutorRuntimeDeps {
@@ -1150,7 +1147,6 @@ function runAsyncPath(data: ExecutionContextData, deps: ResolvedExecutorDeps): S
 			...(task.outputMode !== undefined ? { outputMode: task.outputMode } : {}),
 			...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
 			...(task.progress !== undefined ? { progress: task.progress } : {}),
-			...(task.acceptance !== undefined ? { acceptance: task.acceptance } : {}),
 		}));
 		return deps.runtime.executeAsyncChain(id, {
 			chain: [{
@@ -1252,7 +1248,6 @@ function runAsyncPath(data: ExecutionContextData, deps: ResolvedExecutorDeps): S
 			controlIntercomTarget,
 			childIntercomTarget: childIntercomTarget ? (agent, index) => childIntercomTarget(agent, index) : undefined,
 			nestedRoute,
-			acceptance: params.acceptance,
 		});
 	}
 
@@ -1577,8 +1572,6 @@ async function runForegroundParallelTasks(input: ForegroundParallelRunInput): Pr
 			preferredModelProvider: input.ctx.model?.provider,
 			currentModel: currentModelFullId(input.ctx.model),
 			skills: effectiveSkills === false ? [] : effectiveSkills,
-			acceptance: task.acceptance,
-			acceptanceContext: { mode: "parallel" },
 			onUpdate: input.onUpdate
 				? (progressUpdate) => {
 					const stepResults = progressUpdate.details?.results || [];
@@ -1771,7 +1764,6 @@ async function runParallelPath(data: ExecutionContextData, deps: ResolvedExecuto
 					...(behaviorOverrides[i]?.outputMode !== undefined ? { outputMode: behaviorOverrides[i]!.outputMode } : {}),
 					...(behaviorOverrides[i]?.reads !== undefined ? { reads: behaviorOverrides[i]!.reads } : {}),
 					...(progress !== undefined ? { progress } : {}),
-					...(t.acceptance !== undefined ? { acceptance: t.acceptance } : {}),
 				};
 			});
 			return deps.runtime.executeAsyncChain(id, {
@@ -2154,8 +2146,6 @@ async function runSinglePath(data: ExecutionContextData, deps: ResolvedExecutorD
 		preferredModelProvider: currentProvider,
 		currentModel: currentModelFullId(ctx.model),
 		skills: effectiveSkills,
-		acceptance: params.acceptance,
-		acceptanceContext: { mode: "single" },
 	});
 	if (foregroundControl?.currentIndex === 0) {
 		foregroundControl.interrupt = undefined;

package/dist/builtin/subagents/src/runs/shared/dynamic-fanout.ts

@@ -40,16 +40,17 @@ const SAFE_OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const ITEM_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const ITEM_REF_PATTERN = /\{([A-Za-z_][A-Za-z0-9_]*)(?:\.([^{}]+))?\}/g;
 const RESERVED_TEMPLATE_NAMES = new Set(["task", "previous", "chain_dir", "outputs"]);
-const DYNAMIC_STEP_KEYS = new Set(["expand", "parallel", "collect", "concurrency", "failFast", "phase", "label", "acceptance"]);
-const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance"]);
+const DYNAMIC_STEP_KEYS = new Set(["expand", "parallel", "collect", "concurrency", "failFast", "phase", "label"]);
+const RUNNER_DYNAMIC_STEP_KEYS = new Set(DYNAMIC_STEP_KEYS);
+const REMOVED_LEGACY_DYNAMIC_KEYS = new Set(["acceptance"]);
 const DYNAMIC_EXPAND_KEYS = new Set(["from", "item", "key", "maxItems", "onEmpty"]);
 const DYNAMIC_EXPAND_FROM_KEYS = new Set(["output", "path"]);
-const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "acceptance"]);
+const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model"]);
 const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
 	...DYNAMIC_PARALLEL_KEYS,
 	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "maxSubagentDepth",
-	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "mcpDirectTools", "completionGuard", "systemPrompt",
-	"systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance",
+	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "mcpDirectTools", "systemPrompt",
+	"systemPromptMode", "thinking", "modelCandidates", "sessionFile",
 ]);
 const DYNAMIC_COLLECT_KEYS = new Set(["as", "outputSchema"]);
 
@@ -146,10 +147,16 @@ export function resolveItemTemplate(template: string, itemName: string, item: un
 function assertOnlyKeys(value: unknown, allowed: Set<string>, label: string): void {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new DynamicFanoutError(`${label} must be an object.`);
 	for (const key of Object.keys(value)) {
+		if (REMOVED_LEGACY_DYNAMIC_KEYS.has(key)) continue;
 		if (!allowed.has(key)) throw new DynamicFanoutError(`${label} does not support field '${key}'.`);
 	}
 }
 
+function stripRemovedLegacyDynamicKeys<T extends object>(value: T): T {
+	const entries = Object.entries(value).filter(([key]) => !REMOVED_LEGACY_DYNAMIC_KEYS.has(key));
+	return entries.length === Object.keys(value).length ? value : Object.fromEntries(entries) as T;
+}
+
 export function assertNoUnresolvedItemReferences(template: string, itemName: string, label: string): void {
 	for (const match of template.matchAll(/\{([^{}]*)\}/g)) {
 		const raw = match[0]!;
@@ -247,11 +254,12 @@ export function materializeDynamicParallelStep(step: DynamicParallelStep, output
 		return { items, parallel: [], collectedOnEmpty: [] };
 	}
 	const itemName = step.expand.item ?? "item";
+	const parallelTemplate = stripRemovedLegacyDynamicKeys(step.parallel);
 	const parallel = items.map((entry) => {
-		const task = resolveItemTemplate(step.parallel.task ?? "{previous}", itemName, entry.item);
-		const label = step.parallel.label ? resolveItemTemplate(step.parallel.label, itemName, entry.item) : undefined;
+		const task = resolveItemTemplate(parallelTemplate.task ?? "{previous}", itemName, entry.item);
+		const label = parallelTemplate.label ? resolveItemTemplate(parallelTemplate.label, itemName, entry.item) : undefined;
 		return {
-			...step.parallel,
+			...parallelTemplate,
 			task,
 			...(label !== undefined ? { label } : {}),
 		};

package/dist/builtin/subagents/src/runs/shared/model-fallback.ts

@@ -100,7 +100,6 @@ const NON_RETRYABLE_FAILURE_PATTERNS: readonly RegExp[] = [
 	/shell/i,
 	/missing file/i,
 	/no such file/i,
-	/completion guard/i,
 	/cancel/i,
 	/abort/i,
 	/interrupted/i,

package/dist/builtin/subagents/src/runs/shared/parallel-utils.ts

@@ -18,7 +18,6 @@ export interface RunnerSubagentStep {
 	tools?: string[];
 	extensions?: string[];
 	mcpDirectTools?: string[];
-	completionGuard?: boolean;
 	systemPrompt?: string | null;
 	systemPromptMode?: "append" | "replace";
 	inheritProjectContext: boolean;
@@ -35,7 +34,6 @@ export interface RunnerSubagentStep {
 		outputPath: string;
 	};
 	structuredOutputSchema?: import("../../shared/types.ts").JsonSchemaObject;
-	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
 }
 
 export interface ParallelStepGroup {
@@ -53,7 +51,6 @@ export interface DynamicRunnerGroup {
 	failFast?: boolean;
 	phase?: string;
 	label?: string;
-	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
 }
 
 export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup;

package/dist/builtin/subagents/src/runs/shared/structured-output.ts

@@ -3,11 +3,15 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { APP_NAME } from "@bastani/atomic";
 import { Compile } from "typebox/compile";
+import type { Message } from "@earendil-works/pi-ai";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 
 const ENV_PREFIX = APP_NAME.toUpperCase();
 export const STRUCTURED_OUTPUT_SCHEMA_ENV = `${ENV_PREFIX}_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA`;
 export const STRUCTURED_OUTPUT_CAPTURE_ENV = `${ENV_PREFIX}_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE`;
+export const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
+export const STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS = 3;
+export const STRUCTURED_OUTPUT_MISSING_ERROR = "Missing structured_output call; this step has outputSchema and must finish by calling structured_output.";
 
 export interface StructuredOutputRuntime {
 	schema: JsonSchemaObject;
@@ -50,12 +54,73 @@ export function validateStructuredOutputValue(schema: JsonSchemaObject, value: u
 	}
 }
 
+function textFromContent(content: unknown): string | undefined {
+	if (!Array.isArray(content)) return undefined;
+	const text = content
+		.map((block) => {
+			if (!block || typeof block !== "object") return "";
+			const record = block as { readonly type?: unknown; readonly text?: unknown };
+			return record.type === "text" && typeof record.text === "string" ? record.text : "";
+		})
+		.join("\n")
+		.trim();
+	return text.length > 0 ? text : undefined;
+}
+
+export function latestStructuredOutputToolErrorFromMessages(messages: readonly Message[] | undefined): string | undefined {
+	if (!messages) return undefined;
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message?.role !== "toolResult") continue;
+		if (message.toolName !== STRUCTURED_OUTPUT_TOOL_NAME) continue;
+		if (message.isError !== true) continue;
+		return textFromContent(message.content) ?? "structured_output tool call failed schema validation.";
+	}
+	return undefined;
+}
+
+export function isStructuredOutputContractError(error: string | undefined): boolean {
+	if (error === undefined) return false;
+	return error === STRUCTURED_OUTPUT_MISSING_ERROR
+		|| error.startsWith("Structured output validation failed:")
+		|| error.startsWith("Failed to read structured output:");
+}
+
+export function formatStructuredOutputCorrectionPrompt(args: {
+	readonly originalTask: string;
+	readonly error: string;
+	readonly attempt: number;
+	readonly maxAttempts?: number;
+}): string {
+	const maxAttempts = args.maxAttempts ?? STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS;
+	return [
+		"The previous response failed this subagent's structured-output contract.",
+		"",
+		`Corrective attempt ${args.attempt}/${maxAttempts}.`,
+		"",
+		"Error:",
+		args.error,
+		"",
+		"You must finish by calling the `structured_output` tool exactly once with arguments matching the registered schema.",
+		"Do not answer with plain JSON text, Markdown, or prose. If you attempted `structured_output` and validation failed, correct the tool arguments and call `structured_output` again.",
+		"If the requested work is already complete, do not redo side effects unnecessarily; just report the completed result through `structured_output`.",
+		"",
+		"Original task:",
+		args.originalTask,
+	].join("\n");
+}
+
 export function readStructuredOutput(runtime: StructuredOutputRuntime): { value?: unknown; error?: string } {
 	if (!fs.existsSync(runtime.outputPath)) {
-		return { error: "Missing structured_output call; this step has outputSchema and must finish by calling structured_output." };
+		return { error: STRUCTURED_OUTPUT_MISSING_ERROR };
 	}
 	try {
-		return { value: JSON.parse(fs.readFileSync(runtime.outputPath, "utf-8")) as unknown };
+		const value = JSON.parse(fs.readFileSync(runtime.outputPath, "utf-8")) as unknown;
+		const validation = validateStructuredOutputValue(runtime.schema, value);
+		if (validation.status === "invalid") {
+			return { error: `Structured output validation failed: ${validation.message}` };
+		}
+		return { value };
 	} catch (error) {
 		return { error: `Failed to read structured output: ${error instanceof Error ? error.message : String(error)}` };
 	}