@bastani/atomic 0.9.5-alpha.8 → 0.9.5

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

@@ -102,6 +102,22 @@ export async function runSync(
 		}
 		if (options.artifactConfig?.includeJsonl !== false) jsonlPath = artifactPathsResult.jsonlPath;
 	}
+	const persistArtifacts = (value: SingleResult): void => {
+		if (!artifactPathsResult || options.artifactConfig?.enabled === false) return;
+		value.artifactPaths = artifactPathsResult;
+		if (options.artifactConfig?.includeOutput !== false) {
+			writeArtifact(artifactPathsResult.outputPath, artifactOutputByResult.get(value) ?? value.finalOutput ?? "");
+		}
+		if (options.artifactConfig?.includeMetadata !== false) {
+			writeMetadata(artifactPathsResult.metadataPath, {
+				runId: options.runId, agent: agentName, task, exitCode: value.exitCode,
+				usage: value.usage, model: value.model, fastMode: value.fastMode,
+				attemptedModels: value.attemptedModels, modelAttempts: value.modelAttempts,
+				durationMs: value.progressSummary?.durationMs, toolCount: value.progressSummary?.toolCount,
+				error: value.error, skills: value.skills, skillsWarning: value.skillsWarning, timestamp: Date.now(),
+			});
+		}
+	};
 
 	let lastResult: SingleResult | undefined;
 	const modelsToTry = candidates.length > 0 ? candidates : (rawCandidates.length === 0 ? [undefined] : []);
