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

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

@@ -3,17 +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, 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;
 }
 
 interface DoctorDeps {
-	isAsyncAvailable: () => boolean;
 	discoverAgentsAll: typeof discoverAgentsAll;
 	discoverAvailableSkills: typeof discoverAvailableSkills;
 	diagnoseIntercomBridge: typeof diagnoseIntercomBridge;
@@ -34,14 +30,9 @@ interface DoctorReportInput {
 	deps?: Partial<DoctorDeps>;
 }
 
-const DEFAULT_PATHS: DoctorPaths = {
-	tempRootDir: TEMP_ROOT_DIR,
-	asyncDir: ASYNC_DIR,
-	resultsDir: RESULTS_DIR,
-};
+const DEFAULT_PATHS: DoctorPaths = { tempRootDir: TEMP_ROOT_DIR };
 
 const DEFAULT_DEPS: DoctorDeps = {
-	isAsyncAvailable,
 	discoverAgentsAll,
 	discoverAvailableSkills,
 	diagnoseIntercomBridge,
@@ -162,13 +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),
 		"",
 		"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";
@@ -62,12 +60,9 @@ export {
 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";
@@ -218,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,
@@ -320,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,
@@ -340,7 +315,6 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 						context: request.context,
 						cwd: request.cwd,
 						model: request.model,
-						async: false,
 					},
 					signal,
 					onUpdate,
@@ -381,15 +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 (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,
 				);
@@ -403,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({
@@ -419,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;
@@ -436,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(),
@@ -463,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);
 		};
@@ -479,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

@@ -3,9 +3,9 @@ export const DEFAULT_PROMPT_GUIDANCE: string[] = [
   - 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 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, 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

@@ -100,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.",
 		}),
 	),
 });
@@ -130,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." }),
 		),
@@ -178,7 +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'.",
 			}),
 		),
-		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/tool-description.ts

@@ -5,7 +5,6 @@ EXECUTION (use exactly ONE mode):
 • 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
 • 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 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
