pi-subagents 0.34.0 → 0.35.0

package/src/runs/foreground/async-steering-action.ts

@@ -0,0 +1,230 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import type { AsyncStatus, Details, SubagentState, ToolBudgetConfig, TurnBudgetConfig } from "../../shared/types.ts";
+import { readStatus } from "../../shared/utils.ts";
+import { consumeSteerAcks, deliverInterruptRequest, requestAsyncSteer } from "../background/control-channel.ts";
+import { resolveAsyncResumeTarget } from "../background/async-resume.ts";
+import { reconcileAsyncRun } from "../background/stale-run-reconciler.ts";
+import { actionResultFromSteeringStatus, claimSteeringRecovery, remainingSteeringRecoveryLimits, updateSteeringTarget, waitForSteeringAction } from "../background/steering.ts";
+
+export async function steerAsyncRun(input: {
+	state: SubagentState;
+	runId: string;
+	message: string;
+	index?: number;
+	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
+	location: { asyncDir: string | null };
+	signal?: AbortSignal;
+	ackTimeoutMs?: number;
+	recoveryTimeoutMs?: number;
+	onRequestQueued?: (requestPath: string) => void;
+	onBeforeRecoveryClaim?: (requestId: string, committedAt: number) => void;
+	onRecoveryCommitted?: (requestId: string, committedAt: number) => void;
+	recover?: (limits: { timeoutMs?: number; absoluteDeadlineAt?: number; turnBudget?: TurnBudgetConfig; toolBudget?: ToolBudgetConfig }) => Promise<AgentToolResult<Details>>;
+}): Promise<AgentToolResult<Details>> {
+	if (!input.location.asyncDir) {
+		return {
+			content: [{ type: "text", text: `Async run '${input.runId}' has no live run directory to steer.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	const asyncDir = input.location.asyncDir;
+	const status = reconcileAsyncRun(asyncDir, { kill: input.kill }).status;
+	if (input.state.currentSessionId && status?.sessionId !== input.state.currentSessionId) {
+		return {
+			content: [{ type: "text", text: `Async run '${input.runId}' was not found in the active session.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	if (!status || (status.state !== "running" && status.state !== "queued")) {
+		return {
+			content: [{ type: "text", text: `Async run '${input.runId}' is not running or queued and cannot be steered.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	const steps = status.steps ?? [];
+	if (input.index !== undefined) {
+		if (input.index < 0 || input.index >= steps.length) {
+			return {
+				content: [{ type: "text", text: `Async run '${status.runId}' has ${steps.length} children. Index ${input.index} is out of range.` }],
+				isError: true,
+				details: { mode: "management", results: [] },
+			};
+		}
+		const targetStep = steps[input.index];
+		if (targetStep && targetStep.status !== "running" && targetStep.status !== "pending") {
+			return {
+				content: [{ type: "text", text: `Async run '${status.runId}' child ${input.index} is ${targetStep.status} and cannot be steered.` }],
+				isError: true,
+				details: { mode: "management", results: [] },
+			};
+		}
+	} else {
+		const running = steps.filter((step) => step.status === "running");
+		if (running.length === 0 && steps.length > 1) {
+			return {
+				content: [{ type: "text", text: `Async run '${status.runId}' has no running child yet. Provide index to steer a queued child.` }],
+				isError: true,
+				details: { mode: "management", results: [] },
+			};
+		}
+	}
+	const runningIndexes = steps
+		.map((step, index) => step.status === "running" ? index : undefined)
+		.filter((index): index is number => index !== undefined);
+	const effectiveTargetIndex = input.index ?? (status.mode === "single" && runningIndexes.length === 0 && steps[0]?.status === "pending" ? 0 : undefined);
+	const targetIndexes = effectiveTargetIndex !== undefined ? [effectiveTargetIndex] : runningIndexes;
+	if (targetIndexes.length === 0) {
+		return {
+			content: [{ type: "text", text: `Async run '${status.runId}' has no running child to steer.` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	const requestId = randomUUID();
+	let requestPath: string;
+	try {
+		requestPath = requestAsyncSteer(asyncDir, {
+			message: input.message,
+			...(effectiveTargetIndex !== undefined ? { targetIndex: effectiveTargetIndex } : { targetIndexes }),
+			source: "steer-action",
+			id: requestId,
+		});
+	} catch (error) {
+		return {
+			content: [{ type: "text", text: `Failed to queue steering for async run ${status.runId}: ${error instanceof Error ? error.message : String(error)}` }],
+			isError: true,
+			details: { mode: "management", results: [] },
+		};
+	}
+	input.onRequestQueued?.(requestPath);
+	const tracked = input.state.asyncJobs.get(status.runId);
+	if (tracked) tracked.updatedAt = Date.now();
+	const targets = targetIndexes.map((index) => ({ index, state: status.steps?.[index]?.status === "pending" ? "scheduled" as const : "pending" as const }));
+	if (targets.every((target) => target.state === "scheduled")) {
+		const scheduled = { requestId, state: "scheduled" as const, sourceRunId: status.runId, targets };
+		return { content: [{ type: "text", text: `Steering scheduled for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: scheduled } };
+	}
+	const waited = await waitForSteeringAction({ asyncDir, sourceRunId: status.runId, requestId, timeoutMs: input.ackTimeoutMs ?? 3_000, signal: input.signal });
+	const result = waited ?? { requestId, state: "pending" as const, sourceRunId: status.runId, targets };
+	if (input.signal?.aborted) {
+		return { content: [{ type: "text", text: `Steering pending for async run ${status.runId} (request ${requestId}); caller aborted before recovery.` }], details: { mode: "management", results: [], steering: result } };
+	}
+	const finalStatus = readStatus(asyncDir);
+	const finalResult = finalStatus?.steering ? actionResultFromSteeringStatus(finalStatus.steering, status.runId, requestId) : undefined;
+	if (finalResult?.state === "delivered") {
+		return { content: [{ type: "text", text: `Steering delivered for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: finalResult } };
+	}
+	const running = (finalStatus?.steps ?? status.steps).filter((step) => step.status === "running");
+	const recoveryAllowed = status.mode === "single" && status.isNested !== true && running.length === 1 && Boolean(finalStatus?.steering) && (input.index === undefined || input.index === 0);
+	if (recoveryAllowed && finalResult?.state !== "scheduled" && input.recover) {
+		const appendSteeringNotice = (state: "failed" | "recovered", message: string): void => {
+			try {
+				fs.appendFileSync(path.join(asyncDir, "events.jsonl"), `${JSON.stringify({ type: "subagent.steering.notice", ts: Date.now(), runId: status.runId, requestId, state, message, ...(status.sessionId ? { currentSessionId: status.sessionId } : {}) })}\n`);
+			} catch {
+				// The action result and status remain authoritative if diagnostic notification persistence fails.
+			}
+		};
+		try {
+			const latest = readStatus(asyncDir);
+			const latestResult = latest?.steering ? actionResultFromSteeringStatus(latest.steering, status.runId, requestId) : undefined;
+			if (latestResult?.state === "delivered") return { content: [{ type: "text", text: `Steering delivered for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: latestResult } };
+			const committedAt = Date.now();
+			input.onBeforeRecoveryClaim?.(requestId, committedAt);
+			const { claimPath, markerPath } = claimSteeringRecovery(asyncDir, { requestId, sourceRunId: status.runId, committedAt });
+			input.onRecoveryCommitted?.(requestId, committedAt);
+			const preCommitStatus = readStatus(asyncDir);
+			const preCommitResult = preCommitStatus?.steering ? actionResultFromSteeringStatus(preCommitStatus.steering, status.runId, requestId) : undefined;
+			if (preCommitResult?.state === "delivered" && preCommitResult.targets.every((target) => target.deliveredAt !== undefined && target.deliveredAt <= committedAt)) {
+				fs.rmSync(markerPath, { force: true });
+				fs.rmSync(claimPath, { force: true });
+				return { content: [{ type: "text", text: `Steering delivered for async run ${status.runId} (request ${requestId}).` }], details: { mode: "management", results: [], steering: preCommitResult } };
+			}
+			try {
+				deliverInterruptRequest({ asyncDir, pid: latest?.pid ?? status.pid, kill: input.kill, source: "steering-recovery" });
+			} catch (error) {
+				fs.rmSync(markerPath, { force: true });
+				fs.rmSync(claimPath, { force: true });
+				throw new Error(`Failed to commit steering recovery interrupt: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			const pauseDeadline = Date.now() + (input.recoveryTimeoutMs ?? 15_000);
+			let paused: AsyncStatus | null = null;
+			while (Date.now() <= pauseDeadline) {
+				if (input.signal?.aborted) break;
+				const candidate = readStatus(asyncDir);
+				if (candidate?.state === "paused" && candidate.endedAt !== undefined) { paused = candidate; break; }
+				await new Promise<void>((resolve) => setTimeout(resolve, 50));
+			}
+			if (!paused) throw new Error("Source run did not reach confirmed paused state within 15 seconds; no replacement was launched and the recovery claim remains committed to prevent a delayed duplicate.");
+			let lateAckRecorded = false;
+			for (const ack of consumeSteerAcks(asyncDir)) {
+				if (!paused.steering?.recent.some((request) => request.id === ack.requestId && request.targets.some((target) => target.index === ack.index))) continue;
+				const state = ack.state === "delivered" ? "late" : "failed";
+				const reason = ack.state === "delivered" ? "acknowledged after recovery commit" : ack.message;
+				updateSteeringTarget(paused.steering, ack.requestId, ack.index, state, ack.ts, { reason });
+				const stepSteering = paused.steps?.[ack.index]?.steering;
+				if (stepSteering) updateSteeringTarget(stepSteering, ack.requestId, ack.index, state, ack.ts, { reason });
+				lateAckRecorded = true;
+				try {
+					fs.appendFileSync(path.join(asyncDir, "events.jsonl"), `${JSON.stringify({ type: ack.state === "delivered" ? "subagent.steer.delivered" : "subagent.steer.failed", ts: ack.ts, runId: status.runId, requestId: ack.requestId, index: ack.index, late: true, message: ack.message })}\n`);
+				} catch {
+					// Status remains authoritative when diagnostic event persistence fails.
+				}
+			}
+			if (lateAckRecorded) writeAtomicJson(path.join(asyncDir, "status.json"), paused);
+			let recoveryTarget;
+			try {
+				recoveryTarget = resolveAsyncResumeTarget(
+					{ id: status.runId },
+					{ kill: input.kill },
+					{ sessionId: input.state.currentSessionId ?? undefined },
+				);
+			} catch (error) {
+				throw new Error(`Source run remains paused and cannot be revived safely: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			if (recoveryTarget.kind !== "revive" || !recoveryTarget.sessionFile) throw new Error("Source run has no valid persisted child session; it remains paused and requires a new run.");
+			if (!recoveryTarget.recoveryDescriptor) throw new Error("Source run has no private recovery descriptor; it remains paused and is not safely resumable.");
+			const limits = remainingSteeringRecoveryLimits(recoveryTarget.recoveryDescriptor, paused);
+			const revived = await input.recover(limits);
+			if (revived.isError || !revived.details.asyncId) throw new Error(revived.content[0]?.type === "text" ? revived.content[0].text : "Replacement launch failed; source run remains paused.");
+			const sourceStatus = readStatus(asyncDir);
+			const targetIndex = input.index ?? status.steps.findIndex((step) => step.status === "running");
+			if (sourceStatus?.state === "paused" && sourceStatus.steering && targetIndex >= 0) {
+				updateSteeringTarget(sourceStatus.steering, requestId, targetIndex, "recovered", Date.now(), { replacementRunId: revived.details.asyncId });
+				const stepSteering = sourceStatus.steps?.[targetIndex]?.steering;
+				if (stepSteering) updateSteeringTarget(stepSteering, requestId, targetIndex, "recovered", Date.now(), { replacementRunId: revived.details.asyncId });
+				writeAtomicJson(path.join(asyncDir, "status.json"), sourceStatus);
+			}
+			const recovered = sourceStatus?.steering ? actionResultFromSteeringStatus(sourceStatus.steering, status.runId, requestId, revived.details.asyncId) : undefined;
+			appendSteeringNotice("recovered", `Steering recovered for run ${status.runId}; replacement ${revived.details.asyncId} launched.`);
+			return { content: [{ type: "text", text: `Steering recovered for async run ${status.runId}; replacement ${revived.details.asyncId} launched after the source paused.` }], details: { mode: "management", results: [], steering: recovered ?? { requestId, state: "recovered", sourceRunId: status.runId, replacementRunId: revived.details.asyncId, targets: [{ index: input.index ?? 0, state: "recovered" }] } } };
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			const failedStatus = readStatus(asyncDir);
+			const targetIndex = input.index ?? status.steps.findIndex((step) => step.status === "running");
+			if (failedStatus && failedStatus.state !== "running" && failedStatus.state !== "queued" && failedStatus.steering && targetIndex >= 0) {
+				updateSteeringTarget(failedStatus.steering, requestId, targetIndex, "failed", Date.now(), { reason });
+				const stepSteering = failedStatus.steps?.[targetIndex]?.steering;
+				if (stepSteering) updateSteeringTarget(stepSteering, requestId, targetIndex, "failed", Date.now(), { reason });
+				failedStatus.activityState = "needs_attention";
+				writeAtomicJson(path.join(asyncDir, "status.json"), failedStatus);
+			}
+			const failed = failedStatus?.steering ? actionResultFromSteeringStatus(failedStatus.steering, status.runId, requestId) : undefined;
+			appendSteeringNotice("failed", `Steering failed for run ${status.runId}: ${reason}`);
+			return { content: [{ type: "text", text: `Steering failed for async run ${status.runId} (request ${requestId}): ${reason}` }], isError: true, details: { mode: "management", results: [], steering: failed ?? { requestId, state: "failed", sourceRunId: status.runId, targets: [{ index: input.index ?? 0, state: "failed", reason }] } } };
+		}
+	}
+	const stateText = result.state === "delivered" ? "delivered" : result.state === "scheduled" ? "scheduled" : result.state === "recovered" ? "recovered" : result.state === "failed" ? "failed" : result.state === "partial" ? "partial" : "pending";
+	const isError = result.state === "failed" || result.state === "partial";
+	return {
+		content: [{ type: "text", text: `Steering ${stateText} for async run ${status.runId} (request ${requestId}).` }],
+		...(isError ? { isError: true } : {}),
+		details: { mode: "management", results: [], steering: result },
+	};
+}

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

@@ -1004,6 +1004,7 @@ export class ChainClarifyComponent implements Component {
 			"medium": "Moderate reasoning",
 			"high": "Deep reasoning",
 			"xhigh": "Maximum reasoning (ultrathink)",
+			"max": "Maximum available reasoning",
 		};
 
 		const levels = this.getAvailableThinkingLevels(this.editingStep!);
@@ -1102,18 +1103,29 @@ export class ChainClarifyComponent implements Component {
 		return lines;
 	}
 
-	private getFooterText(): string {
-		const bgLabel = this.runInBackground ? '[b]g:ON' : '[b]g';
+	private getShortcutHelpText(): string {
+		const th = this.theme;
+		const shortcut = (key: string, label: string) =>
+			th.fg("accent", `[${key}]`) + th.fg("dim", label);
+		const backgroundState = this.runInBackground ? "ON" : "OFF";
+		const background = shortcut("b", `Background:${backgroundState}`);
+
 		switch (this.mode) {
 			case 'single':
-				return ` [Enter] Run • [Esc] Cancel • e m t w s ${bgLabel} `;
+				return ` ${shortcut("e", "Task")} ${shortcut("m", "Model")} ${shortcut("t", "Think")} ${shortcut("w", "Output")} ${shortcut("s", "Skills")} ${background}`;
 			case 'parallel':
-				return ` [Enter] Run • [Esc] Cancel • e m t s ${bgLabel} • ↑↓ Nav `;
+				return ` ${shortcut("e", "Task")} ${shortcut("m", "Model")} ${shortcut("t", "Think")} ${shortcut("s", "Skills")} ${background}`;
 			case 'chain':
-				return ` [Enter] Run • [Esc] Cancel • e m t w r p s ${bgLabel} • ↑↓ Nav `;
+				return ` ${shortcut("e", "Task")} ${shortcut("m", "Model")} ${shortcut("t", "Think")} ${shortcut("w", "Output")} ${shortcut("r", "Reads")} ${shortcut("p", "Prog")} ${shortcut("s", "Skills")} ${background}`;
 		}
 	}
 
+	private getFooterText(): string {
+		return this.mode === 'single'
+			? " [Enter] Run • [Esc] Cancel "
+			: " [Enter] Run • [Esc] Cancel • [↑↓] Navigate ";
+	}
+
 	private appendNotice(lines: string[]): void {
 		if (!this.noticeMessage) return;
 		const color = this.noticeMessage.type === "error" ? "error" : "success";
@@ -1162,7 +1174,7 @@ export class ChainClarifyComponent implements Component {
 		const skillsLabel = th.fg("dim", "skills: ");
 		lines.push(this.row(`     ${skillsLabel}${truncateToWidth(skillsValue, innerW - 14)}`));
 
-		lines.push(this.row(""));
+		lines.push(this.row(this.getShortcutHelpText()));
 
 		this.appendNotice(lines);
 		lines.push(this.renderFooter(this.getFooterText()));
@@ -1216,6 +1228,8 @@ export class ChainClarifyComponent implements Component {
 			lines.push(this.row(""));
 		}
 
+		if (this.agentConfigs.length > 0) lines.pop();
+		lines.push(this.row(this.getShortcutHelpText()));
 		this.appendNotice(lines);
 		lines.push(this.renderFooter(this.getFooterText()));
 
@@ -1319,6 +1333,8 @@ export class ChainClarifyComponent implements Component {
 			lines.push(this.row(""));
 		}
 
+		if (this.agentConfigs.length > 0) lines.pop();
+		lines.push(this.row(this.getShortcutHelpText()));
 		this.appendNotice(lines);
 		lines.push(this.renderFooter(this.getFooterText()));
 

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

@@ -63,9 +63,9 @@ import {
 	MAX_CONCURRENCY,
 	resolveChildMaxSubagentDepth,
 } from "../../shared/types.ts";
-import { resolveSubagentModelOverride } from "../shared/model-fallback.ts";
+import { resolveEffectiveSubagentModel } from "../shared/model-fallback.ts";
 import type { ModelScopeConfig } from "../shared/model-scope.ts";
-import { validateFileOnlyOutputMode } from "../shared/single-output.ts";
+import { injectSingleOutputInstruction, 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";
@@ -88,7 +88,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" | "stopped" | "detached"; error?: string; acceptance?: SingleResult["acceptance"] }>;
 }
 
 interface ParallelChainRunInput {
@@ -109,8 +109,8 @@ interface ParallelChainRunInput {
 	globalTaskIndex: number;
 	sessionDirForIndex: (idx?: number) => string | undefined;
 	sessionFileForIndex?: (idx?: number) => string | undefined;
-	sessionFileForTask?: (agentName: string, idx?: number) => string | undefined;
-	thinkingOverrideForTask?: (agentName: string, idx?: number) => AgentConfig["thinking"] | undefined;
+	sessionFileForTask?: (agentName: string, idx?: number, modelOverride?: string) => string | undefined;
+	thinkingOverrideForTask?: (agentName: string, idx?: number, modelOverride?: string) => AgentConfig["thinking"] | undefined;
 	shareEnabled: boolean;
 	artifactConfig: ArtifactConfig;
 	artifactsDir: string;
@@ -152,6 +152,7 @@ interface ParallelChainRunInput {
 	toolBudget?: ResolvedToolBudget;
 	configToolBudget?: ToolBudgetConfig;
 	globalSemaphore?: Semaphore;
+	dynamic?: boolean;
 }
 
 function buildChainExecutionDetails(input: ChainExecutionDetailsInput): Details {
@@ -230,6 +231,21 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 	const concurrency = input.step.concurrency ?? MAX_CONCURRENCY;
 	const failFast = input.step.failFast ?? false;
 	let aborted = false;
+	const effectiveModels = input.step.parallel.map((task) => {
+		const taskAgentConfig = input.agents.find((agent) => agent.name === task.agent);
+		return resolveEffectiveSubagentModel(
+			task.model,
+			taskAgentConfig?.model,
+			input.ctx.model,
+			input.availableModels,
+			input.ctx.model?.provider,
+			{ scope: input.modelScope },
+		);
+	});
+	for (let taskIndex = 0; taskIndex < input.step.parallel.length; taskIndex++) {
+		const task = input.step.parallel[taskIndex]!;
+		input.sessionFileForTask?.(task.agent, input.globalTaskIndex + taskIndex, effectiveModels[taskIndex]);
+	}
 
 	const parallelResults = await mapConcurrent(
 		input.step.parallel,
@@ -248,9 +264,10 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 
 			const taskTemplate = input.parallelTemplates[taskIndex] ?? "{previous}";
 			const behavior = suppressProgressForReadOnlyTask(input.parallelBehaviors[taskIndex]!, taskTemplate, input.originalTask);
+			const taskAgentConfig = input.agents.find((agent) => agent.name === task.agent);
 			const templateHasPrevious = taskTemplate.includes("{previous}");
 			const { prefix, suffix } = buildChainInstructions(
-				behavior,
+				{ ...behavior, output: false },
 				input.chainDir,
 				false,
 				templateHasPrevious ? undefined : input.prev,
@@ -263,14 +280,7 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 			const cleanTask = taskStr;
 			taskStr = prefix + taskStr + suffix;
 
-			const taskAgentConfig = input.agents.find((agent) => agent.name === task.agent);
-			const effectiveModel = resolveSubagentModelOverride(
-				task.model ?? taskAgentConfig?.model,
-				input.ctx.model,
-				input.availableModels,
-				input.ctx.model?.provider,
-				{ scope: input.modelScope, source: task.model ? "explicit" : "inherited" },
-			);
+			const effectiveModel = effectiveModels[taskIndex];
 			const maxSubagentDepth = resolveChildMaxSubagentDepth(input.maxSubagentDepth, taskAgentConfig?.maxSubagentDepth);
 			const toolBudget = resolveChainToolBudget({ stepBudget: task.toolBudget, runBudget: input.toolBudget, agentBudget: taskAgentConfig?.toolBudget, configBudget: input.configToolBudget });
 			if (toolBudget.error) throw new Error(toolBudget.error);
@@ -282,6 +292,7 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 			const outputPath = typeof behavior.output === "string"
 				? (path.isAbsolute(behavior.output) ? behavior.output : path.join(input.chainDir, behavior.output))
 				: undefined;
+			taskStr = injectSingleOutputInstruction(taskStr, outputPath, taskAgentConfig);
 			const interruptController = new AbortController();
 			if (input.foregroundControl) {
 				input.foregroundControl.currentAgent = task.agent;
@@ -310,9 +321,9 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				runId: input.runId,
 				index: input.globalTaskIndex + taskIndex,
 				sessionDir: input.sessionDirForIndex(input.globalTaskIndex + taskIndex),
-				sessionFile: input.sessionFileForTask?.(task.agent, input.globalTaskIndex + taskIndex)
+				sessionFile: input.sessionFileForTask?.(task.agent, input.globalTaskIndex + taskIndex, effectiveModel)
 					?? input.sessionFileForIndex?.(input.globalTaskIndex + taskIndex),
-				thinkingOverride: input.thinkingOverrideForTask?.(task.agent, input.globalTaskIndex + taskIndex),
+				thinkingOverride: input.thinkingOverrideForTask?.(task.agent, input.globalTaskIndex + taskIndex, effectiveModel),
 				share: input.shareEnabled,
 				artifactsDir: input.artifactConfig.enabled ? input.artifactsDir : undefined,
 				artifactConfig: input.artifactConfig,
@@ -331,7 +342,7 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				skills: behavior.skills === false ? [] : behavior.skills,
 				structuredOutput: structuredRuntime,
 				acceptance: task.acceptance,
-				acceptanceContext: { mode: "chain" },
+				acceptanceContext: { mode: "chain", dynamic: input.dynamic && task.acceptance === undefined },
 				timeoutMs: input.timeoutMs,
 				deadlineAt: input.deadlineAt,
 				turnBudget: input.turnBudget,
@@ -412,8 +423,8 @@ interface ChainExecutionParams {
 	shareEnabled: boolean;
 	sessionDirForIndex: (idx?: number) => string | undefined;
 	sessionFileForIndex?: (idx?: number) => string | undefined;
-	sessionFileForTask?: (agentName: string, idx?: number) => string | undefined;
-	thinkingOverrideForTask?: (agentName: string, idx?: number) => AgentConfig["thinking"] | undefined;
+	sessionFileForTask?: (agentName: string, idx?: number, modelOverride?: string) => string | undefined;
+	thinkingOverrideForTask?: (agentName: string, idx?: number, modelOverride?: string) => AgentConfig["thinking"] | undefined;
 	artifactsDir: string;
 	artifactConfig: ArtifactConfig;
 	includeProgress?: boolean;
@@ -627,7 +638,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				return {
 					...step,
 					task: result.templates[i]!,
-					...(override?.model ? { model: override.model } : {}),
+					...(override?.model !== undefined ? { model: override.model } : {}),
 					...(override?.output !== undefined ? { output: override.output } : {}),
 					...("outputMode" in step && step.outputMode !== undefined ? { outputMode: step.outputMode } : {}),
 					...(override?.reads !== undefined ? { reads: override.reads } : {}),
@@ -768,7 +779,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				const detached = detachedIndexInStep >= 0 ? parallelResults[detachedIndexInStep] : undefined;
 				if (detached) {
 					return {
-						content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${detached.agent}). Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.` }],
+						content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${detached.agent}). Reply to the supervisor request first, then wait with subagent_wait({ id: "${runId}" }). Use subagent({ action: "status", id: "${runId}" }) to recover the result; do not resume or launch a replacement while it remains detached.` }],
 						details: buildChainExecutionDetails(makeDetailsInput({
 							currentStepIndex: stepIndex,
 							currentFlatIndex: globalTaskIndex - step.parallel.length + detachedIndexInStep,
@@ -869,7 +880,8 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 					const effectiveGroupAcceptance = resolveEffectiveAcceptance({
 						explicit: step.acceptance,
 						agentName: step.parallel.agent,
-						task: step.parallel.task ?? originalTask,
+						acceptanceRole: agents.find((agent) => agent.name === step.parallel.agent)?.acceptanceRole,
+						task: (step.parallel.task ?? originalTask ?? "").replace(/\{task\}/g, originalTask ?? ""),
 						mode: "chain",
 						dynamicGroup: true,
 					});
@@ -964,6 +976,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				toolBudget: params.toolBudget,
 				configToolBudget: params.configToolBudget,
 				globalSemaphore,
+				dynamic: true,
 			});
 			globalTaskIndex = dynamicStartIndex + reservedDynamicItems;
 
@@ -988,7 +1001,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			const detached = detachedIndexInStep >= 0 ? parallelResults[detachedIndexInStep] : undefined;
 			if (detached) {
 				return {
-					content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${detached.agent}). Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.` }],
+					content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${detached.agent}). Reply to the supervisor request first, then wait with subagent_wait({ id: "${runId}" }). Use subagent({ action: "status", id: "${runId}" }) to recover the result; do not resume or launch a replacement while it remains detached.` }],
 					details: buildChainExecutionDetails(makeDetailsInput({
 						currentStepIndex: stepIndex,
 						currentFlatIndex: dynamicStartIndex + detachedIndexInStep,
@@ -1034,7 +1047,10 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			const effectiveGroupAcceptance = resolveEffectiveAcceptance({
 				explicit: step.acceptance,
 				agentName: step.parallel.agent,
-				task: step.parallel.task ?? originalTask,
+				acceptanceRole: agents.find((agent) => agent.name === step.parallel.agent)?.acceptanceRole,
+				task: materialized.parallel
+					.map((task) => (task.task ?? originalTask ?? "").replace(/\{task\}/g, originalTask ?? ""))
+					.join("\n"),
 				mode: "chain",
 				dynamicGroup: true,
 			});
@@ -1048,7 +1064,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				cwd: cwd ?? ctx.cwd,
 			});
 			dynamicGroupStatuses[stepIndex].acceptance = groupAcceptance;
-			const groupAcceptanceFailure = acceptanceFailureMessage(groupAcceptance);
+			const groupAcceptanceFailure = effectiveGroupAcceptance.explicit ? acceptanceFailureMessage(groupAcceptance) : undefined;
 			if (groupAcceptanceFailure) {
 				dynamicGroupStatuses[stepIndex] = { status: "failed", error: groupAcceptanceFailure, acceptance: groupAcceptance };
 				return buildChainExecutionErrorResult(groupAcceptanceFailure, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex - dynamicParallelStep.parallel.length }));
@@ -1096,7 +1112,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 
 			const templateHasPrevious = stepTemplate.includes("{previous}");
 			const { prefix, suffix } = buildChainInstructions(
-				behavior,
+				{ ...behavior, output: false },
 				chainDir,
 				isFirstProgress,
 				templateHasPrevious ? undefined : prev,
@@ -1110,17 +1126,19 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			stepTask = prefix + stepTask + suffix;
 
 			const explicitStepModel = tuiOverride?.model ?? seqStep.model;
-			const effectiveModel = resolveSubagentModelOverride(
-				explicitStepModel ?? agentConfig.model,
+			const effectiveModel = resolveEffectiveSubagentModel(
+				explicitStepModel,
+				agentConfig.model,
 				ctx.model,
 				availableModels,
 				ctx.model?.provider,
-				{ scope: modelScope, source: explicitStepModel ? "explicit" : "inherited" },
+				{ scope: modelScope },
 			);
 
 			const outputPath = typeof behavior.output === "string"
 				? (path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output))
 				: undefined;
+			stepTask = injectSingleOutputInstruction(stepTask, outputPath, agentConfig);
 			const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Chain step ${stepIndex + 1} (${seqStep.agent})`);
 			if (validationError) {
 				return buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
@@ -1172,9 +1190,9 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				runId,
 				index: childIndex,
 				sessionDir: sessionDirForIndex(childIndex),
-				sessionFile: sessionFileForTask?.(seqStep.agent, childIndex)
+				sessionFile: sessionFileForTask?.(seqStep.agent, childIndex, effectiveModel)
 					?? sessionFileForIndex?.(childIndex),
-				thinkingOverride: thinkingOverrideForTask?.(seqStep.agent, childIndex),
+				thinkingOverride: thinkingOverrideForTask?.(seqStep.agent, childIndex, effectiveModel),
 				share: shareEnabled,
 				artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
 				artifactConfig,
@@ -1264,7 +1282,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			}
 			if (r.detached) {
 				return {
-					content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${r.agent}). Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.` }],
+					content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${r.agent}). Reply to the supervisor request first, then wait with subagent_wait({ id: "${runId}" }). Use subagent({ action: "status", id: "${runId}" }) to recover the result; do not resume or launch a replacement while it remains detached.` }],
 					details: buildChainExecutionDetails(makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: childIndex })),
 				};
 			}