@@ -109,11 +125,29 @@ export async function runSync(
 		const candidate = modelsToTry[i];
 		if (candidate) attemptedModels.push(candidate);
 		const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
-		let attemptOptions = options;
+		const detachedExit = options.onDetachedExit;
+		let attemptOptions: RunSyncOptions = {
+			...options,
+			onDetachedExit: (recovered) => {
+				recovered.attemptedModels = attemptedModels.length > 0 ? [...attemptedModels] : undefined;
+				const recoveredModel = applyThinkingSuffix(candidate, agent.thinking) ?? recovered.model ?? agent.model ?? "default";
+				const completedAttempt: ModelAttempt = {
+					model: recoveredModel,
+					reasoningLevel: resolveEffectiveThinking(recoveredModel, agent.thinking),
+					success: recovered.exitCode === 0 && !recovered.error,
+					exitCode: recovered.exitCode,
+					error: recovered.error,
+					usage: { ...recovered.usage },
+				};
+				recovered.modelAttempts = [...modelAttempts.slice(0, -1), completedAttempt];
+				persistArtifacts(recovered);
+				detachedExit?.(recovered);
+			},
+		};
 		if (i < modelsToTry.length - 1 && options.onUpdate) {
 			const forwardUpdate = options.onUpdate;
 			attemptOptions = {
-				...options,
+				...attemptOptions,
 				onUpdate: (update) => {
 					if (shouldSuppressIntermediateRetryableFailureUpdate(update)) return;
 					forwardUpdate(update);
@@ -149,6 +183,7 @@ export async function runSync(
 		};
 		modelAttempts.push(attempt);
 		if (attemptSucceeded) break;
+		if (result.detached) break;
 		const retrySignal = modelFailureSignalByResult.get(result) ?? result.error;
 		if (isRetryableModelFailure(retrySignal) && i < modelsToTry.length - 1) {
 			pendingAttemptNotes.push(formatModelAttemptNote(attempt, modelsToTry[i + 1]));
@@ -182,30 +217,8 @@ export async function runSync(
 		if (result.progress.recentOutput.length > 50) result.progress.recentOutput.splice(50);
 	}
 
-	if (artifactPathsResult && options.artifactConfig?.enabled !== false) {
-		result.artifactPaths = artifactPathsResult;
-		if (options.artifactConfig?.includeOutput !== false) {
-			writeArtifact(artifactPathsResult.outputPath, artifactOutputByResult.get(result) ?? result.finalOutput ?? "");
-		}
-		if (options.artifactConfig?.includeMetadata !== false) {
-			writeMetadata(artifactPathsResult.metadataPath, {
-				runId: options.runId,
-				agent: agentName,
-				task,
-				exitCode: result.exitCode,
-				usage: result.usage,
-				model: result.model,
-				fastMode: result.fastMode,
-				attemptedModels: result.attemptedModels,
-				modelAttempts: result.modelAttempts,
-				durationMs: result.progressSummary?.durationMs,
-				toolCount: result.progressSummary?.toolCount,
-				error: result.error,
-				skills: result.skills,
-				skillsWarning: result.skillsWarning,
-				timestamp: Date.now(),
-			});
-		}
+	if (artifactPathsResult && options.artifactConfig?.enabled !== false && !result.detached) {
+		persistArtifacts(result);
 
 		if (options.maxOutput) {
 			const config = { ...DEFAULT_MAX_OUTPUT, ...options.maxOutput };

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

@@ -11,7 +11,7 @@ import {
 	resolveTopLevelParallelMaxTasks,
 	wrapForkTask,
 } from "../../shared/types.ts";
-import { type ChainStep } from "../../shared/settings.ts";
+import { resolveSingleProgress, type ChainStep } from "../../shared/settings.ts";
 import { normalizeSingleOutputOverride } from "../shared/single-output.ts";
 import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
 import { collectChainSessionFiles, wrapChainTasksForFork } from "./subagent-executor-input.ts";
@@ -178,6 +178,7 @@ export function runAsyncPath(data: ExecutionContextData, deps: ResolvedExecutorD
 		const skills = normalizedSkills === false ? [] : normalizedSkills;
 		const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, a.maxSubagentDepth);
 		const modelOverride = resolveModelCandidate((params.model as string | undefined) ?? a.model, availableModels, currentProvider);
+		const progress = resolveSingleProgress(a, params.progress, params.task);
 		return deps.runtime.executeAsyncSingle(id, {
 			agent: params.agent!,
 			task: params.context === "fork" ? wrapForkTask(params.task ?? "") : (params.task ?? ""),
@@ -195,6 +196,7 @@ export function runAsyncPath(data: ExecutionContextData, deps: ResolvedExecutorD
 			skills,
 			output: effectiveOutput,
 			outputMode: effectiveOutputMode,
+			progress,
 			modelOverride,
 			maxSubagentDepth,
 			workflowStageSubagentGuard,

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

@@ -1,8 +1,4 @@
-import { randomUUID } from "node:crypto";
-import { APP_NAME } from "@bastani/atomic";
 import { executeChain } from "./chain-execution.ts";
-import { currentModelFullId } from "../shared/model-fallback.ts";
-import { toModelInfo } from "../../shared/model-info.ts";
 import { normalizeSkillInput } from "../../agents/skills.ts";
 import { updateForegroundNestedProjection } from "../shared/nested-events.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
@@ -10,8 +6,8 @@ import { compactForegroundDetails } from "../../shared/utils.ts";
 import { resolveSubagentDepthPolicy } from "../../shared/types.ts";
 import type { ChainStep } from "../../shared/settings.ts";
 import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
-import { collectChainSessionFiles, wrapChainTasksForFork } from "./subagent-executor-input.ts";
-import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun } from "./subagent-executor-status.ts";
+import { wrapChainTasksForFork } from "./subagent-executor-input.ts";
+import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
 
 export async function runChainPath(data: ExecutionContextData, deps: ResolvedExecutorDeps): Promise<import("../../shared/types.ts").SubagentToolResult> {
 	const {
@@ -27,7 +23,6 @@ export async function runChainPath(data: ExecutionContextData, deps: ResolvedExe
 		artifactsDir,
 		artifactConfig,
 		onUpdate,
-		sessionRoot,
 		controlConfig,
 	} = data;
 	const onControlEvent = createForegroundControlNotifier(data, deps);
@@ -54,7 +49,6 @@ export async function runChainPath(data: ExecutionContextData, deps: ResolvedExe
 		artifactsDir,
 		artifactConfig,
 		includeProgress: params.includeProgress,
-		clarify: params.clarify,
 		onUpdate,
 		onControlEvent,
 		controlConfig,
@@ -70,51 +64,9 @@ export async function runChainPath(data: ExecutionContextData, deps: ResolvedExe
 		worktreeSetupHook: deps.config.worktreeSetupHook,
 		worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
 		runSync: deps.runtime.runSync,
+		onDetachedExit: (index, result) => replaceForegroundRunChild(deps.state, runId, index, result),
 	});
 
-	if (chainResult.requestedAsync) {
-		if (!deps.runtime.isAsyncAvailable()) {
-			return {
-				content: [{ type: "text", text: `Background mode requires upstream jiti for TypeScript execution but it could not be found. Ensure the ${APP_NAME}-subagents package dependencies are installed.` }],
-				isError: true,
-				details: { mode: "chain" as const, results: [] },
-			};
-		}
-		const id = randomUUID();
-		const asyncCtx = {
-			pi: deps.pi,
-			cwd: ctx.cwd,
-			currentSessionId: deps.state.currentSessionId!,
-			currentModelProvider: ctx.model?.provider,
-			currentModel: currentModelFullId(ctx.model),
-		};
-		const asyncChain = wrapChainTasksForFork(chainResult.requestedAsync.chain, params.context);
-		return deps.runtime.executeAsyncChain(id, {
-			chain: asyncChain,
-			task: params.task,
-			agents,
-			ctx: asyncCtx,
-			availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
-			cwd: effectiveCwd,
-			maxOutput: params.maxOutput,
-			artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
-			artifactConfig,
-			shareEnabled,
-			sessionRoot,
-			chainSkills: chainResult.requestedAsync.chainSkills,
-			sessionFilesByFlatIndex: collectChainSessionFiles(asyncChain, sessionFileForIndex),
-			dynamicFanoutMaxItems: deps.config.chain?.dynamicFanout?.maxItems,
-			maxSubagentDepth: currentMaxSubagentDepth,
-			workflowStageSubagentGuard,
-			worktreeSetupHook: deps.config.worktreeSetupHook,
-			worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
-			controlConfig,
-			controlIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
-			childIntercomTarget: data.intercomBridge.active ? (agent, index) => resolveSubagentIntercomTarget(id, agent, index) : undefined,
-			nestedRoute: data.nestedRoute,
-		});
-	}
-
 	const chainDetails = chainResult.details ? compactForegroundDetails({ ...chainResult.details, runId }) : undefined;
 	if (foregroundControl) updateForegroundNestedProjection(foregroundControl);
 	if (chainDetails) rememberForegroundRun(deps.state, { runId, mode: "chain", cwd: effectiveCwd, results: chainDetails.results });

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

@@ -29,7 +29,7 @@ import {
 	type ArtifactConfig,
 	type SubagentToolResult,
 } from "../../shared/types.ts";
-import { isParallelStep as isSettingsParallelStep, type SequentialStep } from "../../shared/settings.ts";
+import { buildReadInstruction, isParallelStep as isSettingsParallelStep, type SequentialStep } from "../../shared/settings.ts";
 import type { ExecutionContextBuildResult, ExecutorDeps, ResolvedExecutorDeps, SubagentParamsLike } from "./subagent-executor-types.ts";
 import {
 	applyAgentDefaultContext,
@@ -100,20 +100,18 @@ export function prepareExecutionContext(input: {
 	const hasChain = (effectiveParams.chain?.length ?? 0) > 0;
 	const hasTasks = (effectiveParams.tasks?.length ?? 0) > 0;
 	const hasSingle = !hasChain && !hasTasks && Boolean(effectiveParams.agent);
-	const allowClarifyTaskPrompt = hasChain
-		&& effectiveParams.clarify === true
-		&& ctx.hasUI
-		&& !(effectiveParams.chain?.some(isSettingsParallelStep) ?? false);
-
 	const validationError = validateExecutionInput(
 		effectiveParams,
 		agents,
 		hasChain,
 		hasTasks,
 		hasSingle,
-		allowClarifyTaskPrompt,
 	);
 	if (validationError) return { error: validationError };
+	if (hasSingle) {
+		const readInstruction = buildReadInstruction(effectiveParams.reads, effectiveCwd);
+		if (readInstruction) effectiveParams = { ...effectiveParams, task: `${readInstruction}\n\n${effectiveParams.task ?? ""}` };
+	}
 
 	let sessionFileForIndex: (idx?: number) => string | undefined = () => undefined;
 	try {
@@ -121,9 +119,7 @@ export function prepareExecutionContext(input: {
 	} catch (error) {
 		return { error: toExecutionErrorResult(effectiveParams, error) };
 	}
-	const requestedAsync = effectiveParams.async ?? deps.asyncByDefault;
-	const backgroundRequestedWhileClarifying = (hasChain || hasTasks) && requestedAsync && effectiveParams.clarify === true;
-	const effectiveAsync = requestedAsync && effectiveParams.clarify !== true;
+	const effectiveAsync = effectiveParams.async ?? deps.asyncByDefault;
 	const controlConfig = resolveControlConfig(deps.config.control, effectiveParams.control);
 
 	const artifactConfig: ArtifactConfig = {
@@ -175,7 +171,6 @@ export function prepareExecutionContext(input: {
 		sessionFileForIndex: childSessionFileForIndex,
 		artifactConfig,
 		artifactsDir,
-		backgroundRequestedWhileClarifying,
 		effectiveAsync,
 		controlConfig,
 		intercomBridge,

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

@@ -9,7 +9,6 @@ export function validateExecutionInput(
 	hasChain: boolean,
 	hasTasks: boolean,
 	hasSingle: boolean,
-	allowClarifyTaskPrompt: boolean,
 ): SubagentToolResult | null {
 	if (Number(hasChain) + Number(hasTasks) + Number(hasSingle) !== 1) {
 		return {
@@ -23,6 +22,16 @@ export function validateExecutionInput(
 			details: { mode: "single" as const, results: [] },
 		};
 	}
+	if (hasSingle) {
+		const reads = (params as SubagentParamsLike & { reads?: unknown }).reads;
+		if (reads !== undefined && reads !== false && (!Array.isArray(reads) || reads.some((entry) => typeof entry !== "string"))) {
+			return {
+				content: [{ type: "text", text: "reads must be an array of file path strings or false" }],
+				isError: true,
+				details: { mode: "single", results: [] },
+			};
+		}
+	}
 
 	if (hasSingle && params.agent && !agents.find((agent) => agent.name === params.agent)) {
 		return {
@@ -69,7 +78,7 @@ export function validateExecutionInput(
 				isError: true,
 				details: { mode: "chain" as const, results: [] },
 			};
-		} else if (!(firstStep as SequentialStep).task && !params.task && !allowClarifyTaskPrompt) {
+		} else if (!(firstStep as SequentialStep).task && !params.task) {
 			return {
 				content: [{ type: "text", text: "First step in chain must have a task" }],
 				isError: true,

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

@@ -51,6 +51,7 @@ interface ForegroundParallelRunInput {
 	liveResults: (SingleResult | undefined)[];
 	liveProgress: (AgentProgress | undefined)[];
 	onUpdate?: (r: SubagentToolResult) => void;
+	onDetachedExit?: (index: number, result: SingleResult) => void;
 	worktreeSetup?: WorktreeSetup;
 	runtime: Pick<SubagentExecutorRuntimeDeps, "runSync">;
 }
@@ -108,6 +109,7 @@ export async function runForegroundParallelTasks(input: ForegroundParallelRunInp
 			onControlEvent: input.onControlEvent,
 			intercomSessionName: input.childIntercomTarget?.(task.agent, index),
 			orchestratorIntercomTarget: input.orchestratorIntercomTarget,
+			onDetachedExit: (result) => input.onDetachedExit?.(index, result),
 			nestedRoute: input.foregroundControl?.nestedRoute,
 			modelOverride: input.modelOverrides[index],
 			availableModels: input.availableModels,

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

@@ -1,15 +1,11 @@
-import { randomUUID } from "node:crypto";
-import { APP_NAME } from "@bastani/atomic";
-import { ChainClarifyComponent, type ChainClarifyResult } from "./chain-clarify.ts";
-import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
+import { resolveModelCandidate } from "../shared/model-fallback.ts";
 import { collectKnownModelProviders, toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
-import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skills.ts";
+import { normalizeSkillInput } from "../../agents/skills.ts";
 import { aggregateParallelOutputs } from "../shared/parallel-utils.ts";
 import { recordRun } from "../shared/run-history.ts";
 import {
 	resolveStepBehavior,
 	suppressProgressForReadOnlyTask,
-	taskDisallowsFileUpdates,
 	type StepOverrides,
 } from "../../shared/settings.ts";
 import {
@@ -46,7 +42,7 @@ import {
 	findDuplicateParallelOutputPath,
 	resolveParallelTaskCwd,
 } from "./subagent-executor-worktree.ts";
-import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun } from "./subagent-executor-status.ts";
+import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
 
 export async function runParallelPath(data: ExecutionContextData, deps: ResolvedExecutorDeps): Promise<SubagentToolResult> {
 	const {
@@ -61,9 +57,7 @@ export async function runParallelPath(data: ExecutionContextData, deps: Resolved
 		shareEnabled,
 		artifactConfig,
 		artifactsDir,
-		backgroundRequestedWhileClarifying,
 		onUpdate,
-		sessionRoot,
 		controlConfig,
 	} = data;
 	const onControlEvent = createForegroundControlNotifier(data, deps);
@@ -125,107 +119,6 @@ export async function runParallelPath(data: ExecutionContextData, deps: Resolved
 		resolveModelCandidate(behaviorOverrides[i]?.model ?? agentConfigs[i]?.model, availableModels, currentProvider),
 	);
 
-	if (params.clarify === true && ctx.hasUI) {
-		const behaviors = agentConfigs.map((c, i) =>
-			resolveStepBehavior(c, behaviorOverrides[i]!),
-		);
-		const availableSkills = discoverAvailableSkills(effectiveCwd);
-
-		const result = await ctx.ui.custom<ChainClarifyResult>(
-			(tui, theme, _kb, done) =>
-				new ChainClarifyComponent(
-					tui, theme,
-					agentConfigs,
-					taskTexts,
-					"",
-					undefined,
-					behaviors,
-					availableModels,
-					currentProvider,
-					availableSkills,
-					done,
-					"parallel",
-				),
-			{ overlay: true, overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" } },
-		);
-
-		if (!result || !result.confirmed) {
-			return { content: [{ type: "text", text: "Cancelled" }], details: { mode: "parallel", results: [] } };
-		}
-
-		taskTexts = result.templates;
-		for (let i = 0; i < result.behaviorOverrides.length; i++) {
-			const override = result.behaviorOverrides[i];
-			if (override?.model) {
-				modelOverrides[i] = override.model;
-				behaviorOverrides[i]!.model = override.model;
-			}
-			if (override?.output !== undefined) behaviorOverrides[i]!.output = override.output;
-			if (override?.reads !== undefined) behaviorOverrides[i]!.reads = override.reads;
-			if (override?.progress !== undefined) behaviorOverrides[i]!.progress = override.progress;
-			if (override?.skills !== undefined) {
-				skillOverrides[i] = override.skills;
-				behaviorOverrides[i]!.skills = override.skills;
-			}
-		}
-
-		if (result.runInBackground) {
-			if (!deps.runtime.isAsyncAvailable()) {
-				return {
-					content: [{ type: "text", text: `Background mode requires upstream jiti for TypeScript execution but it could not be found. Ensure the ${APP_NAME}-subagents package dependencies are installed.` }],
-					isError: true,
-					details: { mode: "parallel" as const, results: [] },
-				};
-			}
-			const id = randomUUID();
-			const asyncCtx = {
-				pi: deps.pi,
-				cwd: ctx.cwd,
-				currentSessionId: deps.state.currentSessionId!,
-				currentModelProvider: ctx.model?.provider,
-				currentModel: currentModelFullId(ctx.model),
-			};
-			const parallelTasks = tasks.map((t, i) => {
-				const taskText = params.context === "fork" ? wrapForkTask(taskTexts[i]!) : taskTexts[i]!;
-				const progress = taskDisallowsFileUpdates(taskText) ? false : behaviorOverrides[i]?.progress;
-				return {
-					agent: t.agent,
-					task: taskText,
-					cwd: t.cwd,
-					...(modelOverrides[i] ? { model: modelOverrides[i] } : {}),
-					...(skillOverrides[i] !== undefined ? { skill: skillOverrides[i] } : {}),
-					...(behaviorOverrides[i]?.output !== undefined ? { output: behaviorOverrides[i]!.output } : {}),
-					...(behaviorOverrides[i]?.outputMode !== undefined ? { outputMode: behaviorOverrides[i]!.outputMode } : {}),
-					...(behaviorOverrides[i]?.reads !== undefined ? { reads: behaviorOverrides[i]!.reads } : {}),
-					...(progress !== undefined ? { progress } : {}),
-				};
-			});
-			return deps.runtime.executeAsyncChain(id, {
-				chain: [{ parallel: parallelTasks, concurrency: parallelConcurrency, worktree: params.worktree }],
-				resultMode: "parallel",
-				agents,
-				ctx: asyncCtx,
-				availableModels,
-				knownModelProviders,
-				cwd: effectiveCwd,
-				maxOutput: params.maxOutput,
-				artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
-				artifactConfig,
-				shareEnabled,
-				sessionRoot,
-				chainSkills: [],
-				sessionFilesByFlatIndex: tasks.map((_, index) => sessionFileForIndex(index)),
-				maxSubagentDepth: currentMaxSubagentDepth,
-				workflowStageSubagentGuard,
-				worktreeSetupHook: deps.config.worktreeSetupHook,
-				worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
-				controlConfig,
-				controlIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
-				childIntercomTarget: data.intercomBridge.active ? (agent, index) => resolveSubagentIntercomTarget(id, agent, index) : undefined,
-			});
-		}
-	}
-
 	const behaviors = agentConfigs.map((config, index) => suppressProgressForReadOnlyTask(resolveStepBehavior(config, behaviorOverrides[index]!), taskTexts[index]));
 	const firstProgressIndex = behaviors.findIndex((behavior) => behavior.progress);
 	const liveResults: (SingleResult | undefined)[] = new Array(tasks.length).fill(undefined);
@@ -267,6 +160,7 @@ export async function runParallelPath(data: ExecutionContextData, deps: Resolved
 		}
 
 		const results = await runForegroundParallelTasks({
+			onDetachedExit: (index, result) => replaceForegroundRunChild(deps.state, runId, index, result),
 			tasks,
 			taskTexts,
 			agents,
@@ -352,7 +246,6 @@ export async function runParallelPath(data: ExecutionContextData, deps: Resolved
 
 		const worktreeSuffix = buildParallelWorktreeSuffix(worktreeSetup, artifactsDir, tasks as TaskParam[]);
 		const ok = results.filter((result) => result.exitCode === 0).length;
-		const downgradeNote = backgroundRequestedWhileClarifying ? " (background requested, but clarify kept this run foreground)" : "";
 		const aggregatedOutput = aggregateParallelOutputs(
 			results.map((result) => ({
 				agent: result.agent,
@@ -363,7 +256,7 @@ export async function runParallelPath(data: ExecutionContextData, deps: Resolved
 			(i, agent) => `=== Task ${i + 1}: ${agent} ===`,
 		);
 
-		const summary = `${ok}/${results.length} succeeded${downgradeNote}`;
+		const summary = `${ok}/${results.length} succeeded`;
 		const fullContent = worktreeSuffix
 			? `${summary}\n\n${aggregatedOutput}\n\n${worktreeSuffix}`
 			: `${summary}\n\n${aggregatedOutput}`;

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

@@ -7,6 +7,7 @@ import { readStatus } from "../../shared/utils.ts";
 import { buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../background/async-resume.ts";
 import { resolveSubagentRunId, type ResolvedSubagentRunId } from "../background/run-id-resolver.ts";
 import { toModelInfo } from "../../shared/model-info.ts";
+import { resolveSingleProgress } from "../../shared/settings.ts";
 import {
 	createNestedRoute,
 	readNestedControlResults,
@@ -419,6 +420,7 @@ export async function resumeAsyncRun(input: {
 		agent: target.agent,
 		task: buildRevivedAsyncTask(target, followUp),
 		agentConfig,
+		progress: resolveSingleProgress(agentConfig, input.params.progress, followUp),
 		ctx: {
 			pi: input.deps.pi,
 			cwd: input.requestCwd,