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

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

@@ -3,25 +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/inprocess/background.ts";
-import {
-	ASYNC_DIR,
-	CHAIN_RUNS_DIR,
-	type ExtensionConfig,
-	RESULTS_DIR,
-	type SubagentState,
-	TEMP_ROOT_DIR,
-} from "../shared/types.ts";
+import { type ExtensionConfig, type SubagentState, TEMP_ROOT_DIR } from "../shared/types.ts";
 
 interface DoctorPaths {
 	tempRootDir: string;
-	asyncDir: string;
-	resultsDir: string;
-	chainRunsDir: string;
 }
 
 interface DoctorDeps {
-	isAsyncAvailable: () => boolean;
 	discoverAgentsAll: typeof discoverAgentsAll;
 	discoverAvailableSkills: typeof discoverAvailableSkills;
 	diagnoseIntercomBridge: typeof diagnoseIntercomBridge;
@@ -42,15 +30,9 @@ interface DoctorReportInput {
 	deps?: Partial<DoctorDeps>;
 }
 
-const DEFAULT_PATHS: DoctorPaths = {
-	tempRootDir: TEMP_ROOT_DIR,
-	asyncDir: ASYNC_DIR,
-	resultsDir: RESULTS_DIR,
-	chainRunsDir: CHAIN_RUNS_DIR,
-};
+const DEFAULT_PATHS: DoctorPaths = { tempRootDir: TEMP_ROOT_DIR };
 
 const DEFAULT_DEPS: DoctorDeps = {
-	isAsyncAvailable,
 	discoverAgentsAll,
 	discoverAvailableSkills,
 	diagnoseIntercomBridge,
@@ -126,24 +108,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);
@@ -181,14 +153,10 @@ export function buildDoctorReport(input: DoctorReportInput): string {
 		"",
 		"Runtime",
 		`- cwd: ${input.cwd}`,
-		lineFromCheck("async support", () => `- async support: ${deps.isAsyncAvailable() ? "available" : "unavailable"}`),
 		...formatSessionLines(input),
 		"",
 		"Filesystem",
 		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

@@ -39,23 +39,12 @@ export function createChildSafeState(): SubagentState {
 	return {
 		baseCwd: "",
 		currentSessionId: null,
-		asyncJobs: new Map(),
 		subagentInProgress: false,
 		foregroundRuns: new Map(),
 		foregroundControls: new Map(),
 		lastForegroundControlId: null,
 		pendingForegroundControlNotices: new Map(),
-		cleanupTimers: new Map(),
 		lastUiContext: null,
-		poller: null,
-		completionSeen: new Map(),
-		watcher: null,
-		watcherRestartTimer: null,
-		// Child-safe stub: the parent extension owns watcher/coalescer/cleanup state.
-		resultFileCoalescer: {
-			schedule: () => false,
-			clear: () => {},
-		},
 	};
 }
 
@@ -231,16 +220,10 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI, c
 		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();
-		});
 		const executor = createSubagentExecutor({
 			pi,
 			state,
 			config,
-			asyncByDefault: config.asyncByDefault === true,
 			tempArtifactsDir: getArtifactsDir(null),
 			getSubagentSessionRoot,
 			expandTilde,
@@ -248,6 +231,7 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI, c
 			childPolicy,
 			allowMutatingManagementActions: childPolicy ? childPolicy.managementActions === "full" : false,
 		});
