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

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

@@ -1,21 +1,32 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
 import type { ExtensionContext } from "@bastani/atomic";
 import { handleManagementAction } from "../../agents/agent-management.ts";
 import { resolveExecutionAgentScope } from "../../agents/agent-scope.ts";
 import { clearPendingForegroundControlNotices } from "../../extension/control-notices.ts";
 import { buildDoctorReport } from "../../extension/doctor.ts";
 import {
+	INTERCOM_BRIDGE_MARKER,
 	resolveIntercomBridge,
 	resolveIntercomSessionTarget,
 	resolveSubagentIntercomTarget,
 } from "../../intercom/intercom-bridge.ts";
 import { requestSupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
 import { getArtifactsDir } from "../../shared/artifacts.ts";
-import { toModelInfo } from "../../shared/model-info.ts";
-import { resolveSingleProgress } from "../../shared/settings.ts";
+import { collectKnownModelProviders, toModelInfo } from "../../shared/model-info.ts";
+import { createCandidateModelResolver } from "../../shared/model-resolution.ts";
+import {
+	injectSingleProgressInstruction,
+	resolveSingleProgress,
+	writeInitialProgressFile,
+} from "../../shared/settings.ts";
 import {
 	DEFAULT_ARTIFACT_CONFIG,
+	getCurrentSubagentDepth,
 	isWorkflowStageOrchestrationContext,
+	resolveChildMaxSubagentDepth,
 	resolveWorkflowStageMaxSubagentDepth,
+	type SingleResult,
 	SUBAGENT_ACTIONS,
 	type SubagentToolResult,
 	workflowSessionMetadataFromContext,
@@ -25,20 +36,20 @@ import {
 	interruptInProcessChild,
 	resumeInProcessChild,
 } from "../inprocess/control-status.ts";
-import { inheritedIntercomGroup } from "../shared/intercom-group.ts";
+import { inheritedIntercomGroup } from "../shared/intercom-group.js";
 import { currentModelFullId } from "../shared/model-fallback.ts";
 import { resolveControlConfig } from "../shared/subagent-control.ts";
-import { runAsyncPath } from "./subagent-executor-async.ts";
-import { runChainPath } from "./subagent-executor-chain.ts";
 import { checkDepthForExecution, prepareExecutionContext } from "./subagent-executor-context.ts";
 import { toExecutionErrorResult, withForkContext } from "./subagent-executor-input.ts";
 import { runParallelPath } from "./subagent-executor-parallel.ts";
 import { resolveRequestedCwd } from "./subagent-executor-resume.ts";
 import { resolveSubagentExecutorRuntimeDeps } from "./subagent-executor-runtime.ts";
-import { runSinglePath } from "./subagent-executor-single.ts";
+import { createForwardSingleUpdate, runSinglePath } from "./subagent-executor-single.ts";
 import {
 	foregroundStatusResult,
 	getForegroundControl,
+	notifyDetachedForegroundChildExit,
+	replaceForegroundRunChild,
 	retainedForegroundStatusResult,
 } from "./subagent-executor-status.ts";
 import {
@@ -53,6 +64,7 @@ async function resumeRetainedForegroundChild(
 	message: string,
 	ctx: ExtensionContext,
 	deps: ResolvedExecutorDeps,
+	onUpdate: ((r: SubagentToolResult) => void) | undefined,
 ): Promise<SubagentToolResult | undefined> {
 	const requested = params.id ?? params.runId;
 	if (!requested) return undefined;
@@ -81,40 +93,102 @@ async function resumeRetainedForegroundChild(
 		? resolveSubagentIntercomTarget(run.runId, child.agent, child.index)
 		: undefined;
 	const supervisorAuthorization = await requestSupervisorAuthorization(deps.pi.events, supervisedTarget);
-	return deps.runtime.executeAsyncSingle(run.runId, {
-		agent: child.agent,
-		agentConfig,
-		task: message,
-		ctx: {
-			pi: deps.pi,
+	const artifactConfig = { ...DEFAULT_ARTIFACT_CONFIG, enabled: params.artifacts !== false };
+	const artifactsDir = getArtifactsDir(parentSessionFile);
+	const progressDir = resolveSingleProgress(agentConfig, params.progress, message)
+		? path.join(artifactsDir, "progress", run.runId)
+		: undefined;
+	if (progressDir) {
+		writeInitialProgressFile(progressDir);
+		message = injectSingleProgressInstruction(message, progressDir);
+	}
+	const cleanupProgress = (): void => {
+		if (!progressDir || artifactConfig.enabled) return;
+		try {
+			fs.rmSync(progressDir, { recursive: true, force: true });
+		} catch {
+			// Scratch cleanup must never replace the child run's result or original error.
+		}
+	};
+	const forwardSingleUpdate = createForwardSingleUpdate(
+		onUpdate,
+		getForegroundControl(deps.state, run.runId),
+		child.agent,
+		child.index,
+	);
+	let result: SingleResult;
+	try {
+		result = await deps.runtime.runSync(run.cwd, agents, child.agent, message, {
 			cwd: run.cwd,
-			currentSessionId: ctx.sessionManager.getSessionId(),
-			currentModelProvider: ctx.model?.provider,
-			currentModel: currentModelFullId(ctx.model),
-			intercomGroup: inheritedIntercomGroup(ctx),
+			signal: ctx.signal,
+			interruptSignal: ctx.signal,
+			allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+			intercomEvents: deps.pi.events,
+			runId: run.runId,
+			index: child.index,
+			sessionDir: child.sessionFile ? path.dirname(child.sessionFile) : undefined,
+			sessionFile: child.sessionFile,
+			share: params.share === true,
+			artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
+			artifactConfig,
+			maxOutput: params.maxOutput,
+			maxSubagentDepth:
+				child.maxSubagentDepth ??
+				resolveChildMaxSubagentDepth(
+					resolveWorkflowStageMaxSubagentDepth(ctx, deps.config.maxSubagentDepth),
+					agentConfig.maxSubagentDepth,
+				),
+			parentDepth: getCurrentSubagentDepth(ctx),
+			workflowStageSubagentGuard: isWorkflowStageOrchestrationContext(ctx),
 			workflowSessionMetadata: workflowSessionMetadataFromContext(ctx),
-		},
-		cwd: run.cwd,
-		maxOutput: params.maxOutput,
-		artifactsDir: getArtifactsDir(parentSessionFile),
-		artifactConfig: { ...DEFAULT_ARTIFACT_CONFIG, enabled: params.artifacts !== false },
-		shareEnabled: params.share === true,
-		sessionRoot: deps.getSubagentSessionRoot(parentSessionFile),
-		sessionFile: child.sessionFile,
-		progress: resolveSingleProgress(agentConfig, params.progress, message),
-		modelOverride: params.model,
-		availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
-		maxSubagentDepth: resolveWorkflowStageMaxSubagentDepth(ctx, deps.config.maxSubagentDepth),
-		workflowStageSubagentGuard: isWorkflowStageOrchestrationContext(ctx),
-		controlConfig: resolveControlConfig(deps.config.control, params.control),
-		controlIntercomTarget: intercomBridge.active ? intercomBridge.orchestratorTarget : undefined,
-		childIntercomTarget: intercomBridge.active
-			? (agent, index) => resolveSubagentIntercomTarget(run.runId, agent, index)
-			: undefined,
-		supervisorAuthorization,
-	});
+			controlConfig: resolveControlConfig(deps.config.control, params.control),
+			intercomSessionName: intercomBridge.active
+				? resolveSubagentIntercomTarget(run.runId, child.agent, child.index)
+				: undefined,
+			orchestratorIntercomTarget: intercomBridge.active ? intercomBridge.orchestratorTarget : undefined,
+			intercomGroup: inheritedIntercomGroup(ctx),
+			supervisorAuthorization,
+			modelOverride: params.model,
+			availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
+			knownModelProviders: collectKnownModelProviders(ctx.modelRegistry),
+			resolveCandidateModel: createCandidateModelResolver(ctx.modelRegistry, ctx.model?.provider),
+			preferredModelProvider: ctx.model?.provider,
+			currentModel: currentModelFullId(ctx.model),
+			onUpdate: forwardSingleUpdate,
+			onDetachedExit: (detachedResult) => {
+				cleanupProgress();
+				if (detachedResult) {
+					replaceForegroundRunChild(deps.state, run.runId, child.index, detachedResult);
+					notifyDetachedForegroundChildExit({
+						pi: deps.pi,
+						runId: run.runId,
+						mode: "single",
+						index: child.index,
+						result: detachedResult,
+					});
+				}
+			},
+		});
+	} catch (error) {
+		cleanupProgress();
+		throw error;
+	}
+	if (!result.detached) cleanupProgress();
+	replaceForegroundRunChild(deps.state, run.runId, child.index, result, { onlyWhenDetached: false });
+	return {
+		content: [{ type: "text", text: result.finalOutput ?? result.envelope ?? result.error ?? "" }],
+		details: { mode: "single", runId: run.runId, results: [result] },
+		...(result.status === "error" ? { isError: true } : {}),
+	};
 }
 const MUTATING_MANAGEMENT_ACTIONS = new Set(["create", "update", "delete"]);
+/**
+ * Management actions that only observe. Every other action either mutates agent
+ * definitions or starts/continues agent execution, so a child without fanout
+ * authorization is refused all of them.
+ */
+const READ_ONLY_MANAGEMENT_ACTIONS = new Set(["list", "get", "status", "doctor"]);
+const FANOUT_REFUSAL_MESSAGE = "Subagent fanout is not authorized for this child.";
 
 export type { SubagentExecutorRuntimeDeps, SubagentParamsLike } from "./subagent-executor-types.ts";
 
@@ -124,8 +198,9 @@ async function handleManagementRequest(input: {
 	requestCwd: string;
 	ctx: ExtensionContext;
 	deps: ResolvedExecutorDeps;
+	onUpdate?: (r: SubagentToolResult) => void;
 }): Promise<SubagentToolResult> {
-	const { params, paramsWithResolvedCwd, requestCwd, ctx, deps } = input;
+	const { params, paramsWithResolvedCwd, requestCwd, ctx, deps, onUpdate } = input;
 	const action = params.action;
 	if (!action) {
 		return {
@@ -134,6 +209,30 @@ async function handleManagementRequest(input: {
 			details: { mode: "management", results: [] },
 		};
 	}
+	if (!(SUBAGENT_ACTIONS as readonly string[]).includes(action)) {
+		return {
+			content: [{ type: "text", text: `Unknown action: ${action}. Valid: ${SUBAGENT_ACTIONS.join(", ")}` }],
+			isError: true,
+			details: { mode: "management" as const, results: [] },
+		};
+	}
+	if (isManagementActionsRestricted(deps) && MUTATING_MANAGEMENT_ACTIONS.has(action)) {
+		return {
+			content: [{ type: "text", text: `Action '${action}' is not available from child-safe subagent fanout mode.` }],
+			isError: true,
+			details: { mode: "management" as const, results: [] },
+		};
+	}
+	// `resume` revives a child and `interrupt` is privileged control over a
+	// running one; both continue agent execution, so only the observing actions
+	// reach their handlers for a child without fanout authorization.
+	if (deps.childPolicy && !deps.childPolicy.fanoutAuthorized && !READ_ONLY_MANAGEMENT_ACTIONS.has(action)) {
+		return {
+			content: [{ type: "text", text: FANOUT_REFUSAL_MESSAGE }],
+			isError: true,
+			details: { mode: "management" as const, results: [] },
+		};
+	}
 	if (action === "doctor") {
 		let currentSessionFile: string | null = null;
 		let currentSessionId = deps.state.currentSessionId;
@@ -202,7 +301,7 @@ async function handleManagementRequest(input: {
 		}
 		const inProcess = await resumeInProcessChild(targetRunId, message, { model: ctx.model });
 		if (inProcess) return inProcess;
-		const retained = await resumeRetainedForegroundChild(paramsWithResolvedCwd, message, ctx, deps);
+		const retained = await resumeRetainedForegroundChild(paramsWithResolvedCwd, message, ctx, deps, onUpdate);
 		if (retained) return retained;
 		return {
 			content: [{ type: "text", text: `No in-process child found for '${targetRunId}'.` }],
@@ -229,25 +328,10 @@ async function handleManagementRequest(input: {
 			details: { mode: "management", results: [] },
 		};
 	}
-	if (!(SUBAGENT_ACTIONS as readonly string[]).includes(action)) {
-		return {
-			content: [{ type: "text", text: `Unknown action: ${action}. Valid: ${SUBAGENT_ACTIONS.join(", ")}` }],
-			isError: true,
-			details: { mode: "management" as const, results: [] },
-		};
-	}
-	if (isManagementActionsRestricted(deps) && MUTATING_MANAGEMENT_ACTIONS.has(action)) {
-		return {
-			content: [{ type: "text", text: `Action '${action}' is not available from child-safe subagent fanout mode.` }],
-			isError: true,
-			details: { mode: "management" as const, results: [] },
-		};
-	}
 	return handleManagementAction(action, paramsWithResolvedCwd, { ...ctx, cwd: requestCwd });
 }
 
-function inferExecutionMode(params: SubagentParamsLike): "single" | "parallel" | "chain" {
-	if ((params.chain?.length ?? 0) > 0) return "chain";
+function inferExecutionMode(params: SubagentParamsLike): "single" | "parallel" {
 	if ((params.tasks?.length ?? 0) > 0) return "parallel";
 	return "single";
 }
@@ -282,13 +366,6 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 		onUpdate: ((r: SubagentToolResult) => void) | undefined,
 		ctx: ExtensionContext,
 	): Promise<SubagentToolResult> => {
-		if (deps.childPolicy && !deps.childPolicy.fanoutAuthorized) {
-			return {
-				content: [{ type: "text", text: "Subagent fanout is not authorized for this child." }],
-				isError: true,
-				details: { mode: "single", results: [] },
-			};
-		}
 		deps.state.baseCwd = ctx.cwd;
 		deps.state.foregroundRuns ??= new Map();
 		deps.state.foregroundControls ??= new Map();
@@ -296,7 +373,18 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 		const requestCwd = resolveRequestedCwd(ctx.cwd, params.cwd);
 		const paramsWithResolvedCwd = params.cwd === undefined ? params : { ...params, cwd: requestCwd };
 		if (params.action) {
-			return handleManagementRequest({ params, paramsWithResolvedCwd, requestCwd, ctx, deps });
+			return handleManagementRequest({ params, paramsWithResolvedCwd, requestCwd, ctx, deps, onUpdate });
+		}
+		// Fanout authorization gates delegation and every management action that can
+		// start or continue agent execution. Only `list`, `get`, `status`, and
+		// `doctor` stay available to an unauthorized child; `resume`, `interrupt`,
+		// and mutating management are refused inside handleManagementRequest.
+		if (deps.childPolicy && !deps.childPolicy.fanoutAuthorized) {
+			return {
+				content: [{ type: "text", text: FANOUT_REFUSAL_MESSAGE }],
+				isError: true,
+				details: { mode: inferExecutionMode(params), results: [] },
+			};
 		}
 
 		const depthError = checkDepthForExecution(ctx, deps);
@@ -307,17 +395,10 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 		const prepared = built.prepared!;
 		let nestedForegroundStarted = false;
 		try {
-			const asyncResult = await runAsyncPath(prepared.execData, deps);
-			if (asyncResult) return withForkContext(asyncResult, prepared.effectiveParams.context);
 			if (prepared.foregroundControl) {
 				prepared.writeNestedForegroundEvent("subagent.nested.started");
 				nestedForegroundStarted = true;
 			}
-			if (prepared.hasChain && prepared.effectiveParams.chain) {
-				const result = await runChainPath(prepared.execData, deps);
-				prepared.writeNestedForegroundEvent("subagent.nested.completed", result);
-				return withForkContext(result, prepared.effectiveParams.context);
-			}
 			if (prepared.hasTasks && prepared.effectiveParams.tasks) {
 				const result = await runParallelPath(prepared.execData, deps);
 				prepared.writeNestedForegroundEvent("subagent.nested.completed", result);

package/dist/builtin/subagents/src/runs/inprocess/index.ts

@@ -40,7 +40,7 @@ export type {
 export {
 	AdmittedChild,
 	admit_child_session,
-	continue_in_background,
+	continue_detached,
 	createSubagentControl,
 	deliver_child_result,
 	reload_cold_child,