@bastani/atomic 0.9.13-alpha.2 → 0.9.13-alpha.4

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

@@ -199,6 +199,11 @@ export async function runSingleInProcess(
 		return noSpawnableCandidatesResult(agent, task, filteredCandidates.skippedAttempts);
 	const candidate = filteredCandidates.candidates[0];
 	const fallbackCandidates = filteredCandidates.candidates.slice(1);
+	// The candidate is only a string. `createAgentSession` selects a model from a
+	// `Model<Api>` object and otherwise restores the model persisted in the
+	// session file — which, for a fork-context child, is the parent's model.
+	// Resolving the candidate here is what makes the agent's configured model win.
+	const resolvedCandidate = candidate ? options.resolveCandidateModel?.(candidate) : undefined;
 	const fastModeSettings = getSubagentCodexFastModeSettings(cwd);
 	const orchestrationContext = workflowOrchestrationContext(options);
 	const fastModeScope = resolveSubagentCodexFastModeScope(
@@ -248,8 +253,8 @@ export async function runSingleInProcess(
 		tools: agent.tools,
 		mcpDirectTools: agent.mcpDirectTools,
 		skills: options.skills ?? agent.skills,
-		model: undefined,
-		thinkingLevel: agent.thinking as ChildSpec["thinkingLevel"],
+		model: resolvedCandidate?.model,
+		thinkingLevel: (resolvedCandidate?.thinkingLevel ?? agent.thinking) as ChildSpec["thinkingLevel"],
 		parent,
 		intercom: options.orchestratorIntercomTarget
 			? {
@@ -305,14 +310,14 @@ export async function runSingleInProcess(
 	const neverAbort = new AbortController().signal;
 	const running = control.startAttempt(
 		admission.admitted,
-		{ modelId: candidate, thinkingLevel: spec.thinkingLevel },
+		{ model: resolvedCandidate?.model, modelId: candidate, thinkingLevel: spec.thinkingLevel },
 		{
 			abort: options.signal ?? neverAbort,
 			interrupt: options.interruptSignal ?? neverAbort,
 		},
 		{ fastModeForModel },
 	);
-	if (options.onUpdate && !options.backgroundContinuation) {
+	if (options.onUpdate) {
 		const launchModel = running.currentModel ?? candidate;
 		spec.onProgress?.({
 			index: options.index ?? 0,
@@ -330,79 +335,11 @@ export async function runSingleInProcess(
 			lastActivityAt: Date.now(),
 		});
 	}
-	control.registerNestedAttempt(options.runId, running, { modelId: candidate, thinkingLevel: spec.thinkingLevel });
-	if (options.backgroundContinuation) {
-		control.continueInBackground(running, "async-requested");
-		void running.promise.then(
-			async (backgroundOutcome) => {
-				const recovered = resultFromOutcome(agent, task, backgroundOutcome, startedAt, artifactPaths, {
-					cwd,
-					settings: fastModeSettings,
-					scope: fastModeScope,
-				});
-				await control.deliverChildResult(
-					{
-						path: backgroundOutcome.path,
-						status: backgroundOutcome.status,
-						...(backgroundOutcome.status === "error" ? { cause: backgroundOutcome.cause } : {}),
-						stats: backgroundOutcome.stats,
-						envelope: backgroundOutcome.envelope,
-						...(recovered.model === undefined ? {} : { model: recovered.model }),
-						...(recovered.thinking === undefined ? {} : { thinking: recovered.thinking }),
-						...(recovered.fastMode ? { fastMode: true } : {}),
-						sessionFile: backgroundOutcome.sessionFile,
-						timestamp: Date.now(),
-						artifactsDir: options.artifactsDir,
-					},
-					{ artifactsDir: options.artifactsDir, artifactPaths, artifactsDisabled, maxOutput: options.maxOutput },
-				);
-				const delivered = control.getDeliveredResult(backgroundOutcome.path);
-				if (delivered) {
-					recovered.envelope = delivered.envelope;
-					recovered.finalOutput = delivered.envelope;
-				}
-				options.onDetachedExit?.(recovered);
-			},
-			() => undefined,
-		);
-		const continuedModel = running.currentModel ?? candidate;
-		const continuedFastMode = fastModeForModel(continuedModel);
-		const continuedThinking = running.currentThinking;
-		const continuedResult: SingleResult = {
-			agent: agent.name,
-			task,
-			status: "continued",
-			path: admission.admitted.identity.path,
-			envelope: "Child continued in background.",
-			detached: true,
-			detachedReason: "async-requested",
-			messages: [],
-			usage: emptyUsage(),
-			...(continuedModel === undefined ? {} : { model: continuedModel }),
-			...(continuedThinking === undefined ? {} : { thinking: continuedThinking }),
-			...(continuedFastMode ? { fastMode: true } : {}),
-			progress: {
-				index: options.index ?? 0,
-				agent: agent.name,
-				status: "running",
-				task,
-				...(continuedModel === undefined ? {} : { model: continuedModel }),
-				...(continuedThinking === undefined ? {} : { thinking: continuedThinking }),
-				...(continuedFastMode ? { fastMode: true } : {}),
-				recentTools: [],
-				recentOutput: [],
-				toolCount: 0,
-				tokens: 0,
-				durationMs: Math.max(0, Date.now() - startedAt),
-				lastActivityAt: Date.now(),
-			},
-		};
-		options.onUpdate?.({
-			content: [{ type: "text", text: continuedResult.envelope ?? "" }],
-			details: { mode: "single", runId: options.runId, results: [continuedResult] } satisfies Details,
-		});
-		return continuedResult;
-	}
+	control.registerNestedAttempt(options.runId, running, {
+		model: resolvedCandidate?.model,
+		modelId: candidate,
+		thinkingLevel: spec.thinkingLevel,
+	});
 	let detached = false;
 	let resolveContinuation!: () => void;
 	const continuation = new Promise<void>((resolve) => {
@@ -414,7 +351,7 @@ export async function runSingleInProcess(
 		detach: () => {
 			if (detached) return;
 			detached = true;
-			control.continueInBackground(running, "intercom-coordination");
+			control.continueDetached(running, "intercom-coordination");
 			resolveContinuation();
 		},
 	});
@@ -422,29 +359,29 @@ export async function runSingleInProcess(
 	const winner = await Promise.race([terminal, continuation.then(() => ({ kind: "continued" as const }))]);
 	if (winner.kind === "continued") {
 		detachCleanup();
-		void running.promise.then(async (backgroundOutcome) => {
-			const recovered = resultFromOutcome(agent, task, backgroundOutcome, startedAt, artifactPaths, {
+		void running.promise.then(async (continuedOutcome) => {
+			const recovered = resultFromOutcome(agent, task, continuedOutcome, startedAt, artifactPaths, {
 				cwd,
 				settings: fastModeSettings,
 				scope: fastModeScope,
 			});
 			await control.deliverChildResult(
 				{
-					path: backgroundOutcome.path,
-					status: backgroundOutcome.status,
-					...(backgroundOutcome.status === "error" ? { cause: backgroundOutcome.cause } : {}),
-					stats: backgroundOutcome.stats,
-					envelope: backgroundOutcome.envelope,
+					path: continuedOutcome.path,
+					status: continuedOutcome.status,
+					...(continuedOutcome.status === "error" ? { cause: continuedOutcome.cause } : {}),
+					stats: continuedOutcome.stats,
+					envelope: continuedOutcome.envelope,
 					...(recovered.model === undefined ? {} : { model: recovered.model }),
 					...(recovered.thinking === undefined ? {} : { thinking: recovered.thinking }),
 					...(recovered.fastMode ? { fastMode: true } : {}),
-					sessionFile: backgroundOutcome.sessionFile,
+					sessionFile: continuedOutcome.sessionFile,
 					timestamp: Date.now(),
 					artifactsDir: options.artifactsDir,
 				},
 				{ artifactsDir: options.artifactsDir, artifactPaths, artifactsDisabled, maxOutput: options.maxOutput },
 			);
-			const delivered = control.getDeliveredResult(backgroundOutcome.path);
+			const delivered = control.getDeliveredResult(continuedOutcome.path);
 			if (delivered) {
 				recovered.envelope = delivered.envelope;
 				recovered.finalOutput = delivered.envelope;
@@ -459,7 +396,7 @@ export async function runSingleInProcess(
 			task,
 			status: "continued",
 			path: admission.admitted.identity.path,
-			envelope: "Child continued in background.",
+			envelope: "Child detached for intercom coordination.",
 			detached: true,
 			detachedReason: "intercom-coordination",
 			messages: [],

package/dist/builtin/subagents/src/runs/{background → foreground}/notify.ts

@@ -5,7 +5,7 @@
 import { type ExtensionAPI, isStaleExtensionContextError } from "@bastani/atomic";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import {
-	SUBAGENT_ASYNC_COMPLETE_EVENT,
+	SUBAGENT_COMPLETE_EVENT,
 	SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT,
 	type SubagentAttemptStatus,
 } from "../../shared/types.ts";
@@ -170,7 +170,7 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 			runId,
 			...(terminalId ? { terminalId } : {}),
 			terminalAt: Number.isFinite(result.timestamp) ? result.timestamp : Date.now(),
-			source: "background-notify" as const,
+			source: "detached-notify" as const,
 			sourceSessionTargets,
 			...(barrierDispatch ? { dispatch: barrierDispatch } : {}),
 		};
@@ -238,7 +238,7 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 		const noticeLabel =
 			typeof result.noticeLabel === "string" && result.noticeLabel.trim()
 				? result.noticeLabel.trim()
-				: "Background task";
+				: "Subagent task";
 		let sessionLabel: string | undefined;
 		let sessionValue: string | undefined;
 		if (sessionLine) {
@@ -281,7 +281,7 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 			inFlight.delete(key);
 			ownership.reject(error);
 			result.acknowledge?.(false);
-			console.error("Failed to deliver async subagent completion notification:", error);
+			console.error("Failed to deliver subagent completion notification:", error);
 		};
 		const observe = (delivery: PromiseLike<void>): void => {
 			result.defer?.();
@@ -314,7 +314,7 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 	};
 	let unsubscribe: () => void;
 	try {
-		unsubscribe = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
+		unsubscribe = pi.events.on(SUBAGENT_COMPLETE_EVENT, handleComplete);
 	} catch (error) {
 		if (!isStaleExtensionContextError(error)) throw error;
 		// A stale API cannot accept a new subscription; keep the prior one usable.

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

@@ -22,10 +22,6 @@ import {
 	subagentDepthBlockedMessage,
 } from "../../shared/types.ts";
 
-function applyForceTopLevelAsyncOverride<T extends { async?: boolean }>(params: T, depth: number, force: boolean): T {
-	return depth === 0 && force ? { ...params, async: true } : params;
-}
-
 import {
 	createNestedRoute,
 	resolveInheritedNestedRouteFromEnv,
@@ -81,11 +77,7 @@ export function prepareExecutionContext(input: {
 	if (normalized.error) return { error: normalized.error };
 	const normalizedParams = normalized.params!;
 
-	let effectiveParams = applyForceTopLevelAsyncOverride(
-		normalizedParams,
-		depth,
-		deps.config.forceTopLevelAsync === true,
-	);
+	let effectiveParams = normalizedParams;
 
 	const scope = resolveExecutionAgentScope(effectiveParams.agentScope);
 	const effectiveCwd = effectiveParams.cwd ?? ctx.cwd;
@@ -124,7 +116,6 @@ export function prepareExecutionContext(input: {
 	} catch (error) {
 		return { error: toExecutionErrorResult(effectiveParams, error) };
 	}
-	const effectiveAsync = effectiveParams.async ?? deps.asyncByDefault;
 	const controlConfig = resolveControlConfig(deps.config.control, effectiveParams.control);
 
 	const artifactConfig: ArtifactConfig = {
@@ -176,30 +167,22 @@ export function prepareExecutionContext(input: {
 		artifactConfig,
 		artifactsDir,
 		parentDepth: depth,
-		effectiveAsync,
 		controlConfig,
 		intercomBridge,
 		nestedRoute,
 	};
 
 	const foregroundMode: "single" | "parallel" = hasTasks ? "parallel" : "single";
-	const foregroundControl = effectiveAsync
-		? undefined
-		: {
-				runId,
-				mode: foregroundMode,
-				startedAt: Date.now(),
-				updatedAt: Date.now(),
-				currentAgent: undefined,
-				currentIndex: undefined,
-				currentActivityState: undefined,
-				nestedRoute,
-				interrupt: undefined,
-			};
-	if (foregroundControl) {
-		deps.state.foregroundControls.set(runId, foregroundControl);
-		deps.state.lastForegroundControlId = runId;
-	}
+	const foregroundControl = {
+		runId,
+		mode: foregroundMode,
+		startedAt: Date.now(),
+		updatedAt: Date.now(),
+		nestedRoute,
+		interrupt: undefined,
+	};
+	deps.state.foregroundControls.set(runId, foregroundControl);
+	deps.state.lastForegroundControlId = runId;
 
 	const writeNestedForegroundEvent = (
 		type: "subagent.nested.started" | "subagent.nested.completed",

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

@@ -2,6 +2,7 @@ import type { ExtensionContext } from "@bastani/atomic";
 import type { AgentConfig } from "../../agents/agents.ts";
 import { INTERCOM_BRIDGE_MARKER } from "../../intercom/intercom-bridge.ts";
 import type { ModelInfo } from "../../shared/model-info.ts";
+import type { CandidateModelResolver } from "../../shared/model-resolution.ts";
 import { buildTaskInstructions, type ResolvedStepBehavior } from "../../shared/settings.ts";
 import type {
 	AgentProgress,
@@ -42,6 +43,7 @@ interface ForegroundParallelRunInput {
 	workflowStageSubagentGuard?: boolean;
 	availableModels: ModelInfo[];
 	knownModelProviders: string[];
+	resolveCandidateModel: CandidateModelResolver;
 	modelOverrides: (string | undefined)[];
 	behaviors: ResolvedStepBehavior[];
 	firstProgressIndex: number;
@@ -144,6 +146,7 @@ export async function runForegroundParallelTasks(input: ForegroundParallelRunInp
 				modelOverride: input.modelOverrides[index],
 				availableModels: input.availableModels,
 				knownModelProviders: input.knownModelProviders,
+				resolveCandidateModel: input.resolveCandidateModel,
 				preferredModelProvider: input.ctx.model?.provider,
 				currentModel: currentModelFullId(input.ctx.model),
 				skills: effectiveSkills === false ? [] : effectiveSkills,

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

@@ -2,6 +2,7 @@ import type { AgentConfig } from "../../agents/agents.ts";
 import { normalizeSkillInput } from "../../agents/skills.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import { collectKnownModelProviders, type ModelInfo, toModelInfo } from "../../shared/model-info.ts";
+import { createCandidateModelResolver } from "../../shared/model-resolution.ts";
 import {
 	resolveStepBehavior,
 	type StepOverrides,
@@ -212,6 +213,7 @@ export async function runParallelPath(
 			workflowStageSubagentGuard,
 			availableModels,
 			knownModelProviders,
+			resolveCandidateModel: createCandidateModelResolver(ctx.modelRegistry, currentProvider),
 			modelOverrides,
 			behaviors,
 			firstProgressIndex: parallelProgressPrecreated ? -1 : firstProgressIndex,

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

@@ -1,13 +1,8 @@
-import { formatAsyncStartedMessage, isAsyncAvailable } from "../inprocess/background.ts";
-import { executeAsyncSingle } from "../inprocess/background-single.ts";
 import { runSync } from "./execution.ts";
 import type { SubagentExecutorRuntimeDeps } from "./subagent-executor-types.ts";
 
 const defaultSubagentExecutorRuntimeDeps: SubagentExecutorRuntimeDeps = {
 	runSync,
-	executeAsyncSingle,
-	isAsyncAvailable,
-	formatAsyncStartedMessage,
 };
 
 export function resolveSubagentExecutorRuntimeDeps(

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,
@@ -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 {
@@ -217,6 +226,7 @@ export async function runSinglePath(
 			modelOverride,
 			availableModels,
 			knownModelProviders,
+			resolveCandidateModel: createCandidateModelResolver(ctx.modelRegistry, currentProvider),
 			preferredModelProvider: currentProvider,
 			currentModel: currentModelFullId(ctx.model),
 			skills: effectiveSkills,

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

@@ -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 {
@@ -171,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);
@@ -199,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,
@@ -280,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;
@@ -349,7 +350,6 @@ async function emitForegroundResultIntercom(input: {
 		to: input.intercomBridge.orchestratorTarget,
 		runId: input.runId,
 		mode: input.mode,
-		source: "foreground",
 		children: attachNestedChildrenToResultChildren(input.runId, children, input.nestedChildren),
 	});
 	const delivered = await deliverSubagentResultIntercomEvent(input.pi.events, payload);

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

@@ -12,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";
 
@@ -39,7 +33,6 @@ export interface SubagentParamsLike {
 	action?: (typeof SUBAGENT_ACTIONS)[number];
 	id?: string;
 	runId?: string;
-	dir?: string;
 	index?: number;
 	agent?: string;
 	task?: string;
@@ -49,7 +42,6 @@ export interface SubagentParamsLike {
 	concurrency?: number;
 	worktree?: boolean;
 	context?: "fresh" | "fork";
-	async?: boolean;
 	share?: boolean;
 	control?: ControlConfig;
 	sessionDir?: string;
@@ -69,16 +61,12 @@ export interface SubagentParamsLike {
 
 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;
@@ -115,7 +103,6 @@ export interface ExecutionContextData {
 	artifactConfig: ArtifactConfig;
 	artifactsDir: string;
 	parentDepth?: number;
-	effectiveAsync: boolean;
 	controlConfig: ResolvedControlConfig;
 	intercomBridge: IntercomBridgeState;
 	nestedRoute?: NestedRouteInfo;