pi-subagents 0.27.0 → 0.29.0

package/src/agents/chain-serializer.ts

@@ -4,6 +4,7 @@ import { parseFrontmatter } from "./frontmatter.ts";
 import { ChainOutputValidationError, validateChainOutputBindings } from "../runs/shared/chain-outputs.ts";
 import { validateAcceptanceInput } from "../runs/shared/acceptance.ts";
 import type { ChainStep } from "../shared/settings.ts";
+import type { AgentSource } from "./agents.ts";
 
 function parseStepBody(agent: string, sectionBody: string): ChainStepConfig {
 	const lines = sectionBody.split("\n");
@@ -83,7 +84,7 @@ function parseStepBody(agent: string, sectionBody: string): ChainStepConfig {
 	return step;
 }
 
-export function parseChain(content: string, source: "user" | "project", filePath: string): ChainConfig {
+export function parseChain(content: string, source: AgentSource, filePath: string): ChainConfig {
 	const { frontmatter, body } = parseFrontmatter(content);
 	if (!frontmatter.name || !frontmatter.description) {
 		throw new Error("Chain frontmatter must include name and description");
@@ -124,7 +125,7 @@ export function parseChain(content: string, source: "user" | "project", filePath
 	};
 }
 
-export function parseJsonChain(content: string, source: "user" | "project", filePath: string): ChainConfig {
+export function parseJsonChain(content: string, source: AgentSource, filePath: string): ChainConfig {
 	let parsed: unknown;
 	try {
 		parsed = JSON.parse(content);
@@ -151,17 +152,11 @@ export function parseJsonChain(content: string, source: "user" | "project", file
 			throw new Error(`JSON chain '${filePath}' step ${i + 1} must be an object.`);
 		}
 		const stepRecord = step as Record<string, unknown>;
-		const parallel = stepRecord.parallel;
-		if (Array.isArray(parallel) && Object.hasOwn(stepRecord, "acceptance")) {
-			throw new Error(`Invalid JSON chain '${filePath}': step ${i + 1} acceptance is not supported on static parallel groups; set acceptance on each parallel task.`);
-		}
-		if (parallel && typeof parallel === "object" && !Array.isArray(parallel) && Object.hasOwn(stepRecord, "acceptance")) {
-			throw new Error(`Invalid JSON chain '${filePath}': step ${i + 1} acceptance is not supported on dynamic fanout groups; set acceptance on the dynamic template.`);
-		}
 		const acceptanceErrors = validateAcceptanceInput(stepRecord.acceptance, `step ${i + 1} acceptance`);
 		if (acceptanceErrors.length > 0) {
 			throw new Error(`Invalid JSON chain '${filePath}': ${acceptanceErrors.join(" ")}`);
 		}
+		const parallel = stepRecord.parallel;
 		if (Array.isArray(parallel)) {
 			for (let taskIndex = 0; taskIndex < parallel.length; taskIndex++) {
 				const task = parallel[taskIndex];

package/src/extension/doctor.ts

@@ -81,7 +81,7 @@ function formatExistingDirectory(label: string, dirPath: string): string {
 }
 
 function formatSourceCounts(counts: Record<AgentSource, number>): string {
-	return `builtin ${counts.builtin}, user ${counts.user}, project ${counts.project}`;
+	return `builtin ${counts.builtin}, package ${counts.package}, user ${counts.user}, project ${counts.project}`;
 }
 
 function formatSkillSourceCounts(skills: Array<{ source: SkillSource }>): string {
@@ -132,15 +132,16 @@ function formatDiscovery(input: DoctorReportInput, deps: DoctorDeps): string[] {
 			const discovered = deps.discoverAgentsAll(input.cwd);
 			const agentCounts = {
 				builtin: discovered.builtin.length,
+				package: discovered.package?.length ?? 0,
 				user: discovered.user.length,
 				project: discovered.project.length,
 			};
 			const chainCounts = discovered.chains.reduce<Record<AgentSource, number>>((counts, chain) => {
 				counts[chain.source] += 1;
 				return counts;
-			}, { builtin: 0, user: 0, project: 0 });
+			}, { builtin: 0, package: 0, user: 0, project: 0 });
 			return [
-				`- agents: total ${agentCounts.builtin + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
+				`- agents: total ${agentCounts.builtin + agentCounts.package + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
 				`- chains: total ${discovered.chains.length} (${formatSourceCounts(chainCounts)})`,
 			].join("\n");
 		}),

package/src/extension/fanout-child.ts

@@ -156,7 +156,6 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI):
 		label: "Subagent",
 		description: [
 			"Delegate to subagents from child-safe fanout mode.",
-			"For goal-style requests such as /goal, goal, active goal, or work until evidence says done, use explicit acceptance on the delegated run: criteria for the target, evidence/verify for proof, stopRules for constraints, and maxFinalizationTurns for the bounded loop.",
 			"Allowed management/control actions: list, get, status, interrupt, resume, doctor.",
 			"Agent config mutation actions create, update, and delete are blocked in this mode.",
 		].join("\n"),

package/src/extension/index.ts

@@ -33,8 +33,7 @@ import { registerSlashSubagentBridge } from "../slash/slash-bridge.ts";
 import { clearSlashSnapshots, getSlashRenderableSnapshot, resolveSlashMessageDetails, restoreSlashFinalSnapshots, type SlashMessageDetails } from "../slash/slash-live-state.ts";
 import { inspectSubagentStatus } from "../runs/background/run-status.ts";
 import registerSubagentNotify, { type SubagentNotifyDetails } from "../runs/background/notify.ts";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
-import registerFanoutChildSubagentExtension from "./fanout-child.ts";
+import { SUBAGENT_CHILD_ENV } from "../runs/shared/pi-args.ts";
 import { formatDuration, shortenPath } from "../shared/formatters.ts";
 import { loadConfig } from "./config.ts";
 import {
@@ -209,7 +208,6 @@ class SubagentControlNoticeComponent implements Component {
 
 export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	if (process.env[SUBAGENT_CHILD_ENV] === "1") {
-		if (process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1") registerFanoutChildSubagentExtension(pi);
 		return;
 	}
 	const globalStore = globalThis as Record<string, unknown>;
@@ -395,7 +393,6 @@ EXECUTION (use exactly ONE mode):
 • CHAIN: { chain: [{agent:"agent-a"}, {parallel:[{agent:"agent-b",count:3}]}] } - sequential pipeline with optional parallel fan-out
 • PARALLEL: { tasks: [{agent,task,count?,output?,reads?,progress?}, ...], concurrency?: number, worktree?: true } - concurrent execution (worktree: isolate each task in a git worktree)
 • Optional context: { context: "fresh" | "fork" } (default: if any requested agent has defaultContext: "fork", the whole invocation uses fork; otherwise "fresh"; inspect agent defaults via { action: "list" })
-• Goal-style requests: when the user says “/goal”, “goal”, “active goal”, “work until evidence says done”, or “verify against a goal”, model that as explicit acceptance. Use acceptance.criteria for the target, acceptance.evidence/verify for proof, acceptance.stopRules for constraints, and acceptance.maxFinalizationTurns for the bounded loop.
 
 CHAIN TEMPLATE VARIABLES (use in task strings):
 • {task} - The original task/request from the user

package/src/extension/schemas.ts

@@ -78,39 +78,42 @@ const AcceptanceReviewGateSchema = Type.Object({
 }, { additionalProperties: false });
 
 const AcceptanceOverride = Type.Unsafe({
-	type: "object",
-	properties: {
-		criteria: {
-			type: "array",
-			items: {
-				anyOf: [
-					{ type: "string" },
-					AcceptanceGateSchema,
-				],
+	anyOf: [
+		{ type: "string", enum: ["auto", "none", "attested", "checked", "verified", "reviewed"] },
+		{ const: false },
+		{
+			type: "object",
+			properties: {
+				level: { type: "string", enum: ["auto", "none", "attested", "checked", "verified", "reviewed"] },
+				criteria: {
+					type: "array",
+					items: {
+						anyOf: [
+							{ type: "string" },
+							AcceptanceGateSchema,
+						],
+					},
+				},
+				evidence: { type: "array", items: AcceptanceEvidenceKind },
+				verify: { type: "array", items: AcceptanceVerifyCommandSchema },
+				review: {
+					anyOf: [
+						{ const: false },
+						AcceptanceReviewGateSchema,
+					],
+				},
+				stopRules: { type: "array", items: { type: "string" } },
+				reason: { type: "string" },
 			},
+			additionalProperties: false,
 		},
-		evidence: { type: "array", items: AcceptanceEvidenceKind },
-		verify: { type: "array", items: AcceptanceVerifyCommandSchema },
-		review: AcceptanceReviewGateSchema,
-		stopRules: { type: "array", items: { type: "string" } },
-		maxFinalizationTurns: { type: "integer", minimum: 1, maximum: 10 },
-	},
-	additionalProperties: false,
-	allOf: [{
-		anyOf: [
-			{ required: ["criteria"] },
-			{ required: ["evidence"] },
-			{ required: ["verify"] },
-			{ required: ["review"] },
-			{ required: ["stopRules"] },
-		],
-	}],
-	description: "Optional acceptance contract. Use this for goal-style requests such as /goal, goal, active goal, or work until evidence says done: criteria define the target, evidence/verify define proof, stopRules define constraints, and maxFinalizationTurns defines the bounded loop. When present, the child must complete a same-session self-review/repair loop before acceptance is evaluated.",
+	],
+	description: "Optional acceptance policy. Omitted means auto-inferred; verified requires configured runtime commands.",
 });
 
 const TaskItem = Type.Object({
-	agent: Type.String(),
-	task: Type.String(),
+	agent: Type.String(), 
+	task: Type.String(), 
 	cwd: Type.Optional(Type.String()),
 	count: Type.Optional(Type.Integer({ minimum: 1, description: "Repeat this parallel task N times with the same settings." })),
 	output: Type.Optional(OutputOverride),

package/src/intercom/intercom-bridge.ts

@@ -17,6 +17,16 @@ function defaultIntercomExtensionDir(agentDir = defaultAgentDir()): string {
 	return path.join(agentDir, "extensions", PI_INTERCOM_PACKAGE_NAME);
 }
 
+export const INTERCOM_EXTENSION_DIR_ENV = "PI_INTERCOM_EXTENSION_DIR";
+
+// Launcher-provided override for the pi-intercom package directory. Lets a hermetic
+// wrapper point the subagent intercom bridge at a read-only install (e.g. a Nix-store
+// path) instead of seeding the package into the writable agent dir.
+function envIntercomExtensionDir(): string | undefined {
+	const dir = process.env[INTERCOM_EXTENSION_DIR_ENV]?.trim();
+	return dir ? dir : undefined;
+}
+
 function defaultIntercomConfigPath(agentDir = defaultAgentDir()): string {
 	return path.join(agentDir, "intercom", "config.json");
 }
@@ -224,7 +234,7 @@ function configuredPiIntercomPackageDir(input: ResolveIntercomBridgeInput, agent
 }
 
 function resolveIntercomExtensionDir(input: ResolveIntercomBridgeInput, agentDir: string): string {
-	const legacyDir = path.resolve(input.extensionDir ?? defaultIntercomExtensionDir(agentDir));
+	const legacyDir = path.resolve(input.extensionDir ?? envIntercomExtensionDir() ?? defaultIntercomExtensionDir(agentDir));
 	if (fs.existsSync(legacyDir)) return legacyDir;
 	return configuredPiIntercomPackageDir(input, agentDir) ?? legacyDir;
 }

package/src/runs/background/async-execution.ts

@@ -17,7 +17,7 @@ import type { RunnerStep } from "../shared/parallel-utils.ts";
 import { resolvePiPackageRoot } from "../shared/pi-spawn.ts";
 import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../../agents/skills.ts";
 import { resolveChildCwd } from "../../shared/utils.ts";
-import { buildModelCandidates, resolveModelCandidate, type AvailableModelInfo } from "../shared/model-fallback.ts";
+import { buildModelCandidates, resolveModelCandidate, resolveSubagentModelOverride, type AvailableModelInfo, type ParentModel } from "../shared/model-fallback.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { resolveExpectedWorktreeAgentCwd } from "../shared/worktree.ts";
 import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.ts";
@@ -95,6 +95,7 @@ interface AsyncExecutionContext {
 	cwd: string;
 	currentSessionId: string;
 	currentModelProvider?: string;
+	currentModel?: ParentModel;
 }
 
 interface AsyncChainParams {
@@ -342,7 +343,8 @@ export function executeAsyncChain(
 		taskTemplate = taskTemplate.replace(/\{chain_dir\}/g, runnerCwd);
 		const task = injectSingleOutputInstruction(`${readInstructions.prefix}${taskTemplate}${progressInstructions.suffix}`, outputPath);
 
-		const primaryModel = resolveModelCandidate(behavior.model ?? a.model, availableModels, ctx.currentModelProvider);
+		const requestedModel = behavior.model ?? a.model;
+		const primaryModel = resolveSubagentModelOverride(requestedModel, ctx.currentModel, availableModels, ctx.currentModelProvider);
 		const model = applyThinkingSuffix(primaryModel, a.thinking);
 		return {
 			agent: s.agent,
@@ -354,7 +356,7 @@ export function executeAsyncChain(
 			cwd: stepCwd,
 			model,
 			thinking: resolveEffectiveThinking(model, a.thinking),
-			modelCandidates: buildModelCandidates(behavior.model ?? a.model, a.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
+			modelCandidates: buildModelCandidates(primaryModel, a.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
 				applyThinkingSuffix(candidate, a.thinking),
 			),
 			tools: a.tools,
@@ -436,6 +438,14 @@ export function executeAsyncChain(
 					failFast: s.failFast,
 					phase: s.phase,
 					label: s.label,
+					effectiveAcceptance: resolveEffectiveAcceptance({
+						explicit: s.acceptance,
+						agentName: s.parallel.agent,
+						task: s.parallel.task,
+						mode: resultMode,
+						async: true,
+						dynamicGroup: true,
+					}),
 				};
 			}
 			return buildSeqStep(s as SequentialStep, nextSessionFile());
@@ -657,10 +667,13 @@ export function executeAsyncSingle(
 	const validationError = validateFileOnlyOutputMode(outputMode, outputPath, `Async single run (${agent})`);
 	if (validationError) return formatAsyncStartError("single", validationError);
 	const taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath);
-	const model = applyThinkingSuffix(
-		resolveModelCandidate(params.modelOverride ?? agentConfig.model, availableModels, ctx.currentModelProvider),
-		agentConfig.thinking,
+	const primaryModel = resolveSubagentModelOverride(
+		params.modelOverride ?? agentConfig.model,
+		ctx.currentModel,
+		availableModels,
+		ctx.currentModelProvider,
 	);
+	const model = applyThinkingSuffix(primaryModel, agentConfig.thinking);
 	let spawnResult: { pid?: number; error?: string } = {};
 	try {
 		spawnResult = spawnRunner(
@@ -673,7 +686,7 @@ export function executeAsyncSingle(
 						cwd: runnerCwd,
 						model,
 						thinking: resolveEffectiveThinking(model, agentConfig.thinking),
-						modelCandidates: buildModelCandidates(params.modelOverride ?? agentConfig.model, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
+						modelCandidates: buildModelCandidates(primaryModel, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
 							applyThinkingSuffix(candidate, agentConfig.thinking),
 						),
 						tools: agentConfig.tools,

package/src/runs/background/run-status.ts

@@ -49,11 +49,6 @@ function formatResumeGuidance(runId: string | undefined, children: Array<{ agent
 	return "Resume: unavailable; no child session file was persisted.";
 }
 
-function formatAcceptanceFinalizationSummary(finalization: NonNullable<NonNullable<AsyncStatus["steps"]>[number]["acceptance"]>["finalization"] | undefined): string {
-	if (!finalization) return "";
-	return `, finalization: ${finalization.status} after ${finalization.turns.length}/${finalization.maxTurns} turns`;
-}
-
 function stepLineLabel(status: AsyncStatus, index: number): string {
 	const steps = status.steps ?? [];
 	if (status.mode === "parallel") return `Agent ${index + 1}/${steps.length || 1}`;
@@ -222,8 +217,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				const modelThinking = formatModelThinking(step.model, step.thinking);
 				const modelText = modelThinking ? ` (${modelThinking})` : "";
 				const errorText = step.error ? `, error: ${step.error}` : "";
-				const finalizationText = formatAcceptanceFinalizationSummary(step.acceptance?.finalization);
-				const acceptanceText = step.acceptance?.status ? `, acceptance: ${step.acceptance.status}${finalizationText}` : "";
+				const acceptanceText = step.acceptance?.status ? `, acceptance: ${step.acceptance.status}` : "";
 				const display = step.label ? `${step.label} (${step.agent})` : step.agent;
 				const phase = step.phase ? `[${step.phase}] ` : "";
 				lines.push(`${stepLineLabel(status, index)}: ${phase}${display} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${acceptanceText}${errorText}`);

package/src/runs/background/subagent-runner.ts

@@ -8,8 +8,6 @@ import { appendJsonl, getArtifactPaths } from "../../shared/artifacts.ts";
 import { PI_CODING_AGENT_PACKAGE, getPiSpawnCommand, resolveInstalledPiPackageRoot } from "../shared/pi-spawn.ts";
 import { captureSingleOutputSnapshot, finalizeSingleOutput, formatSavedOutputReference, resolveSingleOutput, type SingleOutputSnapshot } from "../shared/single-output.ts";
 import {
-	type AcceptanceFinalizationTurn,
-	type AcceptanceLedger,
 	type ActivityState,
 	type ArtifactConfig,
 	type ArtifactPaths,
@@ -20,7 +18,6 @@ import {
 	type NestedRouteInfo,
 	type ResolvedControlConfig,
 	type SubagentRunMode,
-	type TokenUsage,
 	type Usage,
 	type WorkflowGraphSnapshot,
 	DEFAULT_MAX_OUTPUT,
@@ -54,7 +51,7 @@ import { nestedSummaryFromAsyncStatus, writeNestedEvent } from "../shared/nested
 import { formatModelAttemptNote, isRetryableModelFailure } from "../shared/model-fallback.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
 import { detectSubagentError, extractTextFromContent, extractToolArgsPreview, getFinalOutput } from "../../shared/utils.ts";
-import { evaluateCompletionMutationGuard, resolveCompletionPolicy } from "../shared/completion-guard.ts";
+import { evaluateCompletionMutationGuard } from "../shared/completion-guard.ts";
 import {
 	createMutatingFailureState,
 	didMutatingToolFail,
@@ -67,6 +64,7 @@ import {
 	summarizeRecentMutatingFailures,
 } from "../shared/long-running-guard.ts";
 import { parseSessionTokens } from "../../shared/session-tokens.ts";
+import type { TokenUsage } from "../../shared/types.ts";
 import {
 	cleanupWorktrees,
 	createWorktrees,
@@ -79,19 +77,7 @@ import {
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { writeInitialProgressFile } from "../../shared/settings.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
-import {
-	acceptanceFailureMessage,
-	acceptanceSelfReviewConfig,
-	attachFinalizationToLedger,
-	buildFinalizationProcessFailureLedger,
-	createFinalizationProcessFailureTurn,
-	createFinalizationTurn,
-	evaluateAcceptance,
-	formatAcceptanceFinalizationPrompt,
-	formatAcceptancePrompt,
-	shouldRunAcceptanceFinalization,
-	stripAcceptanceReport,
-} from "../shared/acceptance.ts";
+import { acceptanceFailureMessage, aggregateAcceptanceReport, evaluateAcceptance, formatAcceptancePrompt, stripAcceptanceReport } from "../shared/acceptance.ts";
 
 interface SubagentRunConfig {
 	id: string;
@@ -139,7 +125,7 @@ interface StepResult {
 	structuredOutput?: unknown;
 	structuredOutputPath?: string;
 	structuredOutputSchemaPath?: string;
-	acceptance?: AcceptanceLedger;
+	acceptance?: import("../../shared/types.ts").AcceptanceLedger;
 }
 
 const ASYNC_INTERRUPT_SIGNAL: NodeJS.Signals = process.platform === "win32" ? "SIGBREAK" : "SIGUSR2";
@@ -613,7 +599,7 @@ async function runSingleStep(
 	structuredOutput?: unknown;
 	structuredOutputPath?: string;
 	structuredOutputSchemaPath?: string;
-	acceptance?: AcceptanceLedger;
+	acceptance?: import("../../shared/types.ts").AcceptanceLedger;
 }> {
 	const effectiveStructuredOutput = step.structuredOutput ?? (step.structuredOutputSchema
 		? createStructuredOutputRuntime(step.structuredOutputSchema, path.join(path.dirname(ctx.outputFile), "structured-output"))
@@ -716,15 +702,7 @@ async function runSingleStep(
 			if (structured.error) structuredError = structured.error;
 			else structuredOutput = structured.value;
 		}
-		const completionPolicy = resolveCompletionPolicy({
-			agent: step.agent,
-			task: taskForCompletionGuard,
-			completionGuardEnabled: step.completionGuard !== false,
-			usesAcceptanceContract: step.effectiveAcceptance?.explicit === true,
-			tools: step.tools,
-			mcpDirectTools: step.mcpDirectTools,
-		});
-		const completionGuard = run.exitCode === 0 && !run.error && !hiddenError?.hasError && completionPolicy === "mutation-guard"
+		const completionGuard = run.exitCode === 0 && !run.error && !hiddenError?.hasError && step.completionGuard !== false
 			? evaluateCompletionMutationGuard({
 				agent: step.agent,
 				task: taskForCompletionGuard,
@@ -737,7 +715,7 @@ async function runSingleStep(
 		const completionGuardError = completionGuardTriggered
 			? "Subagent completed without making edits for an implementation task.\nIt appears to have returned planning or scratchpad output instead of applying changes."
 			: undefined;
-		const effectiveExitCode = completionGuardError
+		const effectiveExitCode = completionGuardTriggered
 			? 1
 			: structuredError
 				? 1
@@ -765,7 +743,7 @@ async function runSingleStep(
 		completionGuardTriggeredFinal = completionGuardTriggered;
 		finalOutputSnapshot = outputSnapshot;
 		finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error, structuredOutput } as RunPiStreamingResult & { structuredOutput?: unknown };
-		if (attempt.success || completionGuardError) break;
+		if (attempt.success || completionGuardTriggered) break;
 		if (!isRetryableModelFailure(error) || index === candidates.length - 1) break;
 		attemptNotes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
 	}
@@ -778,12 +756,12 @@ async function runSingleStep(
 	const output = resolvedOutput.fullOutput;
 	const outputReference = resolvedOutput.savedPath ? formatSavedOutputReference(resolvedOutput.savedPath, output) : undefined;
 	let outputForSummary = output;
-	if (attemptNotes.length > 0) {
-		outputForSummary = `${attemptNotes.join("\n")}\n\n${outputForSummary}`.trim();
-	}
+		if (attemptNotes.length > 0) {
+			outputForSummary = `${attemptNotes.join("\n")}\n\n${outputForSummary}`.trim();
+		}
 	const outputForAcceptance = rawOutput;
-	const finalizedOutput = finalizeSingleOutput({
-		fullOutput: outputForSummary,
+		const finalizedOutput = finalizeSingleOutput({
+			fullOutput: outputForSummary,
 		outputPath: step.outputPath,
 		outputMode: step.outputMode,
 		exitCode: finalResult?.exitCode ?? 1,
@@ -792,115 +770,13 @@ async function runSingleStep(
 		saveError: resolvedOutput.saveError,
 	});
 	outputForSummary = finalizedOutput.displayOutput;
-	const acceptanceForInitialReport = step.effectiveAcceptance && shouldRunAcceptanceFinalization(step.effectiveAcceptance)
-		? acceptanceSelfReviewConfig(step.effectiveAcceptance)
-		: step.effectiveAcceptance;
-	let acceptance = acceptanceForInitialReport
-		? await evaluateAcceptance({
-			acceptance: acceptanceForInitialReport,
-			output: outputForAcceptance,
-			cwd: step.cwd ?? ctx.cwd,
-		})
+	const acceptance = step.effectiveAcceptance
+			? await evaluateAcceptance({
+				acceptance: step.effectiveAcceptance,
+				output: outputForAcceptance,
+				cwd: step.cwd ?? ctx.cwd,
+			})
 		: undefined;
-	if (acceptance && step.effectiveAcceptance && shouldRunAcceptanceFinalization(step.effectiveAcceptance) && (finalResult?.exitCode ?? 1) === 0 && !finalResult?.interrupted) {
-		const sessionFile = step.sessionFile ?? (sessionDir ? findLatestSessionFile(sessionDir) ?? undefined : undefined);
-		const maxTurns = step.effectiveAcceptance.finalization.maxTurns;
-		const turns: AcceptanceFinalizationTurn[] = [];
-		if (!sessionFile) {
-			const message = "Acceptance finalization requires a session file for same-session continuation.";
-			turns.push(createFinalizationProcessFailureTurn({ turn: 1, prompt: "", message }));
-			acceptance = buildFinalizationProcessFailureLedger({ initialLedger: acceptance, turns, maxTurns, message });
-		} else {
-			const selfReviewAcceptance = acceptanceSelfReviewConfig(step.effectiveAcceptance);
-			let previousFailure = acceptanceFailureMessage(acceptance);
-			let authoritativeLedger = acceptance;
-			for (let turn = 1; turn <= maxTurns; turn++) {
-				const prompt = formatAcceptanceFinalizationPrompt({
-					acceptance: step.effectiveAcceptance,
-					initialOutput: outputForAcceptance,
-					initialLedger: acceptance,
-					turn,
-					maxTurns,
-					...(previousFailure ? { previousFailure } : {}),
-				});
-				const { args, env, tempDir } = buildPiArgs({
-					baseArgs: ["--mode", "json", "-p"],
-					task: prompt,
-					sessionEnabled: true,
-					sessionFile,
-					model: finalResult?.model ?? step.model,
-					thinking: step.thinking,
-					inheritProjectContext: step.inheritProjectContext,
-					inheritSkills: step.inheritSkills,
-					tools: step.tools,
-					extensions: step.extensions,
-					systemPrompt: step.systemPrompt,
-					systemPromptMode: step.systemPromptMode,
-					mcpDirectTools: step.mcpDirectTools,
-					cwd: step.cwd ?? ctx.cwd,
-					promptFileStem: `${step.agent}-acceptance-finalization`,
-					intercomSessionName: ctx.childIntercomTarget,
-					orchestratorIntercomTarget: ctx.orchestratorIntercomTarget,
-					runId: ctx.id,
-					childAgentName: step.agent,
-					childIndex: ctx.flatIndex,
-					parentEventSink: ctx.nestedRoute?.eventSink,
-					parentControlInbox: ctx.nestedRoute?.controlInbox,
-					parentRootRunId: ctx.nestedRoute?.rootRunId,
-					parentCapabilityToken: ctx.nestedRoute?.capabilityToken,
-				});
-				ctx.onAttemptStart?.({ model: finalResult?.model ?? step.model, thinking: resolveEffectiveThinking(finalResult?.model ?? step.model, step.thinking) });
-				const finalizationRun = await runPiStreaming(
-					args,
-					step.cwd ?? ctx.cwd,
-					`${ctx.outputFile}.finalization-${turn}.log`,
-					env,
-					ctx.piPackageRoot,
-					ctx.piArgv1,
-					step.maxSubagentDepth,
-					{ eventsPath, runId: ctx.id, stepIndex: ctx.flatIndex, agent: step.agent },
-					ctx.registerInterrupt,
-					ctx.onChildEvent,
-				);
-				cleanupTempDir(tempDir);
-				modelAttempts.push({
-					model: finalResult?.model ?? finalizationRun.model ?? step.model ?? "default",
-					success: finalizationRun.exitCode === 0 && !finalizationRun.error,
-					exitCode: finalizationRun.exitCode,
-					error: finalizationRun.error,
-					usage: finalizationRun.usage,
-				});
-				const finalizationOutput = finalizationRun.finalOutput;
-				if (finalizationRun.exitCode !== 0 || finalizationRun.error || finalizationRun.interrupted) {
-					const message = finalizationRun.error ?? "Acceptance finalization turn did not complete successfully.";
-					turns.push(createFinalizationProcessFailureTurn({ turn, prompt, rawOutput: finalizationOutput, message }));
-					acceptance = buildFinalizationProcessFailureLedger({ initialLedger: acceptance, turns, maxTurns, message });
-					break;
-				}
-				const selfReviewLedger = await evaluateAcceptance({
-					acceptance: selfReviewAcceptance,
-					output: finalizationOutput,
-					cwd: step.cwd ?? ctx.cwd,
-				});
-				authoritativeLedger = selfReviewLedger;
-				turns.push(createFinalizationTurn({ turn, prompt, rawOutput: finalizationOutput, ledger: selfReviewLedger }));
-				const failure = acceptanceFailureMessage(selfReviewLedger);
-				if (!failure) {
-					authoritativeLedger = step.effectiveAcceptance === selfReviewAcceptance
-						? selfReviewLedger
-						: await evaluateAcceptance({
-							acceptance: step.effectiveAcceptance,
-							output: finalizationOutput,
-							cwd: step.cwd ?? ctx.cwd,
-						});
-					acceptance = attachFinalizationToLedger({ initialLedger: acceptance, authoritativeLedger, turns, status: "completed", maxTurns });
-					break;
-				}
-				previousFailure = failure;
-				if (turn === maxTurns) acceptance = attachFinalizationToLedger({ initialLedger: acceptance, authoritativeLedger, turns, status: "failed", maxTurns });
-			}
-		}
-	}
 	const acceptanceFailure = acceptance ? acceptanceFailureMessage(acceptance) : undefined;
 	const acceptanceCanFailRun = acceptanceFailure && acceptance?.explicit && (finalResult?.exitCode ?? 1) === 0 && !finalResult?.interrupted;
 	const effectiveFinalExitCode = acceptanceCanFailRun ? 1 : finalResult?.exitCode ?? 1;
@@ -1236,7 +1112,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 		writeAtomicJson(statusPath, statusPayload);
 		emitNestedSelfEvent(statusPayload.state === "running" || statusPayload.state === "queued" ? "subagent.nested.updated" : "subagent.nested.completed");
 	};
-	const markDynamicGraphGroup = (stepIndex: number, status: "completed" | "failed" | "running", error?: string, acceptance?: AcceptanceLedger): void => {
+	const markDynamicGraphGroup = (stepIndex: number, status: "completed" | "failed" | "running", error?: string, acceptance?: import("../../shared/types.ts").AcceptanceLedger): void => {
 		const groupNode = statusPayload.workflowGraph?.nodes.find((node) => node.id === `step-${stepIndex}`);
 		if (!groupNode) return;
 		groupNode.status = status;
@@ -1578,9 +1454,36 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 					placeholder.durationMs = 0;
 				}
 				previousOutput = "Dynamic fanout produced 0 results.";
+				const groupAcceptance = step.effectiveAcceptance?.explicit
+					? await evaluateAcceptance({
+						acceptance: step.effectiveAcceptance,
+						output: "",
+						report: aggregateAcceptanceReport({
+							results: [],
+							notes: "Dynamic fanout produced 0 results.",
+						}),
+						cwd,
+					})
+					: undefined;
+				if (placeholder && groupAcceptance) placeholder.acceptance = groupAcceptance;
+				const groupAcceptanceFailure = groupAcceptance ? acceptanceFailureMessage(groupAcceptance) : undefined;
+				if (groupAcceptanceFailure) {
+					statusPayload.state = "failed";
+					statusPayload.error = groupAcceptanceFailure;
+					if (placeholder) {
+						placeholder.status = "failed";
+						placeholder.error = groupAcceptanceFailure;
+						placeholder.exitCode = 1;
+					}
+					markDynamicGraphGroup(stepIndex, "failed", groupAcceptanceFailure, groupAcceptance);
+					statusPayload.lastUpdate = now;
+					writeStatusPayload();
+					results.push({ agent: step.parallel.agent, output: groupAcceptanceFailure, error: groupAcceptanceFailure, success: false, exitCode: 1, acceptance: groupAcceptance });
+					break;
+				}
 				flatIndex++;
 				statusPayload.lastUpdate = now;
-				markDynamicGraphGroup(stepIndex, "completed");
+				markDynamicGraphGroup(stepIndex, "completed", undefined, groupAcceptance);
 				writeStatusPayload();
 				continue;
 			}
@@ -1756,7 +1659,31 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						stepIndex,
 					};
 					statusPayload.outputs = outputs;
-					markDynamicGraphGroup(stepIndex, "completed");
+					const groupAcceptance = step.effectiveAcceptance
+						? await evaluateAcceptance({
+							acceptance: step.effectiveAcceptance,
+							output: "",
+							report: aggregateAcceptanceReport({
+								results: parallelResults,
+								notes: `Dynamic fanout collected ${collection.length} result(s) into ${step.collect.as}.`,
+							}),
+							cwd,
+						})
+						: undefined;
+					const groupAcceptanceFailure = groupAcceptance ? acceptanceFailureMessage(groupAcceptance) : undefined;
+					markDynamicGraphGroup(stepIndex, groupAcceptanceFailure ? "failed" : "completed", groupAcceptanceFailure, groupAcceptance);
+					if (groupAcceptanceFailure) {
+						results.push({
+							agent: step.parallel.agent,
+							output: groupAcceptanceFailure,
+							error: groupAcceptanceFailure,
+							success: false,
+							exitCode: 1,
+							structuredOutput: collection,
+							acceptance: groupAcceptance,
+						});
+						statusPayload.error = groupAcceptanceFailure;
+					}
 				} catch (error) {
 					const message = error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
 					results.push({ agent: step.parallel.agent, output: message, error: message, success: false, exitCode: 1, structuredOutput: collection });