+		lifecycle.setCleanup(() => nestedListenerCleanup?.());
 
 		const tool: ToolDefinition<typeof SubagentParams, Details> = {
 			name: "subagent",

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

@@ -1,4 +1,4 @@
-/** Subagent Tool: sync/async orchestration extension. */
+/** Subagent Tool: foreground orchestration extension. */
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -21,8 +21,7 @@ import {
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 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 registerSubagentNotify, { type SubagentNotifyDetails } from "../runs/foreground/notify.ts";
 import { createSubagentExecutor, type SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import { getArtifactsDir } from "../shared/artifacts.ts";
 import { formatDuration, shortenPath } from "../shared/formatters.ts";
@@ -43,7 +42,6 @@ import {
 	renderSubagentResult,
 	type SubagentResultRenderState,
 	stopResultAnimations,
-	stopWidgetAnimation,
 } from "../tui/render.ts";
 import { loadConfig } from "./config.ts";
 import { parseSubagentNotifyContent } from "./notification-content.ts";
@@ -51,15 +49,20 @@ 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,
 	SLASH_RESULT_TYPE,
-	SUBAGENT_ASYNC_COMPLETE_EVENT,
-	SUBAGENT_ASYNC_STARTED_EVENT,
 	SUBAGENT_CONTROL_EVENT,
 	type SubagentState,
 } from "../shared/types.ts";
@@ -210,40 +213,26 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	let runtimeCleanupInstalled = false;
 	try {
 		const config = loadConfig();
-		const asyncByDefault = config.asyncByDefault === true;
 		const tempArtifactsDir = getArtifactsDir(null);
 		const state: SubagentState = {
 			baseCwd: "",
 			currentSessionId: null,
-			asyncJobs: new Map(),
 			subagentInProgress: false,
 			foregroundRuns: new Map(),
 			foregroundControls: new Map(),
 			lastForegroundControlId: null,
 			pendingForegroundControlNotices: new Map(),
-			cleanupTimers: new Map(),
 			lastUiContext: null,
-			poller: null,
-			completionSeen: new Map(),
-			watcher: null,
-			watcherRestartTimer: null,
-			resultFileCoalescer: {
-				schedule: () => false,
-				clear: () => {},
-			},
 		};
 		const maintenance = createSubagentStartupMaintenance(state, {
 			artifactCleanupDays: DEFAULT_ARTIFACT_CONFIG.cleanupDays,
 		});
 		maintenance.scheduleStartupCleanup();
 		registrationFailureCleanups.push(() => maintenance.stop());
-		const { ensurePoller, handleStarted, handleComplete, resetJobs, hydrateActiveJobsDeferred } =
-			createAsyncJobTracker(pi, state, ASYNC_DIR);
 		const executorDeps = {
 			pi,
 			state,
 			config,
-			asyncByDefault,
 			tempArtifactsDir,
 			getSubagentSessionRoot,
 			expandTilde,
@@ -312,13 +301,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 				if (request.tasks && request.tasks.length > 0) {
 					return executeSubagentCollapsed(
 						requestId,
-						{
-							tasks: request.tasks,
-							context: request.context,
-							cwd: request.cwd,
-							worktree: request.worktree,
-							async: false,
-						},
+						{ tasks: request.tasks, context: request.context, cwd: request.cwd, worktree: request.worktree },
 						signal,
 						onUpdate,
 						ctx,
@@ -332,7 +315,6 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 						context: request.context,
 						cwd: request.cwd,
 						model: request.model,
-						async: false,
 					},
 					signal,
 					onUpdate,
@@ -364,7 +346,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,
@@ -373,21 +355,10 @@ 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}`,
-						0,
-						0,
-					);
 				return new Text(
-					`${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("accent", args.agent || "?")}${asyncLabel}`,
+					isParallel
+						? `${theme.fg("toolTitle", theme.bold("subagent "))}parallel (${parallelCount})`
+						: `${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("accent", args.agent || "?")}`,
 					0,
 					0,
 				);
@@ -401,12 +372,6 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		const notifyCleanup = registerSubagentNotify(pi);
 		registrationFailureCleanups.push(notifyCleanup);
 		const visibleControlNotices = getApiScopedSet(pi, "__piSubagentVisibleControlNoticesByApi");
-		const startedEventHandler = (payload: unknown) => {
-			if (lifecycle.isCurrent()) handleStarted(payload);
-		};
-		const completeEventHandler = (payload: unknown) => {
-			if (lifecycle.isCurrent()) handleComplete(payload);
-		};
 		const controlEventHandler = (payload: unknown) => {
 			if (!lifecycle.isCurrent()) return;
 			handleSubagentControlNotice({
@@ -417,15 +382,9 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			});
 		};
 		const eventUnsubscribes: Array<() => void> = [];
-		for (const [event, handler] of [
-			[SUBAGENT_ASYNC_STARTED_EVENT, startedEventHandler],
-			[SUBAGENT_ASYNC_COMPLETE_EVENT, completeEventHandler],
-			[SUBAGENT_CONTROL_EVENT, controlEventHandler],
-		] as const) {
-			const unsubscribe = pi.events.on(event, handler);
-			eventUnsubscribes.push(unsubscribe);
-			registrationFailureCleanups.push(unsubscribe);
-		}
+		const unsubscribeControl = pi.events.on(SUBAGENT_CONTROL_EVENT, controlEventHandler);
+		eventUnsubscribes.push(unsubscribeControl);
+		registrationFailureCleanups.push(unsubscribeControl);
 		let cleaned = false;
 		const runtimeCleanup = () => {
 			if (cleaned) return;
@@ -434,16 +393,8 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 				...eventUnsubscribes,
 				notifyCleanup,
 				() => maintenance.stop(),
-				() => stopWidgetAnimation(undefined, pi),
 				() => stopResultAnimations(),
-				() => {
-					if (state.poller) clearInterval(state.poller);
-					state.poller = null;
-				},
 				() => clearPendingForegroundControlNotices(state),
-				...Array.from(state.cleanupTimers.values(), (timer) => () => clearTimeout(timer)),
-				() => state.cleanupTimers.clear(),
-				() => state.asyncJobs.clear(),
 				() => childExecutors.clear(),
 				() => clearSlashSnapshots(pi),
 				() => slashBridge.cancelAll(),
@@ -461,13 +412,6 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		};
 		lifecycle.setCleanup(runtimeCleanup);
 		runtimeCleanupInstalled = true;
-		pi.on("tool_result", (event, ctx) => {
-			if (!lifecycle.isCurrent() || event.toolName !== "subagent") return;
-			if (!ctx.hasUI) return;
-			state.lastUiContext = ctx;
-			hydrateActiveJobsDeferred(ctx);
-			if (state.asyncJobs.size > 0) ensurePoller();
-		});
 		const cleanupSessionArtifacts = (ctx: ExtensionContext) => {
 			maintenance.cleanupSessionArtifactsDeferred(ctx);
 		};
@@ -477,9 +421,6 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			state.lastUiContext = ctx;
 			cleanupSessionArtifacts(ctx);
 			clearPendingForegroundControlNotices(state);
-			resetJobs(ctx);
-			hydrateActiveJobsDeferred(ctx);
-			restoreSlashFinalSnapshots(ctx.sessionManager.getEntries(), pi);
 			restoreSlashFinalSnapshots(ctx.sessionManager.getEntries(), pi);
 		};
 		pi.on("session_start", (_event, ctx) => {

package/dist/builtin/subagents/src/extension/notification-content.ts

@@ -1,4 +1,4 @@
-import type { SubagentNotifyDetails } from "../runs/background/notify.ts";
+import type { SubagentNotifyDetails } from "../runs/foreground/notify.ts";
 
 const HEADER_STATUSES = ["completed", "failed", "paused"] as const;
 

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.
+  - Foreground execution is the only subagent execution mode; do not duplicate a delegated job while waiting. Workflow stages may still run their own durable work in the background.
   - 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, 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.`,
 ];

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

@@ -36,12 +36,6 @@ const RootReadsOverride = Type.Unsafe({
 		"Files for a single agent to read before running, or false to disable. Relative paths resolve against the effective child cwd.",
 });
 
-const JsonSchemaObject = Type.Unsafe({
-	type: "object",
-	additionalProperties: true,
-	description: "Plain JSON Schema object for structured output.",
-});
-
 const MaxOutputSchema = Type.Object(
 	{
 		bytes: Type.Optional(Type.Number()),
@@ -71,137 +65,6 @@ const TaskItem = Type.Object({
 	group: Type.Optional(GroupSchema),
 });
 
-// Parallel task item (within a parallel step)
-const ParallelTaskSchema = Type.Object({
-	agent: Type.String(),
-	task: Type.Optional(
-		Type.String({
-			description: "Task template with {task}, {previous}, {chain_dir} variables. Defaults to {previous}.",
-		}),
-	),
-	phase: Type.Optional(Type.String({ description: "Optional phase/group label for status and graph rendering." })),
-	label: Type.Optional(Type.String({ description: "Optional user-facing label for this parallel task." })),
-	as: Type.Optional(
-		Type.String({ description: "Optional safe identifier used as {outputs.name} in later chain steps." }),
-	),
-	outputSchema: Type.Optional(JsonSchemaObject),
-	cwd: Type.Optional(Type.String()),
-	count: Type.Optional(
-		Type.Integer({ minimum: 1, description: "Repeat this parallel task N times with the same settings." }),
-	),
-	output: Type.Optional(OutputOverride),
-	outputMode: Type.Optional(OutputModeOverride),
-	reads: Type.Optional(ReadsOverride),
-	progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" })),
-	skill: Type.Optional(SkillOverride),
-	model: Type.Optional(Type.String({ description: "Override model for this task" })),
-	group: Type.Optional(GroupSchema),
-});
-
-const DynamicExpandSchema = Type.Object(
-	{
-		from: Type.Object(
-			{
-				output: Type.String({ description: "Prior named structured output to expand from." }),
-				path: Type.String({ description: "JSON Pointer into the structured output, e.g. /items." }),
-			},
-			{ additionalProperties: false },
-		),
-		item: Type.Optional(Type.String({ description: "Template variable name for each item. Defaults to item." })),
-		key: Type.Optional(Type.String({ description: "JSON Pointer relative to each item for stable child ids." })),
-		maxItems: Type.Optional(
-			Type.Integer({ minimum: 0, description: "Required fanout bound unless configured globally." }),
-		),
-		onEmpty: Type.Optional(
-			Type.String({ enum: ["skip", "fail"], description: "Empty input behavior. Defaults to skip." }),
-		),
-	},
-	{ additionalProperties: false },
-);
-
-const DynamicParallelTemplateSchema = Type.Object(
-	{
-		agent: Type.String(),
-		task: Type.Optional(
-			Type.String({
-				description:
-					"Task template with {item}, {item.path}, {task}, {previous}, {chain_dir}, and {outputs.name} variables.",
-			}),
-		),
-		phase: Type.Optional(Type.String({ description: "Optional phase/group label for status and graph rendering." })),
-		label: Type.Optional(Type.String({ description: "Optional user-facing label; item templates are supported." })),
-		outputSchema: Type.Optional(JsonSchemaObject),
-		cwd: Type.Optional(Type.String()),
-		output: Type.Optional(OutputOverride),
-		outputMode: Type.Optional(OutputModeOverride),
-		reads: Type.Optional(ReadsOverride),
-		progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" })),
-		skill: Type.Optional(SkillOverride),
-		model: Type.Optional(Type.String({ description: "Override model for this task" })),
-		group: Type.Optional(GroupSchema),
-	},
-	{ additionalProperties: false },
-);
-
-const DynamicCollectSchema = Type.Object(
-	{
-		as: Type.String({ description: "Safe output name for the ordered collected result array." }),
-		outputSchema: Type.Optional(JsonSchemaObject),
-	},
-	{ additionalProperties: false },
-);
-
-// Flattened so chain steps do not need an object-shape anyOf/oneOf union.
-const ChainItem = Type.Object(
-	{
-		agent: Type.Optional(Type.String({ description: "Sequential step agent name" })),
-		task: Type.Optional(
-			Type.String({
-				description:
-					"Task template with variables: {task}=original request, {previous}=prior step's text response, {chain_dir}=shared folder, {outputs.name}=prior named output. Required for first step, defaults to '{previous}' for subsequent steps.",
-			}),
-		),
-		phase: Type.Optional(Type.String({ description: "Optional phase/group label for status and graph rendering." })),
-		label: Type.Optional(Type.String({ description: "Optional user-facing label for this chain step." })),
-		as: Type.Optional(
-			Type.String({ description: "Optional safe identifier used as {outputs.name} in later chain steps." }),
-		),
-		outputSchema: Type.Optional(JsonSchemaObject),
-		cwd: Type.Optional(Type.String()),
-		output: Type.Optional(OutputOverride),
-		outputMode: Type.Optional(OutputModeOverride),
-		reads: Type.Optional(ReadsOverride),
-		progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" })),
-		skill: Type.Optional(SkillOverride),
-		model: Type.Optional(Type.String({ description: "Override model for this step" })),
-		parallel: Type.Optional(
-			Type.Unsafe({
-				anyOf: [
-					Type.Array(ParallelTaskSchema, { minItems: 1, description: "Tasks to run in parallel" }),
-					DynamicParallelTemplateSchema,
-				],
-				description:
-					"Static parallel tasks array, or a single dynamic fanout child template when expand/collect are present.",
-			}),
-		),
-		expand: Type.Optional(DynamicExpandSchema),
-		collect: Type.Optional(DynamicCollectSchema),
-		concurrency: Type.Optional(Type.Number({ description: "Max concurrent tasks (default: 4)" })),
-		failFast: Type.Optional(Type.Boolean({ description: "Stop on first failure (default: false)" })),
-		worktree: Type.Optional(
-			Type.Boolean({
-				description: "Create isolated git worktrees for each parallel task.",
-			}),
-		),
-		group: Type.Optional(GroupSchema),
-	},
-	{
-		description:
-			"Chain step: use {agent, task?, ...} for sequential, {parallel: [...]} for static concurrent execution, or {expand, parallel: {...}, collect} for dynamic fanout.",
-		additionalProperties: false,
-	},
-);
-
 const ControlOverrides = Type.Object({
 	enabled: Type.Optional(
 		Type.Boolean({ description: "Enable/disable subagent control attention tracking for this run" }),
@@ -237,8 +100,8 @@ const ControlOverrides = Type.Object({
 		}),
 	),
 	notifyChannels: Type.Optional(
-		Type.Array(Type.String({ enum: ["event", "async", "intercom"] }), {
-			description: "Notification channels to use when available. Defaults to event, async, and intercom.",
+		Type.Array(Type.String({ enum: ["event", "intercom"] }), {
+			description: "Notification channels to use when available. Defaults to event and intercom.",
 		}),
 	),
 });
@@ -267,11 +130,6 @@ export const SubagentParams = Type.Object(
 					"Target run ID for action='interrupt' or action='resume'. Defaults to the most recently active controllable run for interrupt. Prefer id for new calls.",
 			}),
 		),
-		dir: Type.Optional(
-			Type.String({
-				description: "Async run directory for action='status' or action='resume'.",
-			}),
-		),
 		index: Type.Optional(
 			Type.Integer({ minimum: 0, description: "Zero-based child index for actions that target a specific child." }),
 		),
@@ -280,17 +138,10 @@ export const SubagentParams = Type.Object(
 				description: "Follow-up message for action='resume'. Use index to choose a child from multi-child runs.",
 			}),
 		),
-		// Chain identifier for management (can't reuse 'chain' — that's the execution array)
-		chainName: Type.Optional(
-			Type.String({
-				description: "Chain name for get/update/delete management actions",
-			}),
-		),
-		// Agent/chain configuration for create/update (nested to avoid conflicts with execution fields)
 		config: Type.Optional(
 			Type.Unsafe({
 				anyOf: [{ type: "object", additionalProperties: true }, { type: "string" }],
-				description: `Agent or chain config for create/update. Agent: name, package (optional namespace; runtime name becomes package.name), description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext ('fresh'|'fork'), model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress, maxSubagentDepth (integer >= 0, clamped to ${MAX_SUBAGENT_NESTING_DEPTH}). Chain: name, package, description, scope, steps (array of {agent, task?, output?, outputMode?, reads?, model?, skill?, progress?}). Presence of 'steps' creates a chain instead of an agent. String values must be valid JSON.`,
+				description: `Agent config for create/update. Agent: name, package (optional namespace; runtime name becomes package.name), description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext ('fresh'|'fork'), model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress, maxSubagentDepth (integer >= 0, clamped to ${MAX_SUBAGENT_NESTING_DEPTH}). String values must be valid JSON.`,
 			}),
 		),
 		tasks: Type.Optional(
@@ -315,12 +166,6 @@ export const SubagentParams = Type.Object(
 					"Per-worktree diffs included in output.",
 			}),
 		),
-		chain: Type.Optional(
-			Type.Array(ChainItem, {
-				description:
-					"CHAIN mode: sequential pipeline where each step's response becomes {previous} for the next. Use {task}, {previous}, {chain_dir} in task templates.",
-			}),
-		),
 		context: Type.Optional(
 			Type.String({
 				enum: ["fresh", "fork"],
@@ -328,13 +173,6 @@ export const SubagentParams = Type.Object(
 					"'fresh' or 'fork' to branch from parent session. If omitted, any requested agent with defaultContext: 'fork' makes the whole invocation forked; otherwise the default is 'fresh'.",
 			}),
 		),
-		chainDir: Type.Optional(
-			Type.String({
-				description:
-					"Persistent directory for chain artifacts. Default: a user-scoped temp directory under <tmpdir>/ (auto-cleaned after 24h)",
-			}),
-		),
-		async: Type.Optional(Type.Boolean({ description: "Run in background (default: false, or per config)" })),
 		agentScope: Type.Optional(
 			Type.String({
 				description:

package/dist/builtin/subagents/src/extension/startup-maintenance.ts

@@ -2,7 +2,6 @@ import * as path from "node:path";
 import type { ExtensionContext } from "@bastani/atomic";
 import { cleanupOldNestedRuntimeDirs } from "../runs/inprocess/runtime-support/nested-api.ts";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.ts";
-import { cleanupOldChainDirs } from "../shared/settings.ts";
 import type { SubagentState } from "../shared/types.ts";
 
 export interface SubagentStartupMaintenance {
@@ -106,7 +105,6 @@ export function createSubagentStartupMaintenance(
 	return {
 		scheduleStartupCleanup() {
 			schedule(() => {
-				swallowCleanup(cleanupOldChainDirs);
 				swallowCleanup(() => cleanupOldNestedRuntimeDirs(options.artifactCleanupDays));
 				scheduleDelayed(
 					() => swallowCleanup(() => cleanupAllArtifactDirs(options.artifactCleanupDays, contextSessionsRoots)),

package/dist/builtin/subagents/src/extension/tool-description.ts

@@ -1,30 +1,20 @@
-import { APP_NAME } from "@bastani/atomic";
-
 export const SUBAGENT_TOOL_DESCRIPTION = `Delegate bounded specialist work to subagents or manage agent definitions while the parent remains in control.
 EXECUTION (use exactly ONE mode):
 • Execution calls always start non-interactively.
-• Before executing, use { action: "list" } to inspect configured agents/chains. Only execute agents listed as executable/non-disabled.
+• Before executing, use { action: "list" } to inspect configured agents. Only execute agents listed as executable/non-disabled.
 • SINGLE: { agent, task?, progress? } - one focused task; progress:true maintains a run-scoped progress.md under isolated artifact storage without writing it into the child cwd (separate from includeProgress, which only returns runtime telemetry); omit task for self-contained agents
-• CHAIN: { chain: [{agent:"agent-a"}, {parallel:[{agent:"agent-b",count:3}]}] } - bounded sequential pipeline with optional parallel fan-out
 • PARALLEL: { tasks: [{agent,task,count?,output?,reads?,progress?}, ...], concurrency?: number, worktree?: true } - independent concurrent tasks (worktree: isolate each task in a git worktree)
 • Optional context: { context: "fresh" | "fork" } (default: if any requested agent has defaultContext: "fork", the whole invocation uses fork; otherwise "fresh"; inspect agent defaults via { action: "list" })
-• async:true is selective for genuinely long-running/background work; foreground is appropriate when the parent needs the result before proceeding
-• group (string | true) sets the intercom group for spawned children so same-group subagents can intercom each other but stay isolated from other groups. Boolean true or the trimmed, case-insensitive string sentinel "true"/"auto" auto-generates one shared group per parallel set; those names are reserved and cannot be literal groups. Defaults to the current session/stage's group (subagents inherit their launching stage's group). Only applied when the child has intercom access; contact_supervisor still reaches the supervisor across groups.
-CHAIN TEMPLATE VARIABLES (use in task strings):
-• {task} - The original task/request from the user
-• {previous} - Text response from the previous step (empty for first step)
-• {chain_dir} - Shared directory for chain files (e.g., <tmpdir>/${APP_NAME}-subagents-<scope>/chain-runs/abc123/)
-Example: { chain: [{agent:"agent-a", task:"Analyze {task}"}, {agent:"agent-b", task:"Plan based on {previous}"}] }
-MANAGEMENT (use action field, omit agent/task/chain/tasks):
-• { action: "list" } - discover executable agents/chains
+• group (string | true) sets the intercom group for spawned children so same-group subagents can intercom each other but stay isolated from other groups. Boolean true or the trimmed, case-insensitive string sentinel "true"/"auto" auto-generates one shared UUID group per parallel set; those names are reserved and cannot be literal group names. Defaults to the current session/stage's group (subagents inherit their launching stage's group). Only applied when the child has intercom access; contact_supervisor still reaches the supervisor across groups.
+MANAGEMENT (use action field, omit agent/task/tasks):
+• { action: "list" } - discover executable agents
 • { action: "get", agent: "name" } - full detail; packaged agents use dotted runtime names like "package.agent"
 • { action: "create", config: { name: "custom-agent", package: "code-analysis", systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, defaultContext, ... } }
 • { action: "update", agent: "code-analysis.custom-agent", config: { package: "analysis", ... } } - merge
 • { action: "delete", agent: "code-analysis.custom-agent" }
-• Use chainName for chain operations; packaged chains also use dotted runtime names
 CONTROL:
-• { action: "status", id: "..." } - inspect an async/background run by id or prefix
+• { action: "status", id: "..." } - inspect an in-process run by id or prefix
 • { action: "interrupt", id?: "..." } - soft-interrupt the current child turn and leave the run paused
-• { action: "resume", id: "...", message: "...", index?: 0 } - follow up with a live async child or revive a completed async/foreground child from its session
+• { action: "resume", id: "...", message: "...", index?: 0 } - follow up with a live child or revive a retained foreground child
 DIAGNOSTICS:
 • { action: "doctor" } - read-only report for runtime paths, discovery, sessions, and intercom`;