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

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

@@ -1,403 +0,0 @@
-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

@@ -1,223 +0,0 @@
-import { randomUUID } from "node:crypto";
-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,
-	resolveIntercomSessionTarget,
-} from "../../intercom/intercom-bridge.js";
-import { getArtifactsDir } from "../../shared/artifacts.js";
-import { createForkContextResolver } from "../../shared/fork-context.js";
-import { resolveCurrentSessionId } from "../../shared/session-identity.js";
-import { buildReadInstruction } from "../../shared/settings.js";
-import {
-	type ArtifactConfig,
-	DEFAULT_ARTIFACT_CONFIG,
-	getCurrentSubagentDepth,
-	isSubagentChildSession,
-	SUBAGENT_CHILD_DELEGATION_BLOCKED_MESSAGE,
-	type SubagentRunMode,
-	type SubagentToolResult,
-} from "../../shared/types.js";
-import { resolveControlConfig } from "../shared/subagent-control.js";
-import {
-	applyAgentDefaultContext,
-	normalizeRepeatedParallelCounts,
-	toExecutionErrorResult,
-	validateExecutionInput,
-	withForkContext,
-} from "./subagent-executor-input.js";
-import {
-	BURST_TASK_DISCOVERY_CWD,
-	type BurstTaskParam,
-	type ExecutionContextBuildResult,
-	type ExecutionContextData,
-	type ExecutorDeps,
-	type ResolvedExecutorDeps,
-	type SubagentParamsLike,
-} from "./subagent-executor-types.js";
-
-/**
- * Delegation is one level deep and not configurable: a session that was itself
- * admitted as a subagent child may never call the subagent tool.
- */
-export function refuseSubagentChildDelegation(
-	ctx: Pick<ExtensionContext, "subagentPolicy">,
-	mode: SubagentRunMode | "management",
-): SubagentToolResult | undefined {
-	if (!isSubagentChildSession(ctx)) return undefined;
-	return {
-		content: [{ type: "text", text: SUBAGENT_CHILD_DELEGATION_BLOCKED_MESSAGE }],
-		isError: true,
-		details: { mode, results: [] },
-	};
-}
-
-export function prepareExecutionContext(input: {
-	params: SubagentParamsLike;
-	ctx: ExtensionContext;
-	signal: AbortSignal;
-	onUpdate?: (r: SubagentToolResult) => void;
-	deps: ResolvedExecutorDeps;
-}): ExecutionContextBuildResult {
-	const { params, ctx, signal, onUpdate, deps } = input;
-	const depth = getCurrentSubagentDepth(ctx);
-	const normalized = normalizeRepeatedParallelCounts(params);
-	if (normalized.error) return { error: normalized.error };
-	const normalizedParams = normalized.params!;
-
-	let effectiveParams = normalizedParams;
-
-	const scope = resolveExecutionAgentScope(effectiveParams.agentScope);
-	const effectiveCwd = effectiveParams.cwd ?? ctx.cwd;
-	const parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
-	deps.state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
-	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,
-		context: effectiveParams.context,
-		orchestratorTarget: sessionName,
-		cwd: effectiveCwd,
-	});
-	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, parallelAgentConfigs);
-	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 {
-		sessionFileForIndex = createForkContextResolver(ctx.sessionManager, effectiveParams.context).sessionFileForIndex;
-	} catch (error) {
-		return { error: toExecutionErrorResult(effectiveParams, error) };
-	}
-	const controlConfig = resolveControlConfig(deps.config.control, effectiveParams.control);
-
-	const artifactConfig: ArtifactConfig = {
-		...DEFAULT_ARTIFACT_CONFIG,
-		enabled: effectiveParams.artifacts !== false,
-	};
-	const artifactsDir = getArtifactsDir(parentSessionFile);
-
-	let sessionRoot: string;
-	if (effectiveParams.sessionDir) {
-		sessionRoot = path.resolve(deps.expandTilde(effectiveParams.sessionDir));
-	} else {
-		const baseSessionRoot = deps.config.defaultSessionDir
-			? path.resolve(deps.expandTilde(deps.config.defaultSessionDir))
-			: deps.getSubagentSessionRoot(parentSessionFile);
-		sessionRoot = path.join(baseSessionRoot, runId);
-	}
-	try {
-		fs.mkdirSync(sessionRoot, { recursive: true });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return {
-			error: toExecutionErrorResult(
-				effectiveParams,
-				new Error(`Failed to create session directory '${sessionRoot}': ${message}`),
-			),
-		};
-	}
-	const sessionDirForIndex = (idx?: number) => path.join(sessionRoot, `run-${idx ?? 0}`);
-	const childSessionFileForIndex = (idx?: number) =>
-		sessionFileForIndex(idx) ?? path.join(sessionDirForIndex(idx), "session.jsonl");
-
-	const onUpdateWithContext = onUpdate
-		? (r: SubagentToolResult) => onUpdate(withForkContext(r, effectiveParams.context))
-		: undefined;
-
-	const execData: ExecutionContextData = {
-		params: effectiveParams,
-		effectiveCwd,
-		ctx,
-		signal,
-		onUpdate: onUpdateWithContext,
-		agents,
-		...(parallelAgentConfigs ? { parallelAgentConfigs } : {}),
-		runId,
-		shareEnabled,
-		sessionRoot,
-		sessionDirForIndex,
-		sessionFileForIndex: childSessionFileForIndex,
-		artifactConfig,
-		artifactsDir,
-		parentDepth: depth,
-		controlConfig,
-		intercomBridge,
-	};
-
-	const foregroundMode: "single" | "parallel" = hasTasks ? "parallel" : "single";
-	const foregroundControl = {
-		runId,
-		mode: foregroundMode,
-		startedAt: Date.now(),
-		updatedAt: Date.now(),
-		interrupt: undefined,
-	};
-	deps.state.foregroundControls.set(runId, foregroundControl);
-	deps.state.lastForegroundControlId = runId;
-
-	return {
-		prepared: {
-			effectiveParams,
-			effectiveCwd,
-			runId,
-			hasTasks,
-			hasSingle,
-			foregroundMode,
-			execData,
-			foregroundControl,
-		},
-	};
-}
-
-export type { ExecutorDeps };

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

@@ -1,6 +0,0 @@
-import * as path from "node:path";
-
-/** Resolve a caller-provided cwd against the current session cwd. */
-export function resolveRequestedCwd(runtimeCwd: string, requestedCwd: string | undefined): string {
-	return requestedCwd ? path.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
-}