@bastani/atomic 0.9.13-alpha.1 → 0.9.13-alpha.3

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

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { normalizeSkillInput } from "../../agents/skills.ts";
 import { INTERCOM_BRIDGE_MARKER, resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import { collectKnownModelProviders, type ModelInfo, toModelInfo } from "../../shared/model-info.ts";
+import { createCandidateModelResolver } from "../../shared/model-resolution.ts";
 import {
 	injectSingleProgressInstruction,
 	resolveSingleProgress,
@@ -20,7 +21,7 @@ import {
 } from "../../shared/types.ts";
 import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.ts";
 import { updateForegroundNestedProjection } from "../inprocess/runtime-support/nested-api.ts";
-import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.ts";
+import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.js";
 import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
 import { recordRun } from "../shared/run-history.ts";
 import {
@@ -37,7 +38,7 @@ import {
 	rememberForegroundRun,
 	replaceForegroundRunChild,
 } from "./subagent-executor-status.ts";
-import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
+import type { ExecutionContextData, ForegroundControl, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
 
 function formatFailedSingleRunOutput(result: SingleResult, displayOutput: string): string {
 	const error = result.error || "Failed";
@@ -61,6 +62,32 @@ function cleanupTransientProgress(progressDir: string | undefined, artifactsEnab
 	}
 }
 
+export function createForwardSingleUpdate(
+	onUpdate: ((r: SubagentToolResult) => void) | undefined,
+	foregroundControl: ForegroundControl | undefined,
+	agent: string,
+	index: number,
+): ((r: SubagentToolResult) => void) | undefined {
+	if (!onUpdate) return undefined;
+	return (update: SubagentToolResult) => {
+		if (foregroundControl) {
+			const firstProgress = update.details?.progress?.[0];
+			foregroundControl.currentAgent = agent;
+			foregroundControl.currentIndex = firstProgress?.index ?? index;
+			foregroundControl.currentActivityState = firstProgress?.activityState;
+			foregroundControl.lastActivityAt = firstProgress?.lastActivityAt;
+			foregroundControl.currentTool = firstProgress?.currentTool;
+			foregroundControl.currentToolStartedAt = firstProgress?.currentToolStartedAt;
+			foregroundControl.currentPath = firstProgress?.currentPath;
+			foregroundControl.turnCount = firstProgress?.turnCount;
+			foregroundControl.tokens = firstProgress?.tokens;
+			foregroundControl.toolCount = firstProgress?.toolCount;
+			foregroundControl.updatedAt = Date.now();
+		}
+		onUpdate(update);
+	};
+}
+
 export async function runSinglePath(
 	data: ExecutionContextData,
 	deps: ResolvedExecutorDeps,
@@ -158,25 +185,7 @@ export async function runSinglePath(
 		};
 	}
 
-	const forwardSingleUpdate = onUpdate
-		? (update: SubagentToolResult) => {
-				if (foregroundControl) {
-					const firstProgress = update.details?.progress?.[0];
-					foregroundControl.currentAgent = params.agent;
-					foregroundControl.currentIndex = firstProgress?.index ?? 0;
-					foregroundControl.currentActivityState = firstProgress?.activityState;
-					foregroundControl.lastActivityAt = firstProgress?.lastActivityAt;
-					foregroundControl.currentTool = firstProgress?.currentTool;
-					foregroundControl.currentToolStartedAt = firstProgress?.currentToolStartedAt;
-					foregroundControl.currentPath = firstProgress?.currentPath;
-					foregroundControl.turnCount = firstProgress?.turnCount;
-					foregroundControl.tokens = firstProgress?.tokens;
-					foregroundControl.toolCount = firstProgress?.toolCount;
-					foregroundControl.updatedAt = Date.now();
-				}
-				onUpdate(update);
-			}
-		: undefined;
+	const forwardSingleUpdate = createForwardSingleUpdate(onUpdate, foregroundControl, params.agent!, 0);
 
 	let r: SingleResult;
 	try {
@@ -196,6 +205,7 @@ export async function runSinglePath(
 			outputPath,
 			outputMode: effectiveOutputMode,
 			maxSubagentDepth,
+			parentDepth: data.parentDepth,
 			workflowStageSubagentGuard,
 			workflowSessionMetadata: workflowSessionMetadataFromContext(ctx),
 			onUpdate: forwardSingleUpdate,
@@ -216,6 +226,7 @@ export async function runSinglePath(
 			modelOverride,
 			availableModels,
 			knownModelProviders,
+			resolveCandidateModel: createCandidateModelResolver(ctx.modelRegistry, currentProvider),
 			preferredModelProvider: currentProvider,
 			currentModel: currentModelFullId(ctx.model),
 			skills: effectiveSkills,
@@ -262,7 +273,13 @@ export async function runSinglePath(
 		artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
 		truncation: r.truncation,
 	});
-	rememberForegroundRun(deps.state, { runId, mode: "single", cwd: effectiveCwd, results: details.results });
+	rememberForegroundRun(deps.state, {
+		runId,
+		mode: "single",
+		cwd: effectiveCwd,
+		results: details.results,
+		maxSubagentDepths: [maxSubagentDepth],
+	});
 
 	if (!r.detached && !r.interrupted) {
 		if (foregroundControl) updateForegroundNestedProjection(foregroundControl);

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

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@bastani/atomic";
+import { type ExtensionAPI, isStaleExtensionContextError } from "@bastani/atomic";
 import { type IntercomBridgeState, resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import {
 	attachNestedChildrenToResultChildren,
@@ -20,7 +20,6 @@ import {
 	type SubagentToolResult,
 } from "../../shared/types.ts";
 import { compactForegroundDetails, compactForegroundResult, getSingleResultOutput } from "../../shared/utils.ts";
-import { deliverLocalCompletionNotification } from "../background/completion-notification.ts";
 import { updateForegroundNestedProjection } from "../inprocess/runtime-support/nested-api.ts";
 import { formatNestedRunStatusLines } from "../inprocess/runtime-support/nested-rendering.ts";
 import {
@@ -28,6 +27,7 @@ import {
 	formatControlNoticeMessage,
 	shouldNotifyControlEvent,
 } from "../shared/subagent-control.ts";
+import { deliverLocalCompletionNotification } from "./completion-notification.ts";
 import type { ExecutionContextData, ExecutorDeps, ForegroundControl } from "./subagent-executor-types.ts";
 
 export function getForegroundControl(state: SubagentState, runId: string | undefined): ForegroundControl | undefined {
@@ -127,7 +127,14 @@ function takeEarlyDetachedResult(state: SubagentState, runId: string, index: num
 
 export function rememberForegroundRun(
 	state: SubagentState,
-	input: { runId: string; mode: "single" | "parallel" | "chain"; cwd: string; results: SingleResult[] },
+	input: {
+		runId: string;
+		mode: "single" | "parallel";
+		cwd: string;
+		results: SingleResult[];
+		/** Effective delegation limit per child, aligned with `results` by index. */
+		maxSubagentDepths?: readonly (number | undefined)[];
+	},
 ): void {
 	state.foregroundRuns ??= new Map();
 	state.foregroundRuns.set(input.runId, {
@@ -137,6 +144,7 @@ export function rememberForegroundRun(
 		updatedAt: Date.now(),
 		children: input.results.map((originalResult, index) => {
 			const result = takeEarlyDetachedResult(state, input.runId, index) ?? originalResult;
+			const maxSubagentDepth = input.maxSubagentDepths?.[index];
 			return {
 				agent: result.agent,
 				index,
@@ -146,6 +154,7 @@ export function rememberForegroundRun(
 					detached: result.detached,
 				}),
 				...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),
+				...(maxSubagentDepth === undefined ? {} : { maxSubagentDepth }),
 				result,
 			};
 		}),
@@ -162,6 +171,7 @@ export function replaceForegroundRunChild(
 	runId: string,
 	index: number,
 	result: SingleResult,
+	options: { onlyWhenDetached?: boolean } = {},
 ): void {
 	const retainedResult = compactForegroundResult(result);
 	const run = state.foregroundRuns?.get(runId);
@@ -190,7 +200,7 @@ export function replaceForegroundRunChild(
 		return;
 	}
 	const child = run.children.find((entry) => entry.index === index);
-	if (child?.status !== "detached") return;
+	if (!child || (options.onlyWhenDetached !== false && child.status !== "detached")) return;
 	child.status = resolveSubagentResultStatus({
 		status: retainedResult.status,
 		interrupted: retainedResult.interrupted,
@@ -218,7 +228,12 @@ export function emitControlNotification(input: {
 		noticeText: formatControlNoticeMessage(input.event, childIntercomTarget),
 	};
 	if (input.controlConfig.notifyChannels.includes("event")) {
-		input.pi.events.emit(SUBAGENT_CONTROL_EVENT, payload);
+		try {
+			input.pi.events.emit(SUBAGENT_CONTROL_EVENT, payload);
+		} catch (error) {
+			if (!isStaleExtensionContextError(error)) throw error;
+			// Control notices are best effort after a parent runtime replacement.
+		}
 	}
 	if (
 		input.event.type !== "active_long_running" &&
@@ -226,11 +241,16 @@ export function emitControlNotification(input: {
 		input.intercomBridge.active &&
 		input.intercomBridge.orchestratorTarget
 	) {
-		input.pi.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
-			...payload,
-			to: input.intercomBridge.orchestratorTarget,
-			message: formatControlIntercomMessage(input.event, childIntercomTarget),
-		});
+		try {
+			input.pi.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
+				...payload,
+				to: input.intercomBridge.orchestratorTarget,
+				message: formatControlIntercomMessage(input.event, childIntercomTarget),
+			});
+		} catch (error) {
+			if (!isStaleExtensionContextError(error)) throw error;
+			// Intercom control notices are best effort after a parent runtime replacement.
+		}
 	}
 }
 
@@ -261,7 +281,7 @@ function resultSummaryForIntercom(result: SingleResult): string {
  * normally return their results inline in the tool result, but a detached
  * child outlives that tool call, so without this the parent never learns the
  * child finished (see run history: detached parallel runs completed silently).
- * Reuses the async completion pipeline (dedupe, ordering barrier, triggerTurn).
+ * Reuses the detached completion pipeline (dedupe, ordering barrier, triggerTurn).
  */
 export function notifyDetachedForegroundChildExit(input: {
 	pi: ExtensionAPI;
@@ -290,7 +310,11 @@ export function notifyDetachedForegroundChildExit(input: {
 			noticeLabel: "Detached subagent task",
 		},
 		`foreground-detach-${runId}-${index}`,
-	);
+	).catch((error) => {
+		if (!isStaleExtensionContextError(error)) {
+			console.error("Failed to emit detached subagent completion notification:", error);
+		}
+	});
 }
 
 async function emitForegroundResultIntercom(input: {
@@ -299,7 +323,6 @@ async function emitForegroundResultIntercom(input: {
 	runId: string;
 	mode: SubagentRunMode;
 	results: SingleResult[];
-	chainSteps?: number;
 	nestedChildren?: NestedRunSummary[];
 }): Promise<ReturnType<typeof buildSubagentResultIntercomPayload> | null> {
 	if (!input.intercomBridge.active || !input.intercomBridge.orchestratorTarget) return null;
@@ -327,9 +350,7 @@ async function emitForegroundResultIntercom(input: {
 		to: input.intercomBridge.orchestratorTarget,
 		runId: input.runId,
 		mode: input.mode,
-		source: "foreground",
 		children: attachNestedChildrenToResultChildren(input.runId, children, input.nestedChildren),
-		...(typeof input.chainSteps === "number" ? { chainSteps: input.chainSteps } : {}),
 	});
 	const delivered = await deliverSubagentResultIntercomEvent(input.pi.events, payload);
 	if (!delivered) return null;
@@ -350,7 +371,6 @@ export async function maybeBuildForegroundIntercomReceipt(input: {
 		runId: input.runId,
 		mode: input.mode,
 		results: input.details.results,
-		...(typeof input.details.totalSteps === "number" ? { chainSteps: input.details.totalSteps } : {}),
 		...(input.nestedChildren?.length ? { nestedChildren: input.nestedChildren } : {}),
 	});
 	if (!payload) return null;

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

@@ -2,7 +2,6 @@ import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
 import type { AgentConfig, AgentScope } from "../../agents/agents.ts";
 import type { IntercomBridgeState } from "../../intercom/intercom-bridge.ts";
 import type { ModelInfo } from "../../shared/model-info.ts";
-import type { ChainStep } from "../../shared/settings.ts";
 import type {
 	ArtifactConfig,
 	ControlConfig,
@@ -13,12 +12,6 @@ import type {
 	SubagentState,
 	SubagentToolResult,
 } from "../../shared/types.ts";
-import type {
-	AsyncExecutionResult,
-	AsyncSingleParams,
-	formatAsyncStartedMessage,
-	isAsyncAvailable,
-} from "../inprocess/background.ts";
 import type { ChildModePolicy } from "../inprocess/child-policy.ts";
 import type { runSync } from "./execution.ts";
 
@@ -40,19 +33,15 @@ export interface SubagentParamsLike {
 	action?: (typeof SUBAGENT_ACTIONS)[number];
 	id?: string;
 	runId?: string;
-	dir?: string;
 	index?: number;
 	agent?: string;
 	task?: string;
 	message?: string;
-	chainName?: string;
 	config?: unknown;
-	chain?: ChainStep[];
 	tasks?: TaskParam[];
 	concurrency?: number;
 	worktree?: boolean;
 	context?: "fresh" | "fork";
-	async?: boolean;
 	share?: boolean;
 	control?: ControlConfig;
 	sessionDir?: string;
@@ -68,21 +57,16 @@ export interface SubagentParamsLike {
 	reads?: string[] | false;
 	progress?: boolean;
 	agentScope?: string;
-	chainDir?: string;
 }
 
 export interface SubagentExecutorRuntimeDeps {
 	runSync: typeof runSync;
-	executeAsyncSingle: (id: string, params: AsyncSingleParams) => AsyncExecutionResult | Promise<AsyncExecutionResult>;
-	isAsyncAvailable: typeof isAsyncAvailable;
-	formatAsyncStartedMessage: typeof formatAsyncStartedMessage;
 }
 
 export interface ExecutorDeps {
 	pi: ExtensionAPI;
 	state: SubagentState;
 	config: import("../../shared/types.ts").ExtensionConfig;
-	asyncByDefault: boolean;
 	tempArtifactsDir: string;
 	getSubagentSessionRoot: (parentSessionFile: string | null) => string;
 	expandTilde: (p: string) => string;
@@ -118,7 +102,7 @@ export interface ExecutionContextData {
 	sessionFileForIndex: (idx?: number) => string | undefined;
 	artifactConfig: ArtifactConfig;
 	artifactsDir: string;
-	effectiveAsync: boolean;
+	parentDepth?: number;
 	controlConfig: ResolvedControlConfig;
 	intercomBridge: IntercomBridgeState;
 	nestedRoute?: NestedRouteInfo;
@@ -128,10 +112,9 @@ export interface PreparedExecutionContext {
 	effectiveParams: SubagentParamsLike;
 	effectiveCwd: string;
 	runId: string;
-	hasChain: boolean;
 	hasTasks: boolean;
 	hasSingle: boolean;
-	foregroundMode: "single" | "parallel" | "chain";
+	foregroundMode: "single" | "parallel";
 	execData: ExecutionContextData;
 	foregroundControl?: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never;
 	writeNestedForegroundEvent: (

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

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import { type ChainStep, isParallelStep, type ResolvedStepBehavior } from "../../shared/settings.ts";
+import type { ResolvedStepBehavior } from "../../shared/settings.ts";
 import type { ExtensionConfig, SubagentToolResult } from "../../shared/types.ts";
 import { resolveChildCwd } from "../../shared/utils.ts";
 import { resolveSingleOutputPath } from "../shared/single-output.ts";
@@ -52,19 +52,6 @@ export function buildParallelWorktreeTaskCwdError(
 	return formatWorktreeTaskCwdConflict(conflict, sharedCwd);
 }
 
-export function buildChainWorktreeTaskCwdError(chain: ChainStep[], sharedCwd: string): string | undefined {
-	for (let stepIndex = 0; stepIndex < chain.length; stepIndex++) {
-		const step = chain[stepIndex]!;
-		if (!isParallelStep(step) || !step.worktree) continue;
-		const stepCwd = resolveChildCwd(sharedCwd, step.cwd);
-		const conflict = findWorktreeTaskCwdConflict(step.parallel, stepCwd);
-		if (!conflict) continue;
-		const detail = formatWorktreeTaskCwdConflict(conflict, stepCwd);
-		return `parallel chain step ${stepIndex + 1}: ${detail}`;
-	}
-	return undefined;
-}
-
 export function resolveParallelTaskCwd(
 	task: TaskParam,
 	paramsCwd: string,