@bastani/atomic 0.9.13-alpha.1 → 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

@@ -4,20 +4,12 @@ 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 { 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/index.ts

@@ -51,6 +51,14 @@ 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 {
@@ -364,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,
@@ -374,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}`,

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.`,
 ];

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" }),
@@ -280,17 +143,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 +171,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,12 +178,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({

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,27 +1,18 @@
-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: "interrupt", id?: "..." } - soft-interrupt the current child turn and leave the run paused

package/dist/builtin/subagents/src/intercom/intercom-bridge.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { APP_NAME, getEnvValue, getProjectConfigDirs } from "@bastani/atomic";
+import { APP_NAME, createChildProcessEnvironment, getEnvValue, getProjectConfigDirs } from "@bastani/atomic";
 import type { AgentConfig } from "../agents/agents.ts";
 import type { ExtensionConfig, IntercomBridgeConfig, IntercomBridgeMode } from "../shared/types.ts";
 import { getAgentDir } from "../shared/utils.ts";
@@ -207,7 +207,11 @@ let cachedGlobalNpmRoot: string | null | undefined;
 function getGlobalNpmRoot(): string | null {
 	if (cachedGlobalNpmRoot !== undefined) return cachedGlobalNpmRoot;
 	try {
-		cachedGlobalNpmRoot = execSync("npm root -g", { encoding: "utf-8", timeout: 5000 }).trim();
+		cachedGlobalNpmRoot = execSync("npm root -g", {
+			encoding: "utf-8",
+			timeout: 5000,
+			env: createChildProcessEnvironment(),
+		}).trim();
 		return cachedGlobalNpmRoot;
 	} catch {
 		cachedGlobalNpmRoot = null;

package/dist/builtin/subagents/src/intercom/result-intercom.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
+import { isStaleExtensionContextError } from "@bastani/atomic";
 import {
 	type Details,
 	type IntercomEventBus,
@@ -86,9 +87,6 @@ function compactNestedRun(run: NestedRunSummary | PublicNestedRunSummary, depth
 		state: run.state,
 		...(run.agent ? { agent: run.agent } : {}),
 		...(run.agents?.length ? { agents: run.agents.slice(0, 12) } : {}),
-		...(run.currentStep !== undefined ? { currentStep: run.currentStep } : {}),
-		...(run.chainStepCount !== undefined ? { chainStepCount: run.chainStepCount } : {}),
-		...(run.parallelGroups?.length ? { parallelGroups: run.parallelGroups.slice(0, 8) } : {}),
 		...(run.activityState ? { activityState: run.activityState } : {}),
 		...(run.lastActivityAt !== undefined ? { lastActivityAt: run.lastActivityAt } : {}),
 		...(run.currentTool ? { currentTool: run.currentTool } : {}),
@@ -197,7 +195,6 @@ export interface GroupedResultIntercomMessageInput {
 	children: SubagentResultIntercomChild[];
 	asyncId?: string;
 	asyncDir?: string;
-	chainSteps?: number;
 }
 
 function asyncResumeGuidance(input: {
@@ -227,7 +224,6 @@ function formatSubagentResultIntercomMessage(input: {
 	children: SubagentResultIntercomChild[];
 	asyncId?: string;
 	asyncDir?: string;
-	chainSteps?: number;
 }): string {
 	const counts = countStatuses(input.children);
 	const lines: string[] = [
@@ -238,9 +234,6 @@ function formatSubagentResultIntercomMessage(input: {
 		`Status: ${input.status}`,
 		`Children: ${formatStatusCounts(counts)}`,
 	];
-	if (input.mode === "chain" && typeof input.chainSteps === "number") {
-		lines.push(`Chain steps: ${input.chainSteps}`);
-	}
 	if (input.asyncId) lines.push(`Async id: ${input.asyncId}`);
 	if (input.asyncDir) lines.push(`Async dir: ${input.asyncDir}`);
 	const resumeGuidance = asyncResumeGuidance(input);
@@ -293,7 +286,6 @@ export function buildSubagentResultIntercomPayload(
 		children,
 		...(input.asyncId ? { asyncId: input.asyncId } : {}),
 		...(input.asyncDir ? { asyncDir: input.asyncDir } : {}),
-		...(typeof input.chainSteps === "number" ? { chainSteps: input.chainSteps } : {}),
 		...(firstChild?.agent ? { agent: firstChild.agent } : {}),
 		...(firstChild?.index !== undefined ? { index: firstChild.index } : {}),
 		...(firstChild?.artifactPath ? { artifactPath: firstChild.artifactPath } : {}),
@@ -335,15 +327,26 @@ export async function deliverSubagentIntercomMessageEvent(
 			if (settled) return;
 			settled = true;
 			if (timer) clearTimeout(timer);
-			unsubscribe?.();
+			try {
+				unsubscribe?.();
+			} catch (error) {
+				if (!isStaleExtensionContextError(error)) throw error;
+				// Stale event-bus cleanup must not change the delivery result.
+			}
 			resolve(delivered);
 		};
-		unsubscribe = events.on(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, (data) => {
-			if (!data || typeof data !== "object") return;
-			const delivery = data as { requestId?: unknown; delivered?: unknown };
-			if (delivery.requestId !== requestId) return;
-			finish(delivery.delivered === true);
-		});
+		try {
+			unsubscribe = events.on(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, (data) => {
+				if (!data || typeof data !== "object") return;
+				const delivery = data as { requestId?: unknown; delivered?: unknown };
+				if (delivery.requestId !== requestId) return;
+				finish(delivery.delivered === true);
+			});
+		} catch (error) {
+			if (!isStaleExtensionContextError(error)) throw error;
+			finish(false);
+			return;
+		}
 		if (timeoutMs !== false) timer = setTimeout(() => finish(false), timeoutMs);
 		try {
 			events.emit(SUBAGENT_RESULT_INTERCOM_EVENT, { ...extra, to, message, requestId });
@@ -375,12 +378,7 @@ export function formatSubagentResultReceipt(input: {
 	payload: SubagentResultIntercomPayload;
 }): string {
 	const counts = countStatuses(input.payload.children);
-	const modeLabel =
-		input.mode === "single"
-			? "single subagent result"
-			: input.mode === "parallel"
-				? "parallel subagent results"
-				: "chain subagent results";
+	const modeLabel = input.mode === "single" ? "single subagent result" : "parallel subagent results";
 	const lines = [
 		`Delivered ${modeLabel} via intercom.`,
 		`Run: ${input.runId}`,

package/dist/builtin/subagents/src/intercom/supervisor-authorization.ts

@@ -1,3 +1,4 @@
+import { isStaleExtensionContextError } from "@bastani/atomic";
 import type { IntercomEventBus } from "../shared/types.ts";
 
 export const SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT = "subagent:supervisor-authorization";
@@ -18,6 +19,12 @@ export async function requestSupervisorAuthorization(
 	const request: { childName: string; completion?: Promise<SupervisorAuthorization> } = {
 		childName: normalizedChildName,
 	};
-	events.emit(SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT, request);
-	return request.completion ? await request.completion : undefined;
+	try {
+		events.emit(SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT, request);
+		return request.completion ? await request.completion : undefined;
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		// Authorization is advisory when a child outlives its parent runtime.
+		return undefined;
+	}
 }