@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/agents/agent-paths.ts

@@ -4,14 +4,6 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { CONFIG_DIR_NAME, getAgentConfigPaths, getProjectConfigDirs } from "@bastani/atomic";
 
-export function getUserChainDir(): string {
-	return getAgentConfigPaths("chains")[0] ?? path.join(os.homedir(), CONFIG_DIR_NAME, "agent", "chains");
-}
-
-export function getUserChainDirs(): string[] {
-	return getAgentConfigPaths("chains");
-}
-
 export function getUserAgentDirs(): string[] {
 	return getAgentConfigPaths("agents");
 }
@@ -74,18 +66,4 @@ export function resolveNearestProjectAgentDirs(cwd: string): { readDirs: string[
 	};
 }
 
-export function resolveNearestProjectChainDirs(cwd: string): { readDirs: string[]; preferredDir: string | null } {
-	const projectRoot = findNearestProjectRoot(cwd);
-	if (!projectRoot) return { readDirs: [], preferredDir: null };
-
-	const preferredDir = path.join(getProjectConfigDirs(projectRoot)[0]!, "chains");
-	return {
-		readDirs: getProjectConfigDirs(projectRoot)
-			.reverse()
-			.map((configDir) => path.join(configDir, "chains"))
-			.filter(isDirectory),
-		preferredDir,
-	};
-}
-
 export const BUILTIN_AGENTS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "agents");

package/dist/builtin/subagents/src/agents/agent-types.ts

@@ -1,5 +1,3 @@
-import type { OutputMode } from "../shared/types.ts";
-
 export type AgentScope = "user" | "project" | "both";
 
 export type AgentSource = "builtin" | "user" | "project";
