pi-subagents 0.27.0 → 0.29.0

package/src/runs/foreground/chain-execution.ts

@@ -59,12 +59,13 @@ import {
 	MAX_CONCURRENCY,
 	resolveChildMaxSubagentDepth,
 } from "../../shared/types.ts";
-import { resolveModelCandidate } from "../shared/model-fallback.ts";
+import { resolveSubagentModelOverride } from "../shared/model-fallback.ts";
 import { validateFileOnlyOutputMode } from "../shared/single-output.ts";
 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";
 
 interface ChainExecutionDetailsInput {
@@ -231,9 +232,12 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 			taskStr = prefix + taskStr + suffix;
 
 			const taskAgentConfig = input.agents.find((agent) => agent.name === task.agent);
-			const effectiveModel =
-				(task.model ? resolveModelCandidate(task.model, input.availableModels, input.ctx.model?.provider) : null)
-				?? resolveModelCandidate(taskAgentConfig?.model, input.availableModels, input.ctx.model?.provider);
+			const effectiveModel = resolveSubagentModelOverride(
+				task.model ?? taskAgentConfig?.model,
+				input.ctx.model,
+				input.availableModels,
+				input.ctx.model?.provider,
+			);
 			const maxSubagentDepth = resolveChildMaxSubagentDepth(input.maxSubagentDepth, taskAgentConfig?.maxSubagentDepth);
 
 			const taskCwd = input.worktreeSetup
@@ -750,11 +754,6 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				if (worktreeSetup) cleanupWorktrees(worktreeSetup);
 			}
 		} else if (isDynamicParallelStep(step)) {
-			if (Object.hasOwn(step, "acceptance")) {
-				const message = `Dynamic fanout step ${stepIndex + 1} does not support group-level acceptance; set acceptance on the child template instead.`;
-				dynamicGroupStatuses[stepIndex] = { status: "failed", error: message };
-				return buildChainExecutionErrorResult(message, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
-			}
 			let materialized: ReturnType<typeof materializeDynamicParallelStep>;
 			try {
 				materialized = materializeDynamicParallelStep(step, outputs, stepIndex, { maxItems: params.dynamicFanoutMaxItems });
@@ -788,6 +787,30 @@ 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;
 			}
@@ -919,6 +942,28 @@ 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,
@@ -974,10 +1019,13 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			const cleanTask = stepTask;
 			stepTask = prefix + stepTask + suffix;
 
-			const effectiveModel =
-				tuiOverride?.model
-				?? (seqStep.model ? resolveModelCandidate(seqStep.model, availableModels, ctx.model?.provider) : null)
-				?? resolveModelCandidate(agentConfig.model, availableModels, ctx.model?.provider);
+			const effectiveModel = tuiOverride?.model
+				?? resolveSubagentModelOverride(
+					seqStep.model ?? agentConfig.model,
+					ctx.model,
+					availableModels,
+					ctx.model?.provider,
+				);
 
 			const outputPath = typeof behavior.output === "string"
 				? (path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output))

package/src/runs/foreground/execution.ts

@@ -3,9 +3,7 @@
  */
 
 import { spawn } from "node:child_process";
-import { existsSync, mkdtempSync, unlinkSync } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
+import { existsSync, unlinkSync } from "node:fs";
 import type { Message } from "@earendil-works/pi-ai";
 import type { AgentConfig } from "../../agents/agents.ts";
 import {
@@ -15,13 +13,10 @@ import {
 	writeMetadata,
 } from "../../shared/artifacts.ts";
 import {
-	type AcceptanceFinalizationTurn,
-	type AcceptanceLedger,
 	type AgentProgress,
 	type ArtifactPaths,
 	type ControlEvent,
 	type ModelAttempt,
-	type ResolvedAcceptanceConfig,
 	type RunSyncOptions,
 	type SingleResult,
 	type Usage,
@@ -46,7 +41,7 @@ import {
 	extractTextFromContent,
 } from "../../shared/utils.ts";
 import { buildSkillInjection, resolveSkillsWithFallback } from "../../agents/skills.ts";
-import { evaluateCompletionMutationGuard, resolveCompletionPolicy, type CompletionPolicy } from "../shared/completion-guard.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";
@@ -69,20 +64,7 @@ import {
 	shouldEscalateMutatingFailures,
 	summarizeRecentMutatingFailures,
 } from "../shared/long-running-guard.ts";
-import {
-	acceptanceFailureMessage,
-	acceptanceSelfReviewConfig,
-	attachFinalizationToLedger,
-	buildFinalizationProcessFailureLedger,
-	createFinalizationProcessFailureTurn,
-	createFinalizationTurn,
-	evaluateAcceptance,
-	formatAcceptanceFinalizationPrompt,
-	formatAcceptancePrompt,
-	resolveEffectiveAcceptance,
-	shouldRunAcceptanceFinalization,
-	stripAcceptanceReport,
-} from "../shared/acceptance.ts";
+import { acceptanceFailureMessage, evaluateAcceptance, formatAcceptancePrompt, resolveEffectiveAcceptance, stripAcceptanceReport } from "../shared/acceptance.ts";
 
 const artifactOutputByResult = new WeakMap<SingleResult, string>();
 const acceptanceOutputByResult = new WeakMap<SingleResult, string>();
@@ -166,11 +148,10 @@ async function runSingleAttempt(
 		attemptNotes: string[];
 		outputSnapshot?: SingleOutputSnapshot;
 		originalTask?: string;
-		completionPolicy: CompletionPolicy;
 	},
 ): Promise<SingleResult> {
 	const modelArg = applyThinkingSuffix(model, agent.thinking);
-	const { args, env: sharedEnv, tempDir } = buildPiArgs({
+		const { args, env: sharedEnv, tempDir } = buildPiArgs({
 		baseArgs: ["--mode", "json", "-p"],
 		task,
 		sessionEnabled: shared.sessionEnabled,
@@ -194,10 +175,10 @@ async function runSingleAttempt(
 		childIndex: options.index ?? 0,
 		parentEventSink: options.nestedRoute?.eventSink,
 		parentControlInbox: options.nestedRoute?.controlInbox,
-		parentRootRunId: options.nestedRoute?.rootRunId,
-		parentCapabilityToken: options.nestedRoute?.capabilityToken,
-		structuredOutput: options.structuredOutput,
-	});
+			parentRootRunId: options.nestedRoute?.rootRunId,
+			parentCapabilityToken: options.nestedRoute?.capabilityToken,
+			structuredOutput: options.structuredOutput,
+		});
 
 	const result: SingleResult = {
 		agent: agent.name,
@@ -728,9 +709,9 @@ async function runSingleAttempt(
 		durationMs: progress.durationMs,
 	};
 
-	const acceptanceOutput = getFinalOutput(result.messages);
-	let fullOutput = stripAcceptanceReport(acceptanceOutput);
-	const completionGuard = result.exitCode === 0 && !result.error && shared.completionPolicy === "mutation-guard"
+		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,
@@ -739,8 +720,7 @@ async function runSingleAttempt(
 			mcpDirectTools: agent.mcpDirectTools,
 		})
 		: undefined;
-	const completionGuardTriggered = completionGuard?.triggered === true && !observedMutationAttempt;
-	if (completionGuardTriggered) {
+	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";
@@ -756,17 +736,17 @@ async function runSingleAttempt(
 			reason: "completion_guard",
 		}));
 	}
-	if (options.outputPath && result.exitCode === 0) {
-		const resolvedOutput = resolveSingleOutput(options.outputPath, fullOutput, shared.outputSnapshot);
-		fullOutput = stripAcceptanceReport(resolvedOutput.fullOutput);
-		result.savedOutputPath = resolvedOutput.savedPath;
-		result.outputSaveError = resolvedOutput.saveError;
-		if (resolvedOutput.savedPath) {
-			result.outputReference = formatSavedOutputReference(resolvedOutput.savedPath, fullOutput);
-		}
+		if (options.outputPath && result.exitCode === 0) {
+			const resolvedOutput = resolveSingleOutput(options.outputPath, fullOutput, shared.outputSnapshot);
+			fullOutput = stripAcceptanceReport(resolvedOutput.fullOutput);
+			result.savedOutputPath = resolvedOutput.savedPath;
+			result.outputSaveError = resolvedOutput.saveError;
+			if (resolvedOutput.savedPath) {
+				result.outputReference = formatSavedOutputReference(resolvedOutput.savedPath, fullOutput);
+			}
 	}
-	artifactOutputByResult.set(result, fullOutput);
-	acceptanceOutputByResult.set(result, acceptanceOutput);
+		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
@@ -789,99 +769,6 @@ async function runSingleAttempt(
 	return result;
 }
 
-async function runAcceptanceFinalizationLoop(input: {
-	runtimeCwd: string;
-	agent: AgentConfig;
-	result: SingleResult;
-	initialLedger: AcceptanceLedger;
-	initialOutput: string;
-	acceptance: ResolvedAcceptanceConfig;
-	options: RunSyncOptions;
-	systemPrompt: string;
-	resolvedSkillNames?: string[];
-	skillsWarning?: string;
-}): Promise<AcceptanceLedger> {
-	const sessionFile = input.result.sessionFile ?? input.options.sessionFile;
-	const maxTurns = input.acceptance.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 }));
-		return buildFinalizationProcessFailureLedger({ initialLedger: input.initialLedger, turns, maxTurns, message });
-	}
-
-	const selfReviewAcceptance = acceptanceSelfReviewConfig(input.acceptance);
-	let previousFailure = acceptanceFailureMessage(input.initialLedger);
-	let authoritativeLedger = input.initialLedger;
-	for (let turn = 1; turn <= maxTurns; turn++) {
-		const prompt = formatAcceptanceFinalizationPrompt({
-			acceptance: input.acceptance,
-			initialOutput: input.initialOutput,
-			initialLedger: input.initialLedger,
-			turn,
-			maxTurns,
-			...(previousFailure ? { previousFailure } : {}),
-		});
-		const finalizationOptions: RunSyncOptions = { ...input.options, sessionFile, outputMode: "inline" };
-		delete finalizationOptions.sessionDir;
-		delete finalizationOptions.outputPath;
-		delete finalizationOptions.structuredOutput;
-		delete finalizationOptions.onUpdate;
-		finalizationOptions.allowIntercomDetach = false;
-		const finalizationResult = await runSingleAttempt(
-			input.runtimeCwd,
-			input.agent,
-			prompt,
-			input.result.model,
-			finalizationOptions,
-			{
-				sessionEnabled: true,
-				systemPrompt: input.systemPrompt,
-				resolvedSkillNames: input.resolvedSkillNames,
-				skillsWarning: input.skillsWarning,
-				attemptNotes: [],
-				originalTask: prompt,
-				completionPolicy: "acceptance-contract",
-			},
-		);
-		sumUsage(input.result.usage, finalizationResult.usage);
-		input.result.progressSummary = {
-			toolCount: (input.result.progressSummary?.toolCount ?? 0) + (finalizationResult.progressSummary?.toolCount ?? 0),
-			tokens: input.result.usage.input + input.result.usage.output,
-			durationMs: (input.result.progressSummary?.durationMs ?? 0) + (finalizationResult.progressSummary?.durationMs ?? 0),
-		};
-		if (finalizationResult.controlEvents?.length) {
-			input.result.controlEvents = [...(input.result.controlEvents ?? []), ...finalizationResult.controlEvents];
-		}
-		const rawOutput = acceptanceOutputByResult.get(finalizationResult) ?? getFinalOutput(finalizationResult.messages) ?? finalizationResult.finalOutput ?? "";
-		if (finalizationResult.exitCode !== 0 || finalizationResult.error || finalizationResult.detached || finalizationResult.interrupted) {
-			const message = finalizationResult.error ?? "Acceptance finalization turn did not complete successfully.";
-			turns.push(createFinalizationProcessFailureTurn({ turn, prompt, rawOutput, message }));
-			return buildFinalizationProcessFailureLedger({ initialLedger: input.initialLedger, turns, maxTurns, message });
-		}
-		const selfReviewLedger = await evaluateAcceptance({
-			acceptance: selfReviewAcceptance,
-			output: rawOutput,
-			cwd: input.options.cwd ?? input.runtimeCwd,
-		});
-		authoritativeLedger = selfReviewLedger;
-		turns.push(createFinalizationTurn({ turn, prompt, rawOutput, ledger: selfReviewLedger }));
-		const failure = acceptanceFailureMessage(selfReviewLedger);
-		if (!failure) {
-			authoritativeLedger = input.acceptance === selfReviewAcceptance
-				? selfReviewLedger
-				: await evaluateAcceptance({
-					acceptance: input.acceptance,
-					output: rawOutput,
-					cwd: input.options.cwd ?? input.runtimeCwd,
-				});
-			return attachFinalizationToLedger({ initialLedger: input.initialLedger, authoritativeLedger, turns, status: "completed", maxTurns });
-		}
-		previousFailure = failure;
-	}
-	return attachFinalizationToLedger({ initialLedger: input.initialLedger, authoritativeLedger, turns, status: "failed", maxTurns });
-}
-
 /**
  * Run a subagent synchronously (blocking until complete)
  */
