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

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,
@@ -45,9 +44,7 @@ export interface SubagentParamsLike {
 	agent?: string;
 	task?: string;
 	message?: string;
-	chainName?: string;
 	config?: unknown;
-	chain?: ChainStep[];
 	tasks?: TaskParam[];
 	concurrency?: number;
 	worktree?: boolean;
@@ -68,7 +65,6 @@ export interface SubagentParamsLike {
 	reads?: string[] | false;
 	progress?: boolean;
 	agentScope?: string;
-	chainDir?: string;
 }
 
 export interface SubagentExecutorRuntimeDeps {
@@ -118,6 +114,7 @@ export interface ExecutionContextData {
 	sessionFileForIndex: (idx?: number) => string | undefined;
 	artifactConfig: ArtifactConfig;
 	artifactsDir: string;
+	parentDepth?: number;
 	effectiveAsync: boolean;
 	controlConfig: ResolvedControlConfig;
 	intercomBridge: IntercomBridgeState;
@@ -128,10 +125,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,

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

@@ -14,7 +14,9 @@ import { toModelInfo } from "../../shared/model-info.ts";
 import { resolveSingleProgress } from "../../shared/settings.ts";
 import {
 	DEFAULT_ARTIFACT_CONFIG,
+	getCurrentSubagentDepth,
 	isWorkflowStageOrchestrationContext,
+	resolveChildMaxSubagentDepth,
 	resolveWorkflowStageMaxSubagentDepth,
 	SUBAGENT_ACTIONS,
 	type SubagentToolResult,
@@ -25,11 +27,10 @@ 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";
@@ -104,7 +105,16 @@ async function resumeRetainedForegroundChild(
 		progress: resolveSingleProgress(agentConfig, params.progress, message),
 		modelOverride: params.model,
 		availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
-		maxSubagentDepth: resolveWorkflowStageMaxSubagentDepth(ctx, deps.config.maxSubagentDepth),
+		// The child's own effective limit, recorded when the run was retained. An
+		// older record without one falls back to narrowing the current limit by the
+		// agent definition, so a resume never widens a child's delegation budget.
+		maxSubagentDepth:
+			child.maxSubagentDepth ??
+			resolveChildMaxSubagentDepth(
+				resolveWorkflowStageMaxSubagentDepth(ctx, deps.config.maxSubagentDepth),
+				agentConfig.maxSubagentDepth,
+			),
+		parentDepth: getCurrentSubagentDepth(ctx),
 		workflowStageSubagentGuard: isWorkflowStageOrchestrationContext(ctx),
 		controlConfig: resolveControlConfig(deps.config.control, params.control),
 		controlIntercomTarget: intercomBridge.active ? intercomBridge.orchestratorTarget : undefined,
@@ -115,6 +125,13 @@ async function resumeRetainedForegroundChild(
 	});
 }
 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";
 
@@ -134,6 +151,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;
@@ -229,25 +270,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 +308,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();
@@ -298,6 +317,17 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 		if (params.action) {
 			return handleManagementRequest({ params, paramsWithResolvedCwd, requestCwd, ctx, deps });
 		}
+		// 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);
 		if (depthError) return depthError;
@@ -313,11 +343,6 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 				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/background-single.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { isStaleExtensionContextError } from "@bastani/atomic";
 import { buildSkillInjection, resolveSkillsWithFallback } from "../../agents/skills.ts";
 import { injectSingleProgressInstruction, writeInitialProgressFile } from "../../shared/settings.ts";
 import {
@@ -10,7 +11,7 @@ import {
 } from "../../shared/types.ts";
 import { resolveChildCwd } from "../../shared/utils.ts";
 import { runSingleInProcess } from "../foreground/inprocess-run-sync.ts";
-import { resolveChildIntercomGroup } from "../shared/intercom-group.ts";
+import { resolveChildIntercomGroup } from "../shared/intercom-group.js";
 import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
 import { buildModelCandidates } from "../shared/model-fallback.ts";
 import {
@@ -46,6 +47,7 @@ export async function executeAsyncSingle(id: string, params: AsyncSingleParams):
 		sessionRoot,
 		sessionFile,
 		maxSubagentDepth,
+		parentDepth,
 		workflowStageSubagentGuard,
 		controlConfig,
 		controlIntercomTarget,
@@ -123,6 +125,7 @@ export async function executeAsyncSingle(id: string, params: AsyncSingleParams):
 		outputMode,
 		backgroundContinuation: true,
 		maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, agentConfig.maxSubagentDepth),
+		parentDepth,
 		workflowStageSubagentGuard,
 		workflowSessionMetadata: ctx.workflowSessionMetadata,
 		controlConfig,
@@ -139,38 +142,51 @@ export async function executeAsyncSingle(id: string, params: AsyncSingleParams):
 		testSession: params.testSession,
 		onDetachedExit: (completed) => {
 			const envelope = completed.envelope?.trim() ? completed.envelope : "(no output)";
-			ctx.pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
-				id,
-				runId: id,
-				asyncDir,
-				agent,
-				status: completed.status,
-				summary: envelope,
-				envelope,
-				timestamp: Date.now(),
-				sessionFile: completed.sessionFile,
-				results: [
-					{
-						agent,
-						output: envelope,
-						status: completed.status,
-						index: 0,
-						intercomTarget: childIntercomTarget?.(agent, 0),
-					},
-				],
-				result: completed,
-			});
+			try {
+				ctx.pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+					id,
+					runId: id,
+					asyncDir,
+					agent,
+					status: completed.status,
+					summary: envelope,
+					envelope,
+					timestamp: Date.now(),
+					sessionFile: completed.sessionFile,
+					results: [
+						{
+							agent,
+							output: envelope,
+							status: completed.status,
+							index: 0,
+							intercomTarget: childIntercomTarget?.(agent, 0),
+						},
+					],
+					result: completed,
+				});
+			} catch (error) {
+				if (!isStaleExtensionContextError(error)) throw error;
+				// A detached child may finish after its parent extension runtime reloads.
+			}
 		},
 	});
 
-	ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
-		id,
-		asyncDir,
-		sessionId: result.path,
-		mode: "single",
-		agent,
-		agents: [agent],
-	});
+	try {
+		ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
+			id,
+			asyncDir,
+			sessionId: result.path,
+			mode: "single",
+			agent,
+			agents: [agent],
+			...(result.model !== undefined ? { model: result.model } : {}),
+			...(result.thinking !== undefined ? { thinking: result.thinking } : {}),
+			...(result.fastMode ? { fastMode: true } : {}),
+		});
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		// The launch result remains useful when the captured runtime is stale.
+	}
 	return {
 		content: [{ type: "text", text: formatAsyncStartedMessage(`Async: ${agent} [${id}]`) }],
 		details: { mode: "single", runId: id, results: [result], asyncId: id, asyncDir },

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

@@ -42,6 +42,7 @@ export interface AsyncSingleParams {
 	availableModels?: ModelInfo[];
 	knownModelProviders?: string[];
 	maxSubagentDepth: number;
+	parentDepth?: number;
 	workflowStageSubagentGuard?: boolean;
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
@@ -75,7 +76,7 @@ export function isAsyncAvailable(): boolean {
 	return true;
 }
 
-export function formatAsyncStartError(mode: "single" | "parallel" | "chain", message: string): AsyncExecutionResult {
+export function formatAsyncStartError(mode: "single" | "parallel", message: string): AsyncExecutionResult {
 	return {
 		content: [{ type: "text", text: message }],
 		isError: true,