@bastani/atomic 0.9.12 → 0.9.13-alpha.2

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

@@ -1,15 +1,11 @@
 import * as path from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
-import { createResultWatcher } from "../runs/background/result-watcher.ts";
-import { cleanupOldNestedRuntimeDirs } from "../runs/shared/nested-events.ts";
+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 {
 	scheduleStartupCleanup(): void;
-	startResultWatcherDeferred(): void;
-	primeExistingResultsDeferred(): void;
 	cleanupSessionArtifactsDeferred(ctx: ExtensionContext): void;
 	stop(): void;
 }
@@ -47,54 +43,48 @@ function swallowCleanup(task: () => void): void {
 	} catch {}
 }
 
+interface StartupMaintenanceOptions {
+	artifactCleanupDays: number;
+	resultsDir?: string;
+	resultTtlMs?: number;
+	scheduleMacrotask?: (task: () => void) => () => void;
+	scheduleDelayed?: (task: () => void, delayMs: number) => () => void;
+}
+
+export function createSubagentStartupMaintenance(
+	state: SubagentState,
+	options: StartupMaintenanceOptions,
+): SubagentStartupMaintenance;
 export function createSubagentStartupMaintenance(
-	pi: ExtensionAPI,
+	_pi: unknown,
 	state: SubagentState,
-	options: {
-		resultsDir: string;
-		artifactCleanupDays: number;
-		resultTtlMs: number;
-		scheduleMacrotask?: (task: () => void) => () => void;
-		scheduleDelayed?: (task: () => void, delayMs: number) => () => void;
-	},
+	options: StartupMaintenanceOptions,
+): SubagentStartupMaintenance;
+export function createSubagentStartupMaintenance(
+	_first: SubagentState | unknown,
+	second: StartupMaintenanceOptions | SubagentState,
+	third?: StartupMaintenanceOptions,
 ): SubagentStartupMaintenance {
-	const { startResultWatcher, primeExistingResults, stopResultWatcher } = createResultWatcher(
-		pi,
-		state,
-		options.resultsDir,
-		options.resultTtlMs,
-	);
+	const options = third ?? (second as StartupMaintenanceOptions);
 	const cancelTasks = new Set<() => void>();
-	// The sessions root derived from a host-provided (non-default, e.g. isolated
-	// programmatic agentDir) session directory. When set, the global artifact scan
-	// stays inside it instead of touching the real global/legacy sessions roots.
-	// A custom session dir that does not follow the <agentDir>/sessions/<safe-cwd>
-	// layout (the default layout the SDK derives for a programmatic agentDir, with
-	// <safe-cwd> encoding the current working directory) yields no roots at all, so
-	// cleanup never broadens into an arbitrary directory's siblings.
 	let contextSessionsRoots: readonly string[] | undefined;
 	const noteSessionContext = (ctx: ExtensionContext): void => {
 		try {
 			if (ctx.sessionManager.usesDefaultSessionDir()) {
-				// Only a valid default-session context intentionally restores the
-				// env/global cleanup roots.
 				contextSessionsRoots = undefined;
 				return;
 			}
 			const sessionDir = ctx.sessionManager.getSessionDir();
-			// A partial or throwing context keeps the last validated root: destructive
-			// cleanup must never broaden from an isolated root to the global roots on
-			// the strength of an unusable context.
 			if (!sessionDir) return;
 			const parent = path.dirname(sessionDir);
 			const safeCwd = `--${path
 				.resolve(ctx.cwd)
 				.replace(/^[/\\]/, "")
 				.replace(/[/\\:]/g, "-")}--`;
-			const followsAgentDirLayout = path.basename(parent) === "sessions" && path.basename(sessionDir) === safeCwd;
-			contextSessionsRoots = followsAgentDirLayout ? [parent] : [];
+			contextSessionsRoots =
+				path.basename(parent) === "sessions" && path.basename(sessionDir) === safeCwd ? [parent] : [];
 		} catch {
-			// A stale or partial context leaves cleanup on the env/global fallback.
+			// A stale or partial context leaves cleanup on the last validated root.
 		}
 	};
 	const schedule = (task: () => void): void => {
@@ -115,23 +105,13 @@ export function createSubagentStartupMaintenance(
 	return {
 		scheduleStartupCleanup() {
 			schedule(() => {
-				swallowCleanup(cleanupOldChainDirs);
 				swallowCleanup(() => cleanupOldNestedRuntimeDirs(options.artifactCleanupDays));
-				// The global session-artifact scan can touch thousands of historical session
-				// directories, so it waits until well after startup instead of running on the
-				// activation macrotask.
 				scheduleDelayed(
 					() => swallowCleanup(() => cleanupAllArtifactDirs(options.artifactCleanupDays, contextSessionsRoots)),
 					STARTUP_ARTIFACT_SCAN_DELAY_MS,
 				);
 			});
 		},
-		startResultWatcherDeferred() {
-			schedule(startResultWatcher);
-		},
-		primeExistingResultsDeferred() {
-			schedule(primeExistingResults);
-		},
 		cleanupSessionArtifactsDeferred(ctx) {
 			noteSessionContext(ctx);
 			let sessionFile: string | null | undefined;
@@ -148,7 +128,6 @@ export function createSubagentStartupMaintenance(
 		stop() {
 			for (const cancel of cancelTasks) cancel();
 			cancelTasks.clear();
-			stopResultWatcher();
 		},
 	};
 }

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,
@@ -9,6 +10,7 @@ import {
 	type SingleResult,
 	SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
 	SUBAGENT_RESULT_INTERCOM_EVENT,
+	type SubagentAttemptStatus,
 	type SubagentResultIntercomChild,
 	type SubagentResultIntercomPayload,
 	type SubagentResultStatus,
@@ -16,18 +18,17 @@ import {
 } from "../shared/types.ts";
 
 export function resolveSubagentResultStatus(input: {
-	exitCode?: number;
+	status?: SubagentAttemptStatus;
 	success?: boolean;
 	state?: string;
 	interrupted?: boolean;
 	detached?: boolean;
 }): SubagentResultStatus {
-	if (input.detached) return "detached";
-	if (input.interrupted || input.state === "paused") return "paused";
-	if (typeof input.success === "boolean") return input.success ? "completed" : "failed";
-	if (input.state === "complete") return "completed";
-	if (input.state === "failed") return "failed";
-	if (typeof input.exitCode === "number") return input.exitCode === 0 ? "completed" : "failed";
+	if (input.detached || input.status === "continued") return "detached";
+	if (input.interrupted || input.status === "interrupted" || input.state === "paused") return "paused";
+	if (input.status === "ok" || input.success === true || input.state === "complete") return "completed";
+	if (input.status === "error" || input.status === "skipped" || input.success === false || input.state === "failed")
+		return "failed";
 	return "failed";
 }
 
@@ -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;
+	}
 }