@@ -926,10 +813,6 @@ export async function runSync(
 		dynamic: options.acceptanceContext?.dynamic,
 		dynamicGroup: options.acceptanceContext?.dynamicGroup,
 	});
-	if (shouldRunAcceptanceFinalization(effectiveAcceptance) && !options.sessionFile) {
-		const sessionDir = options.sessionDir ?? mkdtempSync(path.join(os.tmpdir(), "pi-subagent-finalization-"));
-		options.sessionFile = path.join(sessionDir, "session.jsonl");
-	}
 	const acceptancePrompt = formatAcceptancePrompt(effectiveAcceptance);
 	const taskWithAcceptance = acceptancePrompt ? `${task}\n${acceptancePrompt}` : task;
 	const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
@@ -994,14 +877,6 @@ export async function runSync(
 			attemptNotes,
 			outputSnapshot,
 			originalTask: task,
-			completionPolicy: resolveCompletionPolicy({
-				agent: agent.name,
-				task,
-				completionGuardEnabled: agent.completionGuard !== false,
-				usesAcceptanceContract: effectiveAcceptance.explicit,
-				tools: agent.tools,
-				mcpDirectTools: agent.mcpDirectTools,
-			}),
 		});
 		lastResult = result;
 		sumUsage(aggregateUsage, result.usage);
