@bastani/atomic 0.9.15 → 0.9.16-alpha.2

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

@@ -0,0 +1,403 @@
+import { isDeepStrictEqual } from "node:util";
+import type { ExtensionContext } from "@bastani/atomic";
+import type { SingleResult, SubagentToolResult } from "../../shared/types.js";
+import { getSingleResultOutput } from "../../shared/utils.js";
+import { formatParallelResultContent } from "../shared/parallel-utils.js";
+import { formatParentAskHandoffOutput } from "./parent-ask-output.js";
+import { registerBurstDisplay, updateBurstDisplay } from "./subagent-executor-burst-display.js";
+import { resolveRequestedCwd } from "./subagent-executor-cwd.js";
+import { getLiveResultIndices } from "./subagent-executor-live-update.js";
+import { getParentAskHandoff } from "./subagent-executor-parent-ask-projection.js";
+import {
+	BURST_TASK_DISCOVERY_CWD,
+	type BurstTaskParam,
+	type SubagentParamsLike,
+	type TaskParam,
+} from "./subagent-executor-types.js";
+
+interface BurstItem {
+	id: string;
+	params: SubagentParamsLike;
+	signal: AbortSignal;
+	onUpdate?: (result: SubagentToolResult) => void;
+	ctx: ExtensionContext;
+	settled: boolean;
+	resolve: (result: SubagentToolResult) => void;
+	reject: (reason?: unknown) => void;
+}
+
+interface ResultRoute {
+	start: number;
+	length: number;
+}
+
+type ExecuteSubagent = (
+	id: string,
+	params: SubagentParamsLike,
+	signal: AbortSignal,
+	onUpdate: ((result: SubagentToolResult) => void) | undefined,
+	ctx: ExtensionContext,
+) => Promise<SubagentToolResult>;
+
+type SharedField =
+	| "concurrency"
+	| "worktree"
+	| "context"
+	| "share"
+	| "control"
+	| "sessionDir"
+	| "maxOutput"
+	| "artifacts"
+	| "includeProgress"
+	| "agentScope";
+
+const SHARED_FIELDS: readonly SharedField[] = [
+	"concurrency",
+	"worktree",
+	"context",
+	"share",
+	"control",
+	"sessionDir",
+	"maxOutput",
+	"artifacts",
+	"includeProgress",
+	"agentScope",
+];
+
+function incompatibleField(items: BurstItem[]): SharedField | undefined {
+	const first = items[0]!.params;
+	for (const field of SHARED_FIELDS) {
+		for (let index = 1; index < items.length; index++) {
+			if (!isDeepStrictEqual(first[field], items[index]!.params[field])) return field;
+		}
+	}
+	return undefined;
+}
+
+function incompatibleFieldResult(field: SharedField): SubagentToolResult {
+	return {
+		content: [
+			{
+				type: "text",
+				text: `Cannot coalesce sibling subagent calls: incompatible top-level field '${field}'.`,
+			},
+		],
+		isError: true,
+		details: { mode: "parallel", results: [] },
+	};
+}
+
+function incompatibleWorktreeCwdResult(): SubagentToolResult {
+	return {
+		content: [
+			{
+				type: "text",
+				text: "Cannot coalesce sibling subagent calls: incompatible top-level field 'cwd' for worktree.",
+			},
+		],
+		isError: true,
+		details: { mode: "parallel", results: [] },
+	};
+}
+
+function taskExpandedLength(task: TaskParam): number {
+	const count = task.count;
+	return typeof count === "number" && Number.isInteger(count) && count >= 1 ? count : 1;
+}
+
+function originatingCallCwd(item: BurstItem): string {
+	return resolveRequestedCwd(item.ctx.cwd, item.params.cwd);
+}
+
+function originatingTaskCwd(callCwd: string, taskCwd: string | undefined): string {
+	return resolveRequestedCwd(callCwd, taskCwd);
+}
+
+function topLevelSingleTask(item: BurstItem): BurstTaskParam | undefined {
+	if (!item.params.agent) return undefined;
+	const callCwd = originatingCallCwd(item);
+	return {
+		agent: item.params.agent,
+		task: item.params.task ?? "",
+		cwd: originatingTaskCwd(callCwd, undefined),
+		[BURST_TASK_DISCOVERY_CWD]: callCwd,
+		...(item.params.output !== undefined ? { output: item.params.output } : {}),
+		...(item.params.outputMode !== undefined ? { outputMode: item.params.outputMode } : {}),
+		...(item.params.reads !== undefined ? { reads: item.params.reads } : {}),
+		...(item.params.progress !== undefined ? { progress: item.params.progress } : {}),
+		...(item.params.model !== undefined ? { model: item.params.model } : {}),
+		...(item.params.skill !== undefined ? { skill: item.params.skill } : {}),
+		...(item.params.group !== undefined ? { group: item.params.group } : {}),
+	};
+}
+
+function existingParallelTask(item: BurstItem, task: TaskParam): BurstTaskParam {
+	const callCwd = originatingCallCwd(item);
+	return {
+		...task,
+		cwd: originatingTaskCwd(callCwd, task.cwd),
+		[BURST_TASK_DISCOVERY_CWD]: callCwd,
+		...(task.group === undefined && item.params.group !== undefined ? { group: item.params.group } : {}),
+	};
+}
+
+function mergeBurst(items: BurstItem[]): {
+	params?: SubagentParamsLike;
+	routes?: ResultRoute[];
+	error?: SubagentToolResult;
+} {
+	const field = incompatibleField(items);
+	if (field) return { error: incompatibleFieldResult(field) };
+	const callCwds = items.map(originatingCallCwd);
+	const commonCwd = callCwds.every((cwd) => cwd === callCwds[0]) ? callCwds[0] : undefined;
+	if (items[0]!.params.worktree === true && commonCwd === undefined) return { error: incompatibleWorktreeCwdResult() };
+
+	const tasks: TaskParam[] = [];
+	const routes: ResultRoute[] = [];
+	for (const item of items) {
+		const start = tasks.reduce((total, task) => total + taskExpandedLength(task), 0);
+		const single = topLevelSingleTask(item);
+		if (single) tasks.push(single);
+		for (const task of item.params.tasks ?? []) tasks.push(existingParallelTask(item, task));
+		const end = tasks.reduce((total, task) => total + taskExpandedLength(task), 0);
+		routes.push({ start, length: end - start });
+	}
+
+	const first = items[0]!.params;
+	return {
+		params: {
+			...(commonCwd ? { cwd: commonCwd } : {}),
+			tasks,
+			concurrency: first.concurrency,
+			worktree: first.worktree,
+			context: first.context,
+			share: first.share,
+			control: first.control,
+			sessionDir: first.sessionDir,
+			maxOutput: first.maxOutput,
+			artifacts: first.artifacts,
+			includeProgress: first.includeProgress,
+			agentScope: first.agentScope,
+		},
+		routes,
+	};
+}
+function formatStandardParallelContent(results: SingleResult[]): string {
+	return formatParallelResultContent(
+		results.map((child) => ({
+			agent: child.agent,
+			output: child.truncation?.text || getSingleResultOutput(child),
+			status: child.status,
+			error: child.error,
+		})),
+		(index, agent) => `=== Task ${index + 1}: ${agent} ===`,
+	);
+}
+
+function projectParentAskContent(
+	result: SubagentToolResult,
+	route: ResultRoute,
+	projectedResults: SingleResult[],
+): SubagentToolResult["content"] | undefined {
+	const handoff = getParentAskHandoff(result);
+	if (!handoff) return undefined;
+	const originalItem =
+		result.content.length === 1 && result.content[0]?.type === "text"
+			? result.content[0]
+			: { type: "text" as const, text: "" };
+	const routeEnd = route.start + route.length;
+	const inRoute = (index: number): boolean => index >= route.start && index < routeEnd;
+	if (!inRoute(handoff.askingChildIndex)) {
+		return [{ ...originalItem, text: formatStandardParallelContent(projectedResults) }];
+	}
+	const projectIndex = (index: number): number => index - route.start;
+	return [
+		{
+			...originalItem,
+			text: formatParentAskHandoffOutput({
+				...handoff,
+				askingChildIndex: projectIndex(handoff.askingChildIndex),
+				releasedChildIndices: handoff.releasedChildIndices.filter(inRoute).map(projectIndex),
+				unlaunchedChildIndices: handoff.unlaunchedChildIndices.filter(inRoute).map(projectIndex),
+				request: { ...handoff.request, index: projectIndex(handoff.request.index) },
+			}),
+		},
+	];
+}
+
+function projectParallelContent(
+	result: SubagentToolResult,
+	sharedResults: SingleResult[],
+	projectedResults: SingleResult[],
+	route: ResultRoute,
+	live: boolean,
+): SubagentToolResult["content"] {
+	const projectedText = formatStandardParallelContent(projectedResults);
+	if (live) return [{ type: "text", text: projectedText }];
+	const parentAskContent = projectParentAskContent(result, route, projectedResults);
+	if (parentAskContent) return parentAskContent;
+	if (result.content.length !== 1 || result.content[0]?.type !== "text") return result.content;
+	const originalItem = result.content[0];
+	const originalText = originalItem.text;
+	const sharedText = formatStandardParallelContent(sharedResults);
+	if (originalText === sharedText) return [{ ...originalItem, text: projectedText }];
+	if (originalText.startsWith(`${sharedText}\n\n`)) {
+		return [{ ...originalItem, text: `${projectedText}${originalText.slice(sharedText.length)}` }];
+	}
+	return result.content;
+}
+
+function projectResult(result: SubagentToolResult, route: ResultRoute, live = false): SubagentToolResult {
+	const sharedDetails = result.details;
+	if (!sharedDetails || (!live && sharedDetails.results.length === 0)) return result;
+
+	const liveIndices = live ? getLiveResultIndices(result) : undefined;
+	const results = liveIndices
+		? sharedDetails.results.filter((_child, index) => {
+				const resultIndex = liveIndices[index];
+				return resultIndex !== undefined && resultIndex >= route.start && resultIndex < route.start + route.length;
+			})
+		: sharedDetails.results.slice(route.start, route.start + route.length);
+	const progress = sharedDetails.progress
+		?.filter((item) => item.index >= route.start && item.index < route.start + route.length)
+		.map((item) => ({ ...item, index: item.index - route.start }));
+	const controlEvents = sharedDetails.controlEvents
+		?.filter(
+			(event) => event.index !== undefined && event.index >= route.start && event.index < route.start + route.length,
+		)
+		.map((event) => ({ ...event, index: event.index! - route.start }));
+	const artifactFiles = results.flatMap((child) => (child.artifactPaths ? [child.artifactPaths] : []));
+
+	return {
+		content: projectParallelContent(result, sharedDetails.results, results, route, live),
+		...(result.isError !== undefined ? { isError: result.isError } : {}),
+		details: {
+			mode: "parallel",
+			...(sharedDetails.runId !== undefined ? { runId: sharedDetails.runId } : {}),
+			...(sharedDetails.context !== undefined ? { context: sharedDetails.context } : {}),
+			results,
+			...(progress?.length ? { progress } : {}),
+			...(controlEvents?.length ? { controlEvents } : {}),
+			...(sharedDetails.totalSteps !== undefined ? { totalSteps: route.length } : {}),
+			...(sharedDetails.parentAskYielded !== undefined ? { parentAskYielded: sharedDetails.parentAskYielded } : {}),
+			...(sharedDetails.artifacts && artifactFiles.length
+				? { artifacts: { dir: sharedDetails.artifacts.dir, files: artifactFiles } }
+				: {}),
+		},
+	};
+}
+
+function resolveItem(item: BurstItem, result: SubagentToolResult): void {
+	if (item.settled) return;
+	item.settled = true;
+	item.resolve(result);
+}
+
+function rejectItem(item: BurstItem, reason: unknown): void {
+	if (item.settled) return;
+	item.settled = true;
+	item.reject(reason);
+}
+
+function observeLaterAbort(item: BurstItem): () => void {
+	let listening = false;
+	const cleanup = (): void => {
+		if (!listening) return;
+		listening = false;
+		item.signal.removeEventListener("abort", onAbort);
+	};
+	const onAbort = (): void => {
+		cleanup();
+		const reason = item.signal.reason;
+		rejectItem(item, reason === undefined ? new DOMException("The operation was aborted", "AbortError") : reason);
+	};
+	if (item.signal.aborted) {
+		onAbort();
+	} else {
+		listening = true;
+		item.signal.addEventListener("abort", onAbort, { once: true });
+		if (item.signal.aborted) onAbort();
+	}
+	return cleanup;
+}
+
+export function createExecutionBurstDispatcher(input: {
+	execute: ExecuteSubagent;
+	isActive: () => boolean;
+	setActive: (active: boolean) => void;
+	duplicateResult: (params: SubagentParamsLike) => SubagentToolResult;
+}): ExecuteSubagent {
+	let queue: BurstItem[] = [];
+	let flushScheduled = false;
+
+	const run = async (items: BurstItem[]): Promise<void> => {
+		if (items.length === 1) {
+			const item = items[0]!;
+			input.setActive(true);
+			try {
+				item.resolve(await input.execute(item.id, item.params, item.signal, item.onUpdate, item.ctx));
+			} catch (error) {
+				item.reject(error instanceof Error ? error : new Error(String(error)));
+			} finally {
+				input.setActive(false);
+			}
+			return;
+		}
+
+		const abortCleanups = items.slice(1).map(observeLaterAbort);
+		const cleanupLaterAborts = (): void => {
+			for (const cleanup of abortCleanups) cleanup();
+		};
+		const merged = mergeBurst(items);
+		if (merged.error) {
+			for (const item of items) resolveItem(item, merged.error);
+			cleanupLaterAborts();
+			return;
+		}
+
+		const first = items[0]!;
+		const display = registerBurstDisplay(
+			items.map((item) => item.id),
+			merged.routes!.reduce((total, route) => total + route.length, 0),
+		);
+		const onUpdate = (update: SubagentToolResult): void => {
+			updateBurstDisplay(display, update);
+			for (let index = 0; index < items.length; index++) {
+				const item = items[index]!;
+				if (!item.settled) item.onUpdate?.(projectResult(update, merged.routes![index]!, true));
+			}
+		};
+		input.setActive(true);
+		try {
+			const result = await input.execute(first.id, merged.params!, first.signal, onUpdate, first.ctx);
+			updateBurstDisplay(display, result);
+			for (let index = 0; index < items.length; index++) {
+				resolveItem(items[index]!, projectResult(result, merged.routes![index]!));
+			}
+		} catch (error) {
+			const rejection = error instanceof Error ? error : new Error(String(error));
+			for (const item of items) rejectItem(item, rejection);
+		} finally {
+			input.setActive(false);
+			cleanupLaterAborts();
+		}
+	};
+
+	const flush = (): void => {
+		flushScheduled = false;
+		const items = queue;
+		queue = [];
+		void run(items);
+	};
+
+	return (id, params, signal, onUpdate, ctx) => {
+		if (input.isActive()) return Promise.resolve(input.duplicateResult(params));
+		return new Promise<SubagentToolResult>((resolve, reject) => {
+			queue.push({ id, params, signal, onUpdate, ctx, settled: false, resolve, reject });
+			if (!flushScheduled) {
+				flushScheduled = true;
+				setImmediate(flush);
+			}
+		});
+	};
+}

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

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionContext } from "@bastani/atomic";
 import { resolveExecutionAgentScope } from "../../agents/agent-scope.js";
