@bastani/atomic 0.9.10 → 0.9.11-alpha.10

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

@@ -5,25 +5,21 @@ import { ensureArtifactsDir, getArtifactPaths, writeArtifact, writeMetadata } fr
 import { getSubagentCodexFastModeSettings, resolveSubagentCodexFastModeScope } from "../../shared/fast-mode.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import {
-	DEFAULT_MAX_OUTPUT,
 	type ArtifactPaths,
+	DEFAULT_MAX_OUTPUT,
 	type ModelAttempt,
 	type RunSyncOptions,
 	type SingleResult,
 	truncateOutput,
 } from "../../shared/types.ts";
 import { findLatestSessionFile } from "../../shared/utils.ts";
+import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
+import { buildModelCandidates, formatModelAttemptNote, isRetryableModelFailure } from "../shared/model-fallback.ts";
 import { applyThinkingSuffix } from "../shared/pi-args.ts";
 import { captureSingleOutputSnapshot, validateFileOnlyOutputMode } from "../shared/single-output.ts";
-import {
-	buildModelCandidates,
-	formatModelAttemptNote,
-	isRetryableModelFailure,
-} from "../shared/model-fallback.ts";
-import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
-import { artifactOutputByResult, emptyUsage, modelFailureSignalByResult, sumUsage } from "./execution-utils.ts";
 import { runSingleAttemptWithStructuredOutputRetries } from "./execution-structured-retries.ts";
 import { shouldSuppressIntermediateRetryableFailureUpdate } from "./execution-updates.ts";