@@ -14,8 +13,8 @@ MANAGEMENT (use action field, omit agent/task/tasks):
 • { action: "update", agent: "code-analysis.custom-agent", config: { package: "analysis", ... } } - merge
 • { action: "delete", agent: "code-analysis.custom-agent" }
 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`;

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

@@ -83,7 +83,7 @@ export function resolveIntercomSessionTarget(sessionName: string | undefined, se
 	const trimmedName = sessionName?.trim();
 	if (trimmedName) return trimmedName;
 	const normalizedSessionId = sessionId.startsWith("session-") ? sessionId.slice("session-".length) : sessionId;
-	return `${DEFAULT_INTERCOM_TARGET_PREFIX}-${normalizedSessionId.slice(0, 8)}`;
+	return `${DEFAULT_INTERCOM_TARGET_PREFIX}-${normalizedSessionId}`;
 }
 
 function sanitizeIntercomTargetPart(value: string): string {

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

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
 import { isStaleExtensionContextError } from "@bastani/atomic";
 import {
 	type Details,
@@ -76,7 +75,6 @@ function compactNestedRun(run: NestedRunSummary | PublicNestedRunSummary, depth
 			...(part.stepIndex !== undefined ? { stepIndex: part.stepIndex } : {}),
 			...(part.agent ? { agent: part.agent } : {}),
 		})),
-		...(run.asyncDir ? { asyncDir: run.asyncDir } : {}),
 		...(run.sessionId ? { sessionId: run.sessionId } : {}),
 		...(run.sessionFile ? { sessionFile: run.sessionFile } : {}),
 		...(run.intercomTarget ? { intercomTarget: run.intercomTarget } : {}),
@@ -191,39 +189,14 @@ export interface GroupedResultIntercomMessageInput {
 	to: string;
 	runId: string;
 	mode: SubagentRunMode;
-	source: "foreground" | "async";
 	children: SubagentResultIntercomChild[];
-	asyncId?: string;
-	asyncDir?: string;
-}
-
-function asyncResumeGuidance(input: {
-	source: "foreground" | "async";
-	children: SubagentResultIntercomChild[];
-	asyncId?: string;
-}): string | undefined {
-	if (input.source !== "async" || !input.asyncId) return undefined;
-	const resumable = input.children.filter(
-		(child) => typeof child.sessionPath === "string" && fs.existsSync(child.sessionPath),
-	);
-	if (input.children.length === 1 && resumable.length === 1) {
-		return `Revive: subagent({ action: "resume", id: "${input.asyncId}", message: "..." })`;
-	}
-	if (resumable.length > 0) {
-		const firstIndex = resumable[0]?.index ?? input.children.indexOf(resumable[0]!);
-		return `Revive child: subagent({ action: "resume", id: "${input.asyncId}", index: ${firstIndex}, message: "..." })`;
-	}
-	return "Resume: unavailable; no child session file was persisted.";
 }
 
 function formatSubagentResultIntercomMessage(input: {
 	runId: string;
 	mode: SubagentRunMode;
 	status: SubagentResultStatus;
-	source: "foreground" | "async";
 	children: SubagentResultIntercomChild[];
-	asyncId?: string;
-	asyncDir?: string;
 }): string {
 	const counts = countStatuses(input.children);
 	const lines: string[] = [
@@ -234,32 +207,21 @@ function formatSubagentResultIntercomMessage(input: {
 		`Status: ${input.status}`,
 		`Children: ${formatStatusCounts(counts)}`,
 	];
-	if (input.asyncId) lines.push(`Async id: ${input.asyncId}`);
-	if (input.asyncDir) lines.push(`Async dir: ${input.asyncDir}`);
-	const resumeGuidance = asyncResumeGuidance(input);
-	if (resumeGuidance) lines.push(resumeGuidance);
 	if (input.children.some((child) => child.intercomTarget)) {
-		lines.push("");
 		lines.push(
-			input.source === "async"
-				? "Previous intercom targets below identify child sessions used while they were running. Inspect artifacts or session logs if resume is unavailable."
-				: "Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.",
+			"",
+			"Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.",
 		);
 	}
 
 	for (let index = 0; index < input.children.length; index++) {
 		const child = input.children[index]!;
-		lines.push("");
-		lines.push(`${index + 1}. ${child.agent} — ${child.status}`);
-		if (child.intercomTarget)
-			lines.push(
-				`${input.source === "async" ? "Previous intercom target" : "Run intercom target"}: ${child.intercomTarget}`,
-			);
+		lines.push("", `${index + 1}. ${child.agent} — ${child.status}`);
+		if (child.intercomTarget) lines.push(`Run intercom target: ${child.intercomTarget}`);
 		if (child.artifactPath) lines.push(`Output artifact: ${child.artifactPath}`);
 		if (child.sessionPath) lines.push(`Session: ${child.sessionPath}`);
 		lines.push(...formatNestedResultLines(child.children));
-		lines.push("Summary:");
-		lines.push(child.summary);
+		lines.push("Summary:", child.summary);
 	}
 
 	return lines.join("\n");
@@ -282,10 +244,7 @@ export function buildSubagentResultIntercomPayload(
 		mode: input.mode,
 		status,
 		summary,
-		source: input.source,
 		children,
-		...(input.asyncId ? { asyncId: input.asyncId } : {}),
-		...(input.asyncDir ? { asyncDir: input.asyncDir } : {}),
 		...(firstChild?.agent ? { agent: firstChild.agent } : {}),
 		...(firstChild?.index !== undefined ? { index: firstChild.index } : {}),
 		...(firstChild?.artifactPath ? { artifactPath: firstChild.artifactPath } : {}),

package/dist/builtin/subagents/src/runs/{background → foreground}/completion-notification.ts

@@ -1,5 +1,5 @@
 import type { IntercomEventBus } from "../../shared/types.ts";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.ts";
+import { SUBAGENT_COMPLETE_EVENT } from "../../shared/types.ts";
 
 export interface CompletionNotificationEnvelope extends Record<string, unknown> {
 	notificationId: string;
@@ -26,7 +26,7 @@ export function deliverLocalCompletionNotification(
 			reject(error);
 		};
 		try {
-			events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+			events.emit(SUBAGENT_COMPLETE_EVENT, {
 				...payload,
 				notificationId,
 				defer: () => {