@@ -92,44 +90,6 @@ export interface SubagentSettings {
 
 export const EMPTY_SUBAGENT_SETTINGS: SubagentSettings = { overrides: {} };
 
-export interface ChainStepConfig {
-	agent?: string;
-	task?: string;
-	phase?: string;
-	label?: string;
-	as?: string;
-	outputSchema?: string | Record<string, unknown>;
-	output?: string | false;
-	outputMode?: OutputMode;
-	reads?: string[] | false;
-	model?: string;
-	skills?: string[] | false;
-	progress?: boolean;
-	parallel?: unknown;
-	expand?: unknown;
-	collect?: unknown;
-	concurrency?: number;
-	failFast?: boolean;
-	worktree?: boolean;
-}
-
-export interface ChainConfig {
-	name: string;
-	localName?: string;
-	packageName?: string;
-	description: string;
-	source: AgentSource;
-	filePath: string;
-	steps: ChainStepConfig[];
-	extraFields?: Record<string, string>;
-}
-
-export interface ChainDiscoveryDiagnostic {
-	source: "user" | "project";
-	filePath: string;
-	error: string;
-}
-
 export interface AgentDiscoveryResult {
 	agents: AgentConfig[];
 	projectAgentsDir: string | null;

package/dist/builtin/subagents/src/agents/agents.ts

@@ -14,9 +14,6 @@ export type {
 	AgentScope,
 	AgentSource,
 	BuiltinAgentOverrideBase,
-	ChainConfig,
-	ChainDiscoveryDiagnostic,
-	ChainStepConfig,
 } from "./agent-types.ts";
 export {
 	defaultInheritProjectContext,

package/dist/builtin/subagents/src/agents/identity.ts

@@ -1,4 +1,4 @@
-import type { AgentConfig, ChainConfig } from "./agents.ts";
+import type { AgentConfig } from "./agents.ts";
 
 const IDENTIFIER_PATTERN = /^[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)*$/;
 
@@ -28,9 +28,7 @@ export function buildRuntimeName(localName: string, packageName?: string): strin
 	return trimmedPackage ? `${trimmedPackage}.${localName}` : localName;
 }
 
-export function frontmatterNameForConfig(
-	config: Pick<AgentConfig | ChainConfig, "name" | "localName" | "packageName">,
-): string {
+export function frontmatterNameForConfig(config: Pick<AgentConfig, "name" | "localName" | "packageName">): string {
 	if (config.localName) return config.localName;
 	if (config.packageName && config.name.startsWith(`${config.packageName}.`)) {
 		return config.name.slice(config.packageName.length + 1);

package/dist/builtin/subagents/src/agents/skills-paths.ts

@@ -2,7 +2,13 @@ import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { getAgentConfigPaths, getAgentDirs, getBuiltinPackagePaths, getProjectConfigDirs } from "@bastani/atomic";
+import {
+	createChildProcessEnvironment,
+	getAgentConfigPaths,
+	getAgentDirs,
+	getBuiltinPackagePaths,
+	getProjectConfigDirs,
+} from "@bastani/atomic";
 import type { SkillSource } from "./skills.ts";
 
 export interface SkillSearchPath {
@@ -73,6 +79,7 @@ function getGlobalNpmRoot(): string | null {
 			stdio: ["ignore", "pipe", "ignore"],
 			timeout: GLOBAL_NPM_ROOT_TIMEOUT_MS,
 			windowsHide: true,
+			env: createChildProcessEnvironment(),
 		}).trim();
 		return cachedGlobalNpmRoot;
 	} catch {

package/dist/builtin/subagents/src/extension/doctor.ts

@@ -3,21 +3,13 @@ import * as path from "node:path";
 import { type AgentSource, discoverAgentsAll } from "../agents/agents.ts";
 import { discoverAvailableSkills, type SkillSource } from "../agents/skills.ts";
 import { diagnoseIntercomBridge, type IntercomBridgeDiagnostic } from "../intercom/intercom-bridge.ts";
-import { isAsyncAvailable } from "../runs/background/async-execution.ts";
-import {
-	ASYNC_DIR,
-	CHAIN_RUNS_DIR,
-	type ExtensionConfig,
-	RESULTS_DIR,
-	type SubagentState,
-	TEMP_ROOT_DIR,
-} from "../shared/types.ts";
+import { isAsyncAvailable } from "../runs/inprocess/background.ts";
+import { ASYNC_DIR, type ExtensionConfig, RESULTS_DIR, type SubagentState, TEMP_ROOT_DIR } from "../shared/types.ts";
 
 interface DoctorPaths {
 	tempRootDir: string;
 	asyncDir: string;
 	resultsDir: string;
-	chainRunsDir: string;
 }
 
 interface DoctorDeps {
@@ -46,7 +38,6 @@ const DEFAULT_PATHS: DoctorPaths = {
 	tempRootDir: TEMP_ROOT_DIR,
 	asyncDir: ASYNC_DIR,
 	resultsDir: RESULTS_DIR,
-	chainRunsDir: CHAIN_RUNS_DIR,
 };
 
 const DEFAULT_DEPS: DoctorDeps = {
@@ -126,24 +117,14 @@ function formatSessionLines(input: DoctorReportInput): string[] {
 
 function formatDiscovery(input: DoctorReportInput, deps: DoctorDeps): string[] {
 	return [
-		lineFromCheck("agents/chains", () => {
+		lineFromCheck("agents", () => {
 			const discovered = deps.discoverAgentsAll(input.cwd);
 			const agentCounts = {
 				builtin: discovered.builtin.length,
 				user: discovered.user.length,
 				project: discovered.project.length,
 			};
-			const chainCounts = discovered.chains.reduce<Record<AgentSource, number>>(
-				(counts, chain) => {
-					counts[chain.source] += 1;
-					return counts;
-				},
-				{ builtin: 0, user: 0, project: 0 },
-			);
-			return [
-				`- agents: total ${agentCounts.builtin + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
-				`- chains: total ${discovered.chains.length} (${formatSourceCounts(chainCounts)})`,
-			].join("\n");
+			return `- agents: total ${agentCounts.builtin + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`;
 		}),
 		lineFromCheck("skills", () => {
 			const skills = deps.discoverAvailableSkills(input.cwd);
@@ -188,7 +169,6 @@ export function buildDoctorReport(input: DoctorReportInput): string {
 		formatExistingDirectory("temp root", paths.tempRootDir),
 		formatExistingDirectory("async runs", paths.asyncDir),
 		formatExistingDirectory("results", paths.resultsDir),
-		formatExistingDirectory("chain runs", paths.chainRunsDir),
 		"",
 		"Discovery",
 		...formatDiscovery(input, deps),

package/dist/builtin/subagents/src/extension/fanout-child.ts

@@ -2,19 +2,20 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { ExtensionAPI, ToolDefinition } from "@bastani/atomic";
-import { APP_NAME, getEnvValue } from "@bastani/atomic";
+import { APP_NAME } from "@bastani/atomic";
 
 import { discoverAgents } from "../agents/agents.ts";
 import { resolveSubagentIntercomTarget } from "../intercom/intercom-bridge.ts";
 import { deliverSubagentIntercomMessageEvent } from "../intercom/result-intercom.ts";
 import { createSubagentExecutor, type SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
+import type { ChildModePolicy } from "../runs/inprocess/child-policy.ts";
+import { hasInProcessNestedRoute, subscribeInProcessControlRequests } from "../runs/inprocess/nested-routing.ts";
 import {
 	type NestedRoute,
 	readNestedControlRequests,
 	resolveNestedRouteFromEnv,
 	writeNestedControlResult,
-} from "../runs/shared/nested-events.ts";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
+} from "../runs/inprocess/runtime-support/nested-api.ts";
 import { getArtifactsDir } from "../shared/artifacts.ts";
 import type { Details, SubagentState } from "../shared/types.ts";
 import { beginApiLifecycle } from "./api-lifecycle.ts";
@@ -63,8 +64,6 @@ const TRIMMED_SEEN_REQUEST_IDS = 512;
 const MAX_PENDING_RESULTS = 256;
 const MAX_PENDING_RESULT_ATTEMPTS = 10;
 const MAX_PENDING_RESULT_AGE_MS = 60_000;
-const NESTED_CONTROL_INBOX_TIMER_KEY = "fanout-child:nested-control-inbox";
-
 type NestedControlResultPayload = Parameters<typeof writeNestedControlResult>[1];
 
 interface PendingControlResult {
@@ -139,7 +138,15 @@ function buildNestedControlResult(
 	})();
 }
 
-export function startNestedControlInboxListener(pi: ExtensionAPI, state: SubagentState): NodeJS.Timeout | undefined {
+const nestedControlListenerCleanups = new WeakMap<ExtensionAPI, () => void>();
+
+export function stopNestedControlInboxListener(pi: ExtensionAPI): void {
+	nestedControlListenerCleanups.get(pi)?.();
+	nestedControlListenerCleanups.delete(pi);
+}
+
+export function startNestedControlInboxListener(pi: ExtensionAPI, state: SubagentState): (() => void) | undefined {
+	stopNestedControlInboxListener(pi);
 	let route: NestedRoute | undefined;
 	try {
 		route = resolveNestedRouteFromEnv();
@@ -150,70 +157,82 @@ export function startNestedControlInboxListener(pi: ExtensionAPI, state: Subagen
 	const seen = new Set<string>();
 	const inFlight = new Set<string>();
 	const pendingResults = new Map<string, PendingControlResult>();
-	const timer = setInterval(() => {
-		try {
-			for (const request of readNestedControlRequests(route)) {
-				if (seen.has(request.requestId) || inFlight.has(request.requestId)) continue;
-				inFlight.add(request.requestId);
-				void (async () => {
-					try {
-						const pending = pendingResults.get(request.requestId);
-						const result = pending?.result ?? (await buildNestedControlResult(pi, state, request));
-						try {
-							writeNestedControlResult(route, result);
-						} catch (error) {
-							const now = Date.now();
-							const nextPending: PendingControlResult = {
-								result,
-								firstFailureAt: pending?.firstFailureAt ?? now,
-								attempts: (pending?.attempts ?? 0) + 1,
-							};
-							pendingResults.set(request.requestId, nextPending);
-							if (shouldDropPendingResult(nextPending, pendingResults.size, now)) {
-								pendingResults.delete(request.requestId);
-								rememberSeenRequest(seen, request.requestId);
-								dropControlRequestFile(request.filePath, request.requestId);
-								console.error(
-									`Dropping nested control result for request '${request.requestId}' targeting '${request.targetRunId}' after ${nextPending.attempts} failed write attempts via inbox '${route.controlInbox}':`,
-									error,
-								);
-							} else if (nextPending.attempts === 1) {
-								console.error(
-									`Failed to write nested control result for request '${request.requestId}' targeting '${request.targetRunId}' via inbox '${route.controlInbox}'; keeping request for retry:`,
-									error,
-								);
-							}
-							return;
-						}
+	const processRequest = (request: ReturnType<typeof readNestedControlRequests>[number]): void => {
+		if (seen.has(request.requestId) || inFlight.has(request.requestId)) return;
+		inFlight.add(request.requestId);
+		void (async () => {
+			try {
+				const pending = pendingResults.get(request.requestId);
+				const result = pending?.result ?? (await buildNestedControlResult(pi, state, request));
+				try {
+					writeNestedControlResult(route!, result);
+				} catch (error) {
+					const now = Date.now();
+					const nextPending: PendingControlResult = {
+						result,
+						firstFailureAt: pending?.firstFailureAt ?? now,
+						attempts: (pending?.attempts ?? 0) + 1,
+					};
+					pendingResults.set(request.requestId, nextPending);
+					if (shouldDropPendingResult(nextPending, pendingResults.size, now)) {
 						pendingResults.delete(request.requestId);
 						rememberSeenRequest(seen, request.requestId);
 						dropControlRequestFile(request.filePath, request.requestId);
-					} finally {
-						inFlight.delete(request.requestId);
+						console.error(
+							`Dropping nested control result for request '${request.requestId}' targeting '${request.targetRunId}' after ${nextPending.attempts} failed writes via inbox '${route!.controlInbox}':`,
+							error,
+						);
+					} else if (nextPending.attempts === 1) {
+						console.error(
+							`Failed to write nested control result for request '${request.requestId}' targeting '${request.targetRunId}' via inbox '${route!.controlInbox}'; keeping request for retry:`,
+							error,
+						);
 					}
-				})();
+					return;
+				}
+				pendingResults.delete(request.requestId);
+				rememberSeenRequest(seen, request.requestId);
+				dropControlRequestFile(request.filePath, request.requestId);
+			} finally {
+				inFlight.delete(request.requestId);
 			}
+		})();
+	};
+	const processPending = (): void => {
+		for (const request of readNestedControlRequests(route!)) processRequest(request);
+	};
+	processPending();
+	const memoryCleanup = hasInProcessNestedRoute(route)
+		? subscribeInProcessControlRequests(route, processRequest)
+		: undefined;
+	let watcher: fs.FSWatcher | undefined;
+	if (!memoryCleanup) {
+		try {
+			watcher = fs.watch(route.controlInbox, { persistent: false }, () => processPending());
 		} catch (error) {
-			console.error(
-				`Failed to poll nested control inbox '${route.controlInbox}' for root '${route.rootRunId}':`,
-				error,
-			);
+			console.error(`Failed to watch nested control inbox '${route.controlInbox}':`, error);
 		}
-	}, 200);
-	timer.unref?.();
-	state.cleanupTimers.set(NESTED_CONTROL_INBOX_TIMER_KEY, timer);
-	return timer;
+	}
+	const cleanup = () => {
+		memoryCleanup?.();
+		watcher?.close();
+		if (nestedControlListenerCleanups.get(pi) === cleanup) nestedControlListenerCleanups.delete(pi);
+	};
+	nestedControlListenerCleanups.set(pi, cleanup);
+	return cleanup;
 }
 
-export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI): void {
-	if (getEnvValue(SUBAGENT_CHILD_ENV) !== "1" || getEnvValue(SUBAGENT_FANOUT_CHILD_ENV) !== "1") return;
+export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI, childPolicy?: ChildModePolicy): void {
+	if (!childPolicy?.fanoutAuthorized) return;
 
 	const lifecycle = beginApiLifecycle(pi);
 
 	try {
 		const config = loadConfig();
 		const state = createChildSafeState();
+		let nestedListenerCleanup: (() => void) | undefined;
 		lifecycle.setCleanup(() => {
+			nestedListenerCleanup?.();
 			for (const timer of state.cleanupTimers.values()) clearInterval(timer);
 			state.cleanupTimers.clear();
 		});
@@ -226,7 +245,8 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI):
 			getSubagentSessionRoot,
 			expandTilde,
 			discoverAgents,
-			allowMutatingManagementActions: false,
+			childPolicy,
+			allowMutatingManagementActions: childPolicy ? childPolicy.managementActions === "full" : false,
 		});
 
 		const tool: ToolDefinition<typeof SubagentParams, Details> = {
@@ -246,7 +266,7 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI):
 		};
 
 		pi.registerTool(tool);
-		startNestedControlInboxListener(pi, state);
+		nestedListenerCleanup = startNestedControlInboxListener(pi, state);
 		pi.on?.("session_shutdown", () => lifecycle.dispose());
 	} catch (error) {
 		lifecycle.dispose();

package/dist/builtin/subagents/src/extension/index.ts

@@ -6,7 +6,6 @@ import {
 	APP_NAME,
 	type ExtensionAPI,
 	type ExtensionContext,
-	getEnvValue,
 	keyHintIfBound,
 	type ToolDefinition,
 } from "@bastani/atomic";
@@ -25,7 +24,6 @@ import { discoverAgents } from "../agents/agents.ts";
 import { createAsyncJobTracker } from "../runs/background/async-job-tracker.ts";
 import registerSubagentNotify, { type SubagentNotifyDetails } from "../runs/background/notify.ts";
 import { createSubagentExecutor, type SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
 import { getArtifactsDir } from "../shared/artifacts.ts";
 import { formatDuration, shortenPath } from "../shared/formatters.ts";
 import { resolveCurrentSessionId } from "../shared/session-identity.ts";
@@ -48,19 +46,25 @@ import {
 	stopWidgetAnimation,
 } from "../tui/render.ts";
 import { loadConfig } from "./config.ts";
-import registerFanoutChildSubagentExtension from "./fanout-child.ts";
 import { parseSubagentNotifyContent } from "./notification-content.ts";
 import { DEFAULT_PROMPT_GUIDANCE } from "./prompt-guidance.ts";
 import { SubagentParams } from "./schemas.ts";
 import { SUBAGENT_TOOL_DESCRIPTION } from "./tool-description.ts";
 
+export {
+	PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT,
+	PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT,
+	PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT,
+	PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT,
+	PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT,
+	registerPromptTemplateBridgeRequestSettlement,
+} from "../slash/prompt-template-bridge.ts";
 export { SUBAGENT_TOOL_DESCRIPTION } from "./tool-description.ts";
 
 import {
 	ASYNC_DIR,
 	DEFAULT_ARTIFACT_CONFIG,
 	type Details,
-	RESULTS_DIR,
 	SLASH_RESULT_TYPE,
 	SUBAGENT_ASYNC_COMPLETE_EVENT,
 	SUBAGENT_ASYNC_STARTED_EVENT,
@@ -90,18 +94,6 @@ function getSubagentSessionRoot(parentSessionFile: string | null): string {
 function expandTilde(p: string): string {
 	return p.startsWith("~/") ? path.join(os.homedir(), p.slice(2)) : p;
 }
-function ensureAccessibleDir(dirPath: string): void {
-	fs.mkdirSync(dirPath, { recursive: true });
-	try {
-		fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
-	} catch {
-		try {
-			fs.rmSync(dirPath, { recursive: true, force: true });
-		} catch {}
-		fs.mkdirSync(dirPath, { recursive: true });
-		fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
-	}
-}
 function isSlashResultRunning(result: { details?: Details }): boolean {
 	return (
 		result.details?.progress?.some((entry) => entry.status === "running") ||
@@ -111,7 +103,7 @@ function isSlashResultRunning(result: { details?: Details }): boolean {
 }
 function isSlashResultError(result: { details?: Details }): boolean {
 	return (
-		result.details?.results.some((entry) => entry.exitCode !== 0 && entry.progress?.status !== "running") || false
+		result.details?.results.some((entry) => entry.status === "error" && entry.progress?.status !== "running") || false
 	);
 }
 type SubagentToolRenderState = SubagentResultRenderState;
@@ -221,16 +213,10 @@ class SubagentControlNoticeComponent implements Component {
 }
 
 export default function registerSubagentExtension(pi: ExtensionAPI): void {
-	if (getEnvValue(SUBAGENT_CHILD_ENV) === "1") {
-		if (getEnvValue(SUBAGENT_FANOUT_CHILD_ENV) === "1") registerFanoutChildSubagentExtension(pi);
-		return;
-	}
 	const lifecycle = beginApiLifecycle(pi);
 	const registrationFailureCleanups: Array<() => void> = [];
 	let runtimeCleanupInstalled = false;
 	try {
-		ensureAccessibleDir(RESULTS_DIR);
-		ensureAccessibleDir(ASYNC_DIR);
 		const config = loadConfig();
 		const asyncByDefault = config.asyncByDefault === true;
 		const tempArtifactsDir = getArtifactsDir(null);
@@ -254,18 +240,14 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 				clear: () => {},
 			},
 		};
-		const maintenance = createSubagentStartupMaintenance(pi, state, {
-			resultsDir: RESULTS_DIR,
+		const maintenance = createSubagentStartupMaintenance(state, {
 			artifactCleanupDays: DEFAULT_ARTIFACT_CONFIG.cleanupDays,
-			resultTtlMs: 10 * 60 * 1000,
 		});
 		maintenance.scheduleStartupCleanup();
 		registrationFailureCleanups.push(() => maintenance.stop());
-		maintenance.startResultWatcherDeferred();
-		maintenance.primeExistingResultsDeferred();
 		const { ensurePoller, handleStarted, handleComplete, resetJobs, hydrateActiveJobsDeferred } =
 			createAsyncJobTracker(pi, state, ASYNC_DIR);
-		const executor = createSubagentExecutor({
+		const executorDeps = {
 			pi,
 			state,
 			config,
@@ -274,7 +256,23 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			getSubagentSessionRoot,
 			expandTilde,
 			discoverAgents,
-		});
+		};
+		const executor = createSubagentExecutor(executorDeps);
+		const childExecutors = new Map<string, ReturnType<typeof createSubagentExecutor>>();
+		const executorForContext = (ctx: ExtensionContext): ReturnType<typeof createSubagentExecutor> => {
+			const policy = ctx.subagentPolicy;
+			if (!policy) return executor;
+			const key = `${policy.managementActions}:${policy.fanoutAuthorized ? "fanout" : "no-fanout"}`;
+			const cached = childExecutors.get(key);
+			if (cached) return cached;
+			const childExecutor = createSubagentExecutor({
+				...executorDeps,
+				childPolicy: policy,
+				allowMutatingManagementActions: policy.managementActions === "full",
+			});
+			childExecutors.set(key, childExecutor);
+			return childExecutor;
+		};
 		pi.registerMessageRenderer<SlashMessageDetails>(SLASH_RESULT_TYPE, (message, options, theme) => {
 			const details = resolveSlashMessageDetails(message.details);
 			if (!details) return undefined;
@@ -304,7 +302,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 				state.lastUiContext = ctx;
 				ctx.ui.setToolsExpanded(false);
 			}
-			return executor.execute(id, params, signal, onUpdate, ctx);
+			return executorForContext(ctx).execute(id, params, signal, onUpdate, ctx);
 		};
 		const slashBridge = registerSlashSubagentBridge({
 			events: pi.events,
@@ -374,7 +372,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			},
 			renderCall(args, theme) {
 				if (args.action) {
-					const target = args.agent || args.chainName || "";
+					const target = args.agent || "";
 					return new Text(
 						`${theme.fg("toolTitle", theme.bold("subagent "))}${args.action}${target ? ` ${theme.fg("accent", target)}` : ""}`,
 						0,
@@ -384,12 +382,6 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 				const isParallel = (args.tasks?.length ?? 0) > 0;
 				const parallelCount = effectiveParallelTaskCount(args.tasks as Array<{ count?: unknown }> | undefined);
 				const asyncLabel = args.async === true ? theme.fg("warning", " [async]") : "";
-				if (args.chain?.length)
-					return new Text(
-						`${theme.fg("toolTitle", theme.bold("subagent "))}chain (${args.chain.length})${asyncLabel}`,
-						0,
-						0,
-					);
 				if (isParallel)
 					return new Text(
 						`${theme.fg("toolTitle", theme.bold("subagent "))}parallel (${parallelCount})${asyncLabel}`,
@@ -454,6 +446,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 				...Array.from(state.cleanupTimers.values(), (timer) => () => clearTimeout(timer)),
 				() => state.cleanupTimers.clear(),
 				() => state.asyncJobs.clear(),
+				() => childExecutors.clear(),
 				() => clearSlashSnapshots(pi),
 				() => slashBridge.cancelAll(),
 				() => slashBridge.dispose(),
@@ -489,7 +482,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			resetJobs(ctx);
 			hydrateActiveJobsDeferred(ctx);
 			restoreSlashFinalSnapshots(ctx.sessionManager.getEntries(), pi);
-			maintenance.primeExistingResultsDeferred();
+			restoreSlashFinalSnapshots(ctx.sessionManager.getEntries(), pi);
 		};
 		pi.on("session_start", (_event, ctx) => {
 			if (lifecycle.isCurrent()) resetSessionState(ctx);

package/dist/builtin/subagents/src/extension/prompt-guidance.ts

@@ -1,11 +1,11 @@
 export const DEFAULT_PROMPT_GUIDANCE: string[] = [
 	`**Subagent orchestration**: Use subagents for focused specialist work inside workflows or as bounded delegation when a workflow would be unnecessary overhead.
   - Because workflows are the default for non-trivial structured work with verifiable objectives, do not stretch parent-controlled subagent calls into an ad hoc implementation, review, or retry pipeline; use a workflow and let its stages delegate specialists.
-  - Use a single subagent for a focused specialty, a chain for a bounded sequential handoff, or parallel tasks for independent work. Keep substantial-overlap tasks together rather than duplicating investigation across agents.
+  - Use a single subagent for a focused specialty or parallel tasks for independent work. Keep substantial-overlap tasks together rather than duplicating investigation across agents.
   - Delegate noisy or context-heavy command investigation when isolation helps, but run concise commands inline when that is simpler.
   - Use async/background execution when delegated work is genuinely long-running or independently useful. Foreground execution is appropriate when the parent needs the result before proceeding; do not duplicate a delegated job while waiting.
   - Use the debugger subagent for actual failures that need reproduction, root-cause diagnosis, and a validated fix; additional debugger or research delegates are optional when they add a distinct useful angle.
   - Let each named agent use its declared model and fallback policy: omit the explicit model argument unless the user requests an exact model or a documented task requirement needs one, and record the reason for any override before launch. Do not choose an ad hoc model merely for diversity.
   - If an agent has no declared model or fallback policy, consult packages/coding-agent/docs/models/model-selection.md for the role's Pareto-efficient recommendations, then use workflow({ action: "models" }) when available to inspect the configured catalog. Pin only a returned fullId and only append a thinking level listed for that entry. If the catalog tool is unavailable, the catalog is empty, or no recommended model is present, leave the child unpinned and state the limitation rather than inventing a model. Do not inspect credentials or infer why a model is absent.
-  - Workflow stages automatically receive their invocation-scoped Intercom group, and delegated children inherit the launching session's group across single, parallel, chain, async, and follow-up work. Do not create or propagate group identifiers for ordinary workflow-stage delegation; use an explicit group only for an intentional topology override. Keep contact_supervisor available for cross-group escalation.`,
+  - Workflow stages automatically receive their invocation-scoped Intercom group, and delegated children inherit the launching session's group across single, parallel, async, and follow-up work. Do not create or propagate group identifiers for ordinary workflow-stage delegation; use an explicit group only for an intentional topology override. Keep contact_supervisor available for cross-group escalation.`,
 ];