+import type { AgentConfig } from "../../agents/agents.js";
 import {
 	applyIntercomBridgeToAgent,
 	resolveIntercomBridge,
@@ -29,11 +30,14 @@ import {
 	validateExecutionInput,
 	withForkContext,
 } from "./subagent-executor-input.js";
-import type {
-	ExecutionContextBuildResult,
-	ExecutorDeps,
-	ResolvedExecutorDeps,
-	SubagentParamsLike,
+import {
+	BURST_TASK_DISCOVERY_CWD,
+	type BurstTaskParam,
+	type ExecutionContextBuildResult,
+	type ExecutionContextData,
+	type ExecutorDeps,
+	type ResolvedExecutorDeps,
+	type SubagentParamsLike,
 } from "./subagent-executor-types.js";
 
 /**
@@ -71,8 +75,39 @@ export function prepareExecutionContext(input: {
 	const effectiveCwd = effectiveParams.cwd ?? ctx.cwd;
 	const parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
 	deps.state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
-	const discoveredAgents = deps.discoverAgents(effectiveCwd, scope).agents;
-	effectiveParams = applyAgentDefaultContext(effectiveParams, discoveredAgents);
+	const initialDiscoveryCwd =
+		(effectiveParams.tasks?.[0] as BurstTaskParam | undefined)?.[BURST_TASK_DISCOVERY_CWD] ?? effectiveCwd;
+	const discoveredAgents = deps.discoverAgents(initialDiscoveryCwd, scope).agents;
+	let resolvedTaskAgents: AgentConfig[] | undefined;
+	if (effectiveParams.tasks?.some((task) => (task as BurstTaskParam)[BURST_TASK_DISCOVERY_CWD] !== undefined)) {
+		const agentsByCwd = new Map<string, AgentConfig[]>([[initialDiscoveryCwd, discoveredAgents]]);
+		resolvedTaskAgents = [];
+		for (let index = 0; index < effectiveParams.tasks.length; index++) {
+			const task = effectiveParams.tasks[index]!;
+			const discoveryCwd = (task as BurstTaskParam)[BURST_TASK_DISCOVERY_CWD] ?? effectiveCwd;
+			let taskAgents = agentsByCwd.get(discoveryCwd);
+			if (!taskAgents) {
+				taskAgents = deps.discoverAgents(discoveryCwd, scope).agents;
+				agentsByCwd.set(discoveryCwd, taskAgents);
+			}
+			const agent = taskAgents.find((candidate) => candidate.name === task.agent);
+			if (!agent) {
+				return {
+					error: {
+						content: [{ type: "text", text: `Unknown agent: ${task.agent} (task ${index + 1})` }],
+						isError: true,
+						details: { mode: "parallel", results: [] },
+					},
+				};
+			}
+			resolvedTaskAgents.push(agent);
+		}
+	}
+	if (effectiveParams.context === undefined && resolvedTaskAgents?.some((agent) => agent.defaultContext === "fork")) {
+		effectiveParams = { ...effectiveParams, context: "fork" };
+	} else {
+		effectiveParams = applyAgentDefaultContext(effectiveParams, discoveredAgents);
+	}
 	const sessionName = resolveIntercomSessionTarget(deps.pi.getSessionName(), ctx.sessionManager.getSessionId());
 	const intercomBridge = resolveIntercomBridge({
 		config: deps.config.intercomBridge,
@@ -83,11 +118,14 @@ export function prepareExecutionContext(input: {
 	const agents = intercomBridge.active
 		? discoveredAgents.map((agent) => applyIntercomBridgeToAgent(agent, intercomBridge))
 		: discoveredAgents;
+	const parallelAgentConfigs = intercomBridge.active
+		? resolvedTaskAgents?.map((agent) => applyIntercomBridgeToAgent(agent, intercomBridge))
+		: resolvedTaskAgents;
 	const runId = randomUUID().slice(0, 8);
 	const shareEnabled = effectiveParams.share === true;
 	const hasTasks = (effectiveParams.tasks?.length ?? 0) > 0;
 	const hasSingle = !hasTasks && Boolean(effectiveParams.agent);
-	const validationError = validateExecutionInput(effectiveParams, agents, hasTasks, hasSingle);
+	const validationError = validateExecutionInput(effectiveParams, agents, hasTasks, hasSingle, parallelAgentConfigs);
 	if (validationError) return { error: validationError };
 	if (hasSingle) {
 		const readInstruction = buildReadInstruction(effectiveParams.reads, effectiveCwd);
@@ -137,13 +175,14 @@ export function prepareExecutionContext(input: {
 		? (r: SubagentToolResult) => onUpdate(withForkContext(r, effectiveParams.context))
 		: undefined;
 
-	const execData = {
+	const execData: ExecutionContextData = {
 		params: effectiveParams,
 		effectiveCwd,
 		ctx,
 		signal,
 		onUpdate: onUpdateWithContext,
 		agents,
+		...(parallelAgentConfigs ? { parallelAgentConfigs } : {}),
 		runId,
 		shareEnabled,
 		sessionRoot,

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

@@ -7,6 +7,7 @@ export function validateExecutionInput(
 	agents: AgentConfig[],
 	hasTasks: boolean,
 	hasSingle: boolean,
+	parallelAgentConfigs?: AgentConfig[],
 ): SubagentToolResult | null {
 	if (Number(hasTasks) + Number(hasSingle) !== 1) {
 		return {
@@ -47,7 +48,8 @@ export function validateExecutionInput(
 	if (hasTasks && params.tasks) {
 		for (let i = 0; i < params.tasks.length; i++) {
 			const task = params.tasks[i]!;
-			if (!agents.find((agent) => agent.name === task.agent)) {
+			const agent = parallelAgentConfigs?.[i] ?? agents.find((candidate) => candidate.name === task.agent);
+			if (!agent || agent.name !== task.agent) {
 				return {
 					content: [{ type: "text", text: `Unknown agent: ${task.agent} (task ${i + 1})` }],
 					isError: true,

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

@@ -0,0 +1,11 @@
+import type { SubagentToolResult } from "../../shared/types.js";
+
+const liveResultIndices = new WeakMap<SubagentToolResult, readonly number[]>();
+
+export function markLiveResultIndices(result: SubagentToolResult, indices: readonly number[]): void {
+	liveResultIndices.set(result, indices);
+}
+
+export function getLiveResultIndices(result: SubagentToolResult): readonly number[] | undefined {
+	return liveResultIndices.get(result);
+}