+import { artifactOutputByResult, emptyUsage, modelFailureSignalByResult, sumUsage } from "./execution-utils.ts";
 
 /**
  * Run a subagent synchronously (blocking until complete)
@@ -37,9 +33,20 @@ export async function runSync(
 ): Promise<SingleResult> {
 	const agent = agents.find((a) => a.name === agentName);
 	if (!agent) {
-		return { agent: agentName, task, exitCode: 1, messages: [], usage: emptyUsage(), error: `Unknown agent: ${agentName}` };
+		return {
+			agent: agentName,
+			task,
+			exitCode: 1,
+			messages: [],
+			usage: emptyUsage(),
+			error: `Unknown agent: ${agentName}`,
+		};
 	}
-	const outputModeValidationError = validateFileOnlyOutputMode(options.outputMode, options.outputPath, `Single run (${agentName})`);
+	const outputModeValidationError = validateFileOnlyOutputMode(
+		options.outputMode,
+		options.outputPath,
+		`Single run (${agentName})`,
+	);
 	if (outputModeValidationError) {
 		return {
 			agent: agentName,
@@ -56,9 +63,20 @@ export async function runSync(
 	const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
 	const skillNames = options.skills ?? agent.skills ?? [];
 	const skillCwd = options.cwd ?? runtimeCwd;
-	const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, skillCwd, runtimeCwd);
+	const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(
+		skillNames,
+		skillCwd,
+		runtimeCwd,
+	);
 	if (skillNames.some((skill) => skill.trim() === "subagent") && missingSkills.includes("subagent")) {
-		return { agent: agentName, task, exitCode: 1, messages: [], usage: emptyUsage(), error: "Skills not found: subagent" };
+		return {
+			agent: agentName,
+			task,
+			exitCode: 1,
+			messages: [],
+			usage: emptyUsage(),
+			error: "Skills not found: subagent",
+		};
 	}
 	let systemPrompt = agent.systemPrompt?.trim() || "";
 	if (resolvedSkills.length > 0) {
@@ -110,17 +128,27 @@ export async function runSync(
 		}
 		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(),
+				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] : []);
+	const modelsToTry = candidates.length > 0 ? candidates : rawCandidates.length === 0 ? [undefined] : [];
 	for (let i = 0; i < modelsToTry.length; i++) {
 		const candidate = modelsToTry[i];
 		if (candidate) attemptedModels.push(candidate);
@@ -130,7 +158,8 @@ export async function runSync(
 			...options,
 			onDetachedExit: (recovered) => {
 				recovered.attemptedModels = attemptedModels.length > 0 ? [...attemptedModels] : undefined;
-				const recoveredModel = applyThinkingSuffix(candidate, agent.thinking) ?? recovered.model ?? agent.model ?? "default";
+				const recoveredModel =
+					applyThinkingSuffix(candidate, agent.thinking) ?? recovered.model ?? agent.model ?? "default";
 				const completedAttempt: ModelAttempt = {
 					model: recoveredModel,
 					reasoningLevel: resolveEffectiveThinking(recoveredModel, agent.thinking),
@@ -154,19 +183,26 @@ export async function runSync(
 				},
 			};
 		}
-		const result = await runSingleAttemptWithStructuredOutputRetries(runtimeCwd, agent, task, candidate, attemptOptions, {
-			sessionEnabled,
-			systemPrompt,
-			resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
-			skillsWarning: missingSkills.length > 0 ? `Skills not found: ${missingSkills.join(", ")}` : undefined,
-			jsonlPath,
-			artifactPaths: artifactPathsResult,
-			attemptNotes,
-			outputSnapshot,
-			fastModeSettings,
-			fastModeScope,
-			originalTask: task,
-		});
+		const result = await runSingleAttemptWithStructuredOutputRetries(
+			runtimeCwd,
+			agent,
+			task,
+			candidate,
+			attemptOptions,
+			{
+				sessionEnabled,
+				systemPrompt,
+				resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
+				skillsWarning: missingSkills.length > 0 ? `Skills not found: ${missingSkills.join(", ")}` : undefined,
+				jsonlPath,
+				artifactPaths: artifactPathsResult,
+				attemptNotes,
+				outputSnapshot,
+				fastModeSettings,
+				fastModeScope,
+				originalTask: task,
+			},
+		);
 		lastResult = result;
 		sumUsage(aggregateUsage, result.usage);
 		totalToolCount += result.progressSummary?.toolCount ?? 0;
@@ -193,16 +229,19 @@ export async function runSync(
 		break;
 	}
 
-	const result = lastResult ?? {
-		agent: agentName,
-		task,
-		exitCode: 1,
-		messages: [],
-		usage: emptyUsage(),
-		error: modelAttempts.length > 0
-			? "No spawnable subagent model candidates after pre-spawn filtering."
-			: "Subagent did not produce a result.",
-	} satisfies SingleResult;
+	const result =
+		lastResult ??
+		({
+			agent: agentName,
+			task,
+			exitCode: 1,
+			messages: [],
+			usage: emptyUsage(),
+			error:
+				modelAttempts.length > 0
+					? "No spawnable subagent model candidates after pre-spawn filtering."
+					: "Subagent did not produce a result.",
+		} satisfies SingleResult);
 
 	result.usage = aggregateUsage;
 	result.attemptedModels = attemptedModels.length > 0 ? attemptedModels : undefined;

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

@@ -1,15 +1,15 @@
 import type { AgentConfig } from "../../agents/agents.ts";
 import type { RunSyncOptions, SingleResult } from "../../shared/types.ts";
 import {
-	STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS,
 	formatStructuredOutputCorrectionPrompt,
 	isStructuredOutputContractError,
 	latestStructuredOutputToolErrorFromMessages,
+	STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS,
 } from "../shared/structured-output.ts";
-import { emptyUsage, sumUsage } from "./execution-utils.ts";
 import { runSingleAttempt } from "./execution-attempt.ts";
 import type { RunSingleAttemptShared } from "./execution-attempt-types.ts";
-import { shouldSuppressIntermediateStructuredOutputFailureUpdate, type RunSyncUpdate } from "./execution-updates.ts";
+import { type RunSyncUpdate, shouldSuppressIntermediateStructuredOutputFailureUpdate } from "./execution-updates.ts";
+import { emptyUsage, sumUsage } from "./execution-utils.ts";
 
 export async function runSingleAttemptWithStructuredOutputRetries(
 	runtimeCwd: string,
@@ -27,17 +27,18 @@ export async function runSingleAttemptWithStructuredOutputRetries(
 	let totalDurationMs = 0;
 
 	while (true) {
-		const suppressIntermediateStructuredOutputFailure = options.structuredOutput !== undefined
-			&& correctiveAttempts < STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS
-			&& options.onUpdate !== undefined;
+		const suppressIntermediateStructuredOutputFailure =
+			options.structuredOutput !== undefined &&
+			correctiveAttempts < STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS &&
+			options.onUpdate !== undefined;
 		const attemptOptions = suppressIntermediateStructuredOutputFailure
 			? {
-				...options,
-				onUpdate: (update: RunSyncUpdate) => {
-					if (shouldSuppressIntermediateStructuredOutputFailureUpdate(update)) return;
-					options.onUpdate?.(update);
-				},
-			}
+					...options,
+					onUpdate: (update: RunSyncUpdate) => {
+						if (shouldSuppressIntermediateStructuredOutputFailureUpdate(update)) return;
+						options.onUpdate?.(update);
+					},
+				}
 			: options;
 		const result = await runSingleAttempt(runtimeCwd, agent, nextTask, model, attemptOptions, shared);
 		finalResult = result;
@@ -46,7 +47,10 @@ export async function runSingleAttemptWithStructuredOutputRetries(
 		totalDurationMs += result.progressSummary?.durationMs ?? 0;
 
 		if (!options.structuredOutput || !isStructuredOutputContractError(result.error)) break;
-		const correctionError = latestStructuredOutputToolErrorFromMessages(result.messages) ?? result.error ?? "Structured output contract failed.";
+		const correctionError =
+			latestStructuredOutputToolErrorFromMessages(result.messages) ??
+			result.error ??
+			"Structured output contract failed.";
 		if (correctiveAttempts >= STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS) {
 			result.error = correctionError;
 			break;
@@ -59,14 +63,16 @@ export async function runSingleAttemptWithStructuredOutputRetries(
 		});
 	}
 
-	const result = finalResult ?? {
-		agent: agent.name,
-		task,
-		exitCode: 1,
-		messages: [],
-		usage: emptyUsage(),
-		error: "Subagent did not produce a result.",
-	} satisfies SingleResult;
+	const result =
+		finalResult ??
+		({
+			agent: agent.name,
+			task,
+			exitCode: 1,
+			messages: [],
+			usage: emptyUsage(),
+			error: "Subagent did not produce a result.",
+		} satisfies SingleResult);
 	result.usage = aggregateUsage;
 	result.progressSummary = {
 		toolCount: totalToolCount,

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

@@ -7,7 +7,7 @@ export type RunSyncUpdate = AgentToolResult<Details>;
 
 function extractUpdateText(update: RunSyncUpdate): string | undefined {
 	const text = update.content
-		.map((item) => item.type === "text" ? item.text : undefined)
+		.map((item) => (item.type === "text" ? item.text : undefined))
 		.filter((item): item is string => Boolean(item?.trim()))
 		.join("\n");
 	return text || undefined;
@@ -19,10 +19,7 @@ function terminalUpdateFailureText(update: RunSyncUpdate): string | undefined {
 	const progress = update.details?.progress?.[0];
 	const status = result.progress?.status ?? progress?.status;
 	if (status !== "failed") return undefined;
-	return result.error
-		?? result.progress?.error
-		?? progress?.error
-		?? extractUpdateText(update);
+	return result.error ?? result.progress?.error ?? progress?.error ?? extractUpdateText(update);
 }
 
 export function shouldSuppressIntermediateRetryableFailureUpdate(update: RunSyncUpdate): boolean {

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

@@ -36,15 +36,20 @@ export function snapshotProgress(progress: AgentProgress): AgentProgress {
 export function snapshotResult(result: SingleResult, progress: AgentProgress): SingleResult {
 	return {
 		...result,
-		messages: result.outputMode === "file-only" && result.savedOutputPath ? undefined : result.messages ? [...result.messages] : undefined,
+		messages:
+			result.outputMode === "file-only" && result.savedOutputPath
+				? undefined
+				: result.messages
+					? [...result.messages]
+					: undefined,
 		usage: { ...result.usage },
 		skills: result.skills ? [...result.skills] : undefined,
 		attemptedModels: result.attemptedModels ? [...result.attemptedModels] : undefined,
 		modelAttempts: result.modelAttempts
 			? result.modelAttempts.map((attempt) => ({
-				...attempt,
-				usage: attempt.usage ? { ...attempt.usage } : undefined,
-			}))
+					...attempt,
+					usage: attempt.usage ? { ...attempt.usage } : undefined,
+				}))
 			: undefined,
 		controlEvents: result.controlEvents ? result.controlEvents.map((event) => ({ ...event })) : undefined,
 		progress,

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

@@ -1,9 +1,19 @@
 import { randomUUID } from "node:crypto";
 import { APP_NAME } from "@bastani/atomic";
-import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
-import { collectKnownModelProviders, toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
 import { normalizeSkillInput } from "../../agents/skills.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
+import {
+	requestSupervisorAuthorization,
+	type SupervisorAuthorization,
+} from "../../intercom/supervisor-authorization.ts";
+import { collectKnownModelProviders, type ModelInfo, toModelInfo } from "../../shared/model-info.ts";
+import {
+	type ChainStep,
+	isDynamicParallelStep,
+	isParallelStep,
+	resolveSingleProgress,
+	type SequentialStep,
+} from "../../shared/settings.ts";
 import {
 	resolveChildMaxSubagentDepth,
 	resolveSubagentDepthPolicy,
@@ -12,14 +22,21 @@ import {
 	workflowSessionMetadataFromContext,
 	wrapForkTask,
 } from "../../shared/types.ts";
-import { isDynamicParallelStep, isParallelStep, resolveSingleProgress, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
+import { inheritedIntercomGroup } from "../shared/intercom-group.ts";
+import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.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";
-import { buildChainWorktreeTaskCwdError, buildParallelModeError, buildParallelWorktreeTaskCwdError } from "./subagent-executor-worktree.ts";
-import { requestSupervisorAuthorization, type SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
+import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
+import {
+	buildChainWorktreeTaskCwdError,
+	buildParallelModeError,
+	buildParallelWorktreeTaskCwdError,
+} from "./subagent-executor-worktree.ts";
 
-async function authorizeChild(deps: ResolvedExecutorDeps, childName: string | undefined): Promise<SupervisorAuthorization | undefined> {
+async function authorizeChild(
+	deps: ResolvedExecutorDeps,
+	childName: string | undefined,
+): Promise<SupervisorAuthorization | undefined> {
 	return await requestSupervisorAuthorization(deps.pi.events, childName);
 }
 
@@ -41,14 +58,12 @@ async function authorizeAsyncChain(
 			authorizations.push(undefined);
 
 			const count = Math.max(0, dynamicMaxItems ?? 0);
-			dynamic[stepIndex] = (await Promise.all(
-				Array.from({ length: count }, () => authorizeChild(deps, "*")),
-			)).filter((value): value is SupervisorAuthorization => value !== undefined);
+			dynamic[stepIndex] = (
+				await Promise.all(Array.from({ length: count }, () => authorizeChild(deps, "*")))
+			).filter((value): value is SupervisorAuthorization => value !== undefined);
 			continue;
 		}
-		const agents = isParallelStep(step)
-			? step.parallel.map((task) => task.agent)
-			: [(step as SequentialStep).agent];
+		const agents = isParallelStep(step) ? step.parallel.map((task) => task.agent) : [(step as SequentialStep).agent];
 		for (let index = 0; index < agents.length; index++) {
 			authorizations.push(await authorizeChild(deps, "*"));
 		}
@@ -59,8 +74,10 @@ async function authorizeAsyncChain(
 	};
 }
 
-
-export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExecutorDeps): Promise<import("../../shared/types.ts").SubagentToolResult | null> {
+export async function runAsyncPath(
+	data: ExecutionContextData,
+	deps: ResolvedExecutorDeps,
+): Promise<import("../../shared/types.ts").SubagentToolResult | null> {
 	const {
 		params,
 		effectiveCwd,
@@ -105,7 +122,12 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 
 	if (!deps.runtime.isAsyncAvailable()) {
 		return {
-			content: [{ type: "text", text: `Async mode requires upstream jiti for TypeScript execution but it could not be found. Ensure the ${APP_NAME}-subagents package dependencies are installed.` }],
+			content: [
+				{
+					type: "text",
+					text: `Async 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: "single" as const, results: [] },
 		};
@@ -118,6 +140,7 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 		currentModelProvider: ctx.model?.provider,
 		currentModel: currentModelFullId(ctx.model),
 		workflowSessionMetadata: workflowSessionMetadataFromContext(ctx),
+		intercomGroup: inheritedIntercomGroup(ctx),
 	};
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
 	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
@@ -126,7 +149,9 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 	const workflowStageSubagentGuard = depthPolicy.workflowStageSubagentGuard;
 	const currentProvider = ctx.model?.provider;
 	const controlIntercomTarget = intercomBridge.active ? intercomBridge.orchestratorTarget : undefined;
-	const childIntercomTarget = intercomBridge.active ? (agent: string, index: number) => resolveSubagentIntercomTarget(id, agent, index) : undefined;
+	const childIntercomTarget = intercomBridge.active
+		? (agent: string, index: number) => resolveSubagentIntercomTarget(id, agent, index)
+		: undefined;
 
 	if (hasTasks && params.tasks) {
 		const agentConfigs = params.tasks.map((task) => agents.find((agent) => agent.name === task.agent));
@@ -138,23 +163,36 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 			agent: task.agent,
 			task: params.context === "fork" ? wrapForkTask(task.task) : task.task,
 			cwd: task.cwd,
+			group: task.group,
 			...(modelOverrides[index] ? { model: modelOverrides[index] } : {}),
 			...(skillOverrides[index] !== undefined ? { skill: skillOverrides[index] } : {}),
-			...(task.output === true ? (agentConfigs[index]?.output ? { output: agentConfigs[index]!.output } : {}) : task.output !== undefined ? { output: task.output } : {}),
+			...(task.output === true
+				? agentConfigs[index]?.output
+					? { output: agentConfigs[index]!.output }
+					: {}
+				: task.output !== undefined
+					? { output: task.output }
+					: {}),
 			...(task.outputMode !== undefined ? { outputMode: task.outputMode } : {}),
 			...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
 			...(task.progress !== undefined ? { progress: task.progress } : {}),
 		}));
 		const supervisorAuthorizations = childIntercomTarget
-			? await Promise.all(params.tasks.map((task, index) => authorizeChild(deps, childIntercomTarget(task.agent, index))))
+			? await Promise.all(
+					params.tasks.map((task, index) => authorizeChild(deps, childIntercomTarget(task.agent, index))),
+				)
 			: undefined;
 		return deps.runtime.executeAsyncChain(id, {
-			chain: [{
-				parallel: parallelTasks,
-				concurrency: resolveTopLevelParallelConcurrency(params.concurrency, deps.config.parallel?.concurrency),
-				worktree: params.worktree,
-			}],
+			chain: [
+				{
+					parallel: parallelTasks,
+					group: params.group,
+					concurrency: resolveTopLevelParallelConcurrency(params.concurrency, deps.config.parallel?.concurrency),
+					worktree: params.worktree,
+				},
+			],
 			resultMode: "parallel",
+			group: params.group,
 			agents,
 			ctx: asyncCtx,
 			availableModels,
@@ -192,6 +230,7 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 		return deps.runtime.executeAsyncChain(id, {
 			chain,
 			task: params.task,
+			group: params.group,
 			agents,
 			ctx: asyncCtx,
 			availableModels,
@@ -233,7 +272,11 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 		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 = resolveModelCandidate(
+			(params.model as string | undefined) ?? a.model,
+			availableModels,
+			currentProvider,
+		);
 		const progress = resolveSingleProgress(a, params.progress, params.task);
 		const supervisorAuthorization = childIntercomTarget
 			? await authorizeChild(deps, childIntercomTarget(params.agent!, 0))
@@ -241,6 +284,7 @@ export async function runAsyncPath(data: ExecutionContextData, deps: ResolvedExe
 		return deps.runtime.executeAsyncSingle(id, {
 			agent: params.agent!,
 			task: params.context === "fork" ? wrapForkTask(params.task ?? "") : (params.task ?? ""),
+			group: params.group,
 			agentConfig: a,
 			ctx: asyncCtx,
 			availableModels,

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

@@ -1,15 +1,24 @@
-import { executeChain } from "./chain-execution.ts";
 import { normalizeSkillInput } from "../../agents/skills.ts";
-import { updateForegroundNestedProjection } from "../shared/nested-events.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
-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 { resolveSubagentDepthPolicy } from "../../shared/types.ts";
+import { compactForegroundDetails } from "../../shared/utils.ts";
+import { updateForegroundNestedProjection } from "../shared/nested-events.ts";
+import { executeChain } from "./chain-execution.ts";
 import { wrapChainTasksForFork } from "./subagent-executor-input.ts";
-import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
+import {
+	createForegroundControlNotifier,
+	maybeBuildForegroundIntercomReceipt,
+	notifyDetachedForegroundChildExit,
+	rememberForegroundRun,
+	replaceForegroundRunChild,
+} from "./subagent-executor-status.ts";
+import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
 
-export async function runChainPath(data: ExecutionContextData, deps: ResolvedExecutorDeps): Promise<import("../../shared/types.ts").SubagentToolResult> {
+export async function runChainPath(
+	data: ExecutionContextData,
+	deps: ResolvedExecutorDeps,
+): Promise<import("../../shared/types.ts").SubagentToolResult> {
 	const {
 		params,
 		effectiveCwd,
@@ -37,6 +46,7 @@ export async function runChainPath(data: ExecutionContextData, deps: ResolvedExe
 	const chainResult = await executeChain({
 		chain,
 		task: params.task,
+		group: params.group,
 		agents,
 		ctx,
 		intercomEvents: deps.pi.events,
@@ -64,22 +74,29 @@ 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),
+		onDetachedExit: (index, result) => {
+			replaceForegroundRunChild(deps.state, runId, index, result);
+			notifyDetachedForegroundChildExit({ pi: deps.pi, runId, mode: "chain", index, result });
+		},
 	});
 
 	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 });
-	const intercomReceipt = chainDetails && !chainDetails.results.some((result) => result.interrupted || result.detached)
-		? await maybeBuildForegroundIntercomReceipt({
-			pi: deps.pi,
-			intercomBridge: data.intercomBridge,
-			runId,
-			mode: "chain",
-			details: chainDetails,
-			...(foregroundControl?.nestedChildren?.length ? { nestedChildren: foregroundControl.nestedChildren } : {}),
-		})
-		: null;
+	if (chainDetails)
+		rememberForegroundRun(deps.state, { runId, mode: "chain", cwd: effectiveCwd, results: chainDetails.results });
+	const intercomReceipt =
+		chainDetails && !chainDetails.results.some((result) => result.interrupted || result.detached)
+			? await maybeBuildForegroundIntercomReceipt({
+					pi: deps.pi,
+					intercomBridge: data.intercomBridge,
+					runId,
+					mode: "chain",
+					details: chainDetails,
+					...(foregroundControl?.nestedChildren?.length
+						? { nestedChildren: foregroundControl.nestedChildren }
+						: {}),
+				})
+			: null;
 	if (intercomReceipt) {
 		return {
 			...chainResult,