@@ -1091,33 +966,14 @@ export async function runSync(
 		if (sessionFile) result.sessionFile = sessionFile;
 	}
 
-	const initialAcceptanceOutput = acceptanceOutputByResult.get(result) ?? result.finalOutput ?? "";
-	const acceptanceForInitialReport = shouldRunAcceptanceFinalization(effectiveAcceptance)
-		? acceptanceSelfReviewConfig(effectiveAcceptance)
-		: effectiveAcceptance;
-	const initialAcceptance = await evaluateAcceptance({
-		acceptance: acceptanceForInitialReport,
-		output: initialAcceptanceOutput,
-		cwd: options.cwd ?? runtimeCwd,
-	});
-	result.acceptance = initialAcceptance;
-	if (shouldRunAcceptanceFinalization(effectiveAcceptance) && result.exitCode === 0 && !result.detached && !result.interrupted) {
-		result.acceptance = await runAcceptanceFinalizationLoop({
-			runtimeCwd,
-			agent,
-			result,
-			initialLedger: initialAcceptance,
-			initialOutput: initialAcceptanceOutput,
+		result.acceptance = await evaluateAcceptance({
 			acceptance: effectiveAcceptance,
-			options,
-			systemPrompt,
-			resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
-			...(missingSkills.length > 0 ? { skillsWarning: `Skills not found: ${missingSkills.join(", ")}` } : {}),
+			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) {
+		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) {

package/src/runs/foreground/subagent-executor.ts

@@ -13,7 +13,7 @@ import { handleManagementAction } from "../../agents/agent-management.ts";
 import { buildDoctorReport } from "../../extension/doctor.ts";
 import { clearPendingForegroundControlNotices } from "../../extension/control-notices.ts";
 import { runSync } from "./execution.ts";
-import { resolveModelCandidate } from "../shared/model-fallback.ts";
+import { resolveModelCandidate, resolveSubagentModelOverride } from "../shared/model-fallback.ts";
 import { aggregateParallelOutputs } from "../shared/parallel-utils.ts";
 import { recordRun } from "../shared/run-history.ts";
 import {
@@ -53,7 +53,6 @@ import { resolveSubagentRunId, type ResolvedSubagentRunId } from "../background/
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { inspectSubagentStatus } from "../background/run-status.ts";
 import { applyForceTopLevelAsyncOverride } from "../background/top-level-async.ts";
-import { validateAcceptanceInput } from "../shared/acceptance.ts";
 import {
 	cleanupWorktrees,
 	createWorktrees,
@@ -650,6 +649,7 @@ async function resumeAsyncRun(input: {
 			cwd: input.requestCwd,
 			currentSessionId: input.deps.state.currentSessionId,
 			currentModelProvider: input.ctx.model?.provider,
+			currentModel: input.ctx.model,
 		},
 		cwd: effectiveCwd,
 		maxOutput: input.params.maxOutput,
@@ -691,6 +691,19 @@ function resultSummaryForIntercom(result: SingleResult): string {
 	return output || result.error || "(no output)";
 }
 
+function formatFailedSingleRunOutput(result: SingleResult, displayOutput: string): string {
+	const error = result.error || "Failed";
+	const output = displayOutput.trim();
+	const lines = [error];
+	if (output && output !== error.trim()) {
+		lines.push("", "Output:", output);
+	}
+	if (result.artifactPaths?.outputPath) {
+		lines.push("", `Output artifact: ${result.artifactPaths.outputPath}`);
+	}
+	return lines.join("\n");
+}
+
 function createForegroundControlNotifier(data: Pick<ExecutionContextData, "controlConfig" | "intercomBridge">, deps: Pick<ExecutorDeps, "pi">): (event: ControlEvent) => void {
 	return (event) => emitControlNotification({
 		pi: deps.pi,
@@ -761,36 +774,6 @@ async function maybeBuildForegroundIntercomReceipt(input: {
 	};
 }
 
-function validationErrorResult(mode: Details["mode"], text: string): AgentToolResult<Details> {
-	return { content: [{ type: "text", text }], isError: true, details: { mode, results: [] } };
-}
-
-function validateAcceptanceForExecution(params: SubagentParamsLike): AgentToolResult<Details> | null {
-	const topLevelErrors = validateAcceptanceInput(params.acceptance);
-	if (topLevelErrors.length > 0) return validationErrorResult("single", topLevelErrors.join(" "));
-	for (const [index, task] of (params.tasks ?? []).entries()) {
-		const errors = validateAcceptanceInput(task.acceptance, `tasks[${index}].acceptance`);
-		if (errors.length > 0) return validationErrorResult("parallel", errors.join(" "));
-	}
-	for (const [stepIndex, step] of (params.chain ?? []).entries()) {
-		if (isParallelStep(step)) {
-			if (Object.hasOwn(step, "acceptance")) return validationErrorResult("chain", `chain[${stepIndex}].acceptance is not supported on static parallel groups; set acceptance on each parallel task.`);
-			for (const [taskIndex, task] of step.parallel.entries()) {
-				const errors = validateAcceptanceInput(task.acceptance, `chain[${stepIndex}].parallel[${taskIndex}].acceptance`);
-				if (errors.length > 0) return validationErrorResult("chain", errors.join(" "));
-			}
-		} else if (isDynamicParallelStep(step)) {
-			if (Object.hasOwn(step, "acceptance")) return validationErrorResult("chain", `chain[${stepIndex}].acceptance is not supported on dynamic fanout groups; set acceptance on chain[${stepIndex}].parallel.acceptance for each materialized child.`);
-			const errors = validateAcceptanceInput(step.parallel.acceptance, `chain[${stepIndex}].parallel.acceptance`);
-			if (errors.length > 0) return validationErrorResult("chain", errors.join(" "));
-		} else {
-			const stepErrors = validateAcceptanceInput(step.acceptance, `chain[${stepIndex}].acceptance`);
-			if (stepErrors.length > 0) return validationErrorResult("chain", stepErrors.join(" "));
-		}
-	}
-	return null;
-}
-
 function validateExecutionInput(
 	params: SubagentParamsLike,
 	agents: AgentConfig[],
@@ -799,9 +782,6 @@ function validateExecutionInput(
 	hasSingle: boolean,
 	allowClarifyTaskPrompt: boolean,
 ): AgentToolResult<Details> | null {
-	const acceptanceError = validateAcceptanceForExecution(params);
-	if (acceptanceError) return acceptanceError;
-
 	if (Number(hasChain) + Number(hasTasks) + Number(hasSingle) !== 1) {
 		return {
 			content: [
@@ -1116,6 +1096,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 		cwd: ctx.cwd,
 		currentSessionId: deps.state.currentSessionId!,
 		currentModelProvider: ctx.model?.provider,
+		currentModel: ctx.model,
 	};
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
 	const currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth);
@@ -1126,7 +1107,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 	if (hasTasks && params.tasks) {
 		const agentConfigs = params.tasks.map((task) => agents.find((agent) => agent.name === task.agent));
 		const modelOverrides = params.tasks.map((task, index) =>
-			resolveModelCandidate(task.model ?? agentConfigs[index]?.model, availableModels, currentProvider),
+			resolveSubagentModelOverride(task.model ?? agentConfigs[index]?.model, ctx.model, availableModels, currentProvider),
 		);
 		const skillOverrides = params.tasks.map((task) => normalizeSkillInput(task.skill));
 		const parallelTasks = params.tasks.map((task, index) => ({
@@ -1213,7 +1194,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 		const normalizedSkills = normalizeSkillInput(params.skill);
 		const skills = normalizedSkills === false ? [] : normalizedSkills;
 		const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, a.maxSubagentDepth);
-		const modelOverride = resolveModelCandidate((params.model as string | undefined) ?? a.model, availableModels, currentProvider);
+		const modelOverride = resolveSubagentModelOverride((params.model as string | undefined) ?? a.model, ctx.model, availableModels, currentProvider);
 		return executeAsyncSingle(id, {
 			agent: params.agent!,
 			task: params.context === "fork" ? wrapForkTask(params.task ?? "") : (params.task ?? ""),
@@ -1314,6 +1295,7 @@ async function runChainPath(data: ExecutionContextData, deps: ExecutorDeps): Pro
 			cwd: ctx.cwd,
 			currentSessionId: deps.state.currentSessionId!,
 			currentModelProvider: ctx.model?.provider,
+			currentModel: ctx.model,
 		};
 		const asyncChain = wrapChainTasksForFork(chainResult.requestedAsync.chain, params.context);
 		return executeAsyncChain(id, {
@@ -1669,7 +1651,7 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 		...(task.model ? { model: task.model } : {}),
 	}));
 	const modelOverrides: (string | undefined)[] = tasks.map((_, i) =>
-		resolveModelCandidate(behaviorOverrides[i]?.model ?? agentConfigs[i]?.model, availableModels, currentProvider),
+		resolveSubagentModelOverride(behaviorOverrides[i]?.model ?? agentConfigs[i]?.model, ctx.model, availableModels, currentProvider),
 	);
 
 	if (params.clarify === true && ctx.hasUI) {
@@ -1730,6 +1712,7 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 				cwd: ctx.cwd,
 				currentSessionId: deps.state.currentSessionId!,
 				currentModelProvider: ctx.model?.provider,
+				currentModel: ctx.model,
 			};
 			const parallelTasks = tasks.map((t, i) => {
 				const taskText = params.context === "fork" ? wrapForkTask(taskTexts[i]!) : taskTexts[i]!;
@@ -1952,8 +1935,9 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 	const currentProvider = ctx.model?.provider;
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
 	let task = params.task ?? "";
-	let modelOverride: string | undefined = resolveModelCandidate(
+	let modelOverride: string | undefined = resolveSubagentModelOverride(
 		(params.model as string | undefined) ?? agentConfig.model,
+		ctx.model,
 		availableModels,
 		currentProvider,
 	);
@@ -2010,6 +1994,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 				cwd: ctx.cwd,
 				currentSessionId: deps.state.currentSessionId!,
 				currentModelProvider: ctx.model?.provider,
+				currentModel: ctx.model,
 			};
 			return executeAsyncSingle(id, {
 				agent: params.agent!,
@@ -2194,7 +2179,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 
 	if (r.exitCode !== 0)
 		return {
-			content: [{ type: "text", text: r.error || "Failed" }],
+			content: [{ type: "text", text: formatFailedSingleRunOutput(r, finalizedOutput.displayOutput) }],
 			details,
 			isError: true,
 		};