@bastani/atomic 0.9.15 → 0.9.16-alpha.2

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

@@ -38,7 +38,6 @@ import {
 } from "../slash/slash-live-state.js";
 import {
 	advanceResultPulseFrame,
-	renderLiveSubagentResult,
 	renderSubagentResult,
 	type SubagentResultRenderState,
 	stopResultAnimations,
@@ -48,6 +47,7 @@ import { parseSubagentNotifyContent } from "./notification-content.js";
 import { DEFAULT_PROMPT_GUIDANCE } from "./prompt-guidance.js";
 import { SubagentParams } from "./schemas.js";
 import { SUBAGENT_TOOL_DESCRIPTION } from "./tool-description.js";
+import { renderSubagentToolCall, renderSubagentToolResult } from "./tool-rendering.js";
 
 export {
 	PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT,
@@ -157,7 +157,7 @@ export function renderSubagentNotification(
 	const icon =
 		details.status === "completed"
 			? theme.fg("success", "✓")
-			: details.status === "paused"
+			: details.status === "interrupted"
 				? theme.fg("warning", "■")
 				: theme.fg("error", "✗");
 	const parts: string[] = [];
@@ -218,7 +218,6 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			baseCwd: "",
 			currentSessionId: null,
 			subagentInProgress: false,
-			foregroundRuns: new Map(),
 			foregroundControls: new Map(),
 			lastForegroundControlId: null,
 			pendingForegroundControlNotices: new Map(),
@@ -326,14 +325,6 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			promptTemplateBridge.cancelAll();
 			promptTemplateBridge.dispose();
 		});
-		function effectiveParallelTaskCount(tasks: Array<{ count?: unknown }> | undefined): number {
-			if (!tasks || tasks.length === 0) return 0;
-			return tasks.reduce((total, task) => {
-				const count =
-					typeof task.count === "number" && Number.isInteger(task.count) && task.count >= 1 ? task.count : 1;
-				return total + count;
-			}, 0);
-		}
 		const tool: ToolDefinition<typeof SubagentParams, Details, SubagentToolRenderState> = {
 			name: "subagent",
 			label: "Subagent",
@@ -344,27 +335,11 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 				const executionSignal = signal ?? ctx.signal ?? new AbortController().signal;
 				return executeSubagentCollapsed(id, params as SubagentParamsLike, executionSignal, onUpdate, ctx);
 			},
-			renderCall(args, theme) {
-				if (args.action) {
-					const target = args.agent || "";
-					return new Text(
-						`${theme.fg("toolTitle", theme.bold("subagent "))}${args.action}${target ? ` ${theme.fg("accent", target)}` : ""}`,
-						0,
-						0,
-					);
-				}
-				const isParallel = (args.tasks?.length ?? 0) > 0;
-				const parallelCount = effectiveParallelTaskCount(args.tasks as Array<{ count?: unknown }> | undefined);
-				return new Text(
-					isParallel
-						? `${theme.fg("toolTitle", theme.bold("subagent "))}parallel (${parallelCount})`
-						: `${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("accent", args.agent || "?")}`,
-					0,
-					0,
-				);
+			renderCall(args, theme, context) {
+				return renderSubagentToolCall(args as SubagentParamsLike, theme, context);
 			},
 			renderResult(result, options, theme, context) {
-				return renderLiveSubagentResult(result, options, theme, context);
+				return renderSubagentToolResult(result, options, theme, context);
 			},
 		};
 		pi.registerTool(tool);

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

@@ -1,6 +1,6 @@
 import type { SubagentNotifyDetails } from "../runs/foreground/notify.js";
 
-const HEADER_STATUSES = ["completed", "failed", "paused"] as const;
+const HEADER_STATUSES = ["completed", "failed", "interrupted"] as const;
 
 function isHeaderLineTerminator(character: string): boolean {
 	return character === "\r" || character === "\u2028" || character === "\u2029";

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

@@ -124,23 +124,11 @@ export const SubagentParams = Type.Object(
 				description: "Management/control action. Omit for execution mode.",
 			}),
 		),
-		id: Type.Optional(
-			Type.String({
-				description: "Run id or prefix for action='status', action='interrupt', or action='resume'.",
-			}),
-		),
+		id: Type.Optional(Type.String({ description: "Run id or prefix for action='status' or action='interrupt'." })),
 		runId: Type.Optional(
 			Type.String({
 				description:
-					"Target run ID for action='interrupt' or action='resume'. Defaults to the most recently active controllable run for interrupt. Prefer id for new calls.",
-			}),
-		),
-		index: Type.Optional(
-			Type.Integer({ minimum: 0, description: "Zero-based child index for actions that target a specific child." }),
-		),
-		message: Type.Optional(
-			Type.String({
-				description: "Follow-up message for action='resume'. Use index to choose a child from multi-child runs.",
+					"Target run ID for action='interrupt'. Defaults to the most recently active controllable run. Prefer id for new calls.",
 			}),
 		),
 		config: Type.Optional(

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

@@ -14,7 +14,4 @@ MANAGEMENT (use action field, omit agent/task/tasks):
 • { action: "delete", agent: "code-analysis.custom-agent" }
 CONTROL:
 • { 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 child or revive a retained foreground child
-DIAGNOSTICS:
-• { action: "doctor" } - read-only report for runtime paths, discovery, sessions, and intercom`;
+• { action: "interrupt", id?: "..." } - soft-interrupt the current child turn; the child is terminal for continuation, so follow-up work starts a fresh launch`;

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

@@ -0,0 +1,53 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { type Component, Container, Text } from "@earendil-works/pi-tui";
+import { getBurstDisplay } from "../runs/foreground/subagent-executor-burst-display.js";
+import type { SubagentParamsLike } from "../runs/foreground/subagent-executor-types.js";
+import type { Details } from "../shared/types.js";
+import { renderLiveSubagentResult } from "../tui/render.js";
+
+type Theme = Parameters<typeof renderLiveSubagentResult>[2];
+type RenderContext = Parameters<typeof renderLiveSubagentResult>[3] & { toolCallId: string };
+
+function effectiveParallelTaskCount(tasks: Array<{ count?: unknown }> | undefined): number {
+	if (!tasks || tasks.length === 0) return 0;
+	return tasks.reduce((total, task) => {
+		const count = typeof task.count === "number" && Number.isInteger(task.count) && task.count >= 1 ? task.count : 1;
+		return total + count;
+	}, 0);
+}
+
+export function renderSubagentToolCall(args: SubagentParamsLike, theme: Theme, context: RenderContext): Component {
+	const burst = getBurstDisplay(context.toolCallId);
+	if (burst && !burst.owner) return new Container();
+	if (args.action) {
+		const target = args.agent || "";
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("subagent "))}${args.action}${target ? ` ${theme.fg("accent", target)}` : ""}`,
+			0,
+			0,
+		);
+	}
+	if (burst) {
+		return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}parallel (${burst.taskCount})`, 0, 0);
+	}
+	const isParallel = (args.tasks?.length ?? 0) > 0;
+	const parallelCount = effectiveParallelTaskCount(args.tasks as Array<{ count?: unknown }> | undefined);
+	return new Text(
+		isParallel
+			? `${theme.fg("toolTitle", theme.bold("subagent "))}parallel (${parallelCount})`
+			: `${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("accent", args.agent || "?")}`,
+		0,
+		0,
+	);
+}
+
+export function renderSubagentToolResult(
+	result: AgentToolResult<Details>,
+	options: { expanded: boolean; isPartial: boolean },
+	theme: Theme,
+	context: RenderContext,
+): Component {
+	const burst = getBurstDisplay(context.toolCallId);
+	if (burst && !burst.owner) return new Container();
+	return renderLiveSubagentResult(burst?.result ?? result, options, theme, context);
+}

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

@@ -37,7 +37,7 @@ const DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `The inherited thread is reference-only
 
 Use contact_supervisor first. It resolves the supervisor session "{orchestratorTarget}" and run metadata automatically.
 - Need a decision, blocked, approval, or product/API/scope ambiguity: contact_supervisor({ reason: "need_decision", message: "<question>" })
-- After contact_supervisor with reason "need_decision", stay alive and continue only after the reply arrives. Do not finish your final response with a choose-one question.
+- A claimed decision or interview ends this child. Do not wait for or expect a reply in this run; the supervisor receives a dynamic [TASK_CONTEXT] handoff and may launch a fresh subagent with a new run identity and the answer.
 - Do not ask for clarification when the only conflict is review-only/no-edit versus progress-writing or artifact-writing instructions. Review-only/no-edit wins; leave files unchanged and mention the conflict in your final result only if it matters.
 - Meaningful progress or unexpected discoveries that change the plan: contact_supervisor({ reason: "progress_update", message: "UPDATE: <summary>" })
 - Generic intercom is lower-level plumbing/fallback only: intercom({ action: "ask", to: "{orchestratorTarget}", message: "<question>" })
@@ -52,19 +52,6 @@ export interface IntercomBridgeState {
 	instruction: string;
 }
 
-export interface IntercomBridgeDiagnostic {
-	active: boolean;
-	mode: IntercomBridgeMode;
-	wantsIntercom: boolean;
-	piIntercomAvailable: boolean;
-	extensionDir: string;
-	configPath?: string;
-	orchestratorTarget?: string;
-	reason?: string;
-	intercomConfigEnabled?: boolean;
-	intercomConfigError?: string;
-}
-
 interface ResolveIntercomBridgeInput {
 	config: ExtensionConfig["intercomBridge"];
 	context: "fresh" | "fork" | undefined;
@@ -317,46 +304,6 @@ function buildIntercomBridgeInstruction(orchestratorTarget: string, template: st
 ${instruction}`;
 }
 
-export function diagnoseIntercomBridge(input: ResolveIntercomBridgeInput): IntercomBridgeDiagnostic {
-	const config = resolveIntercomBridgeConfig(input.config);
-	const mode = config.mode;
-	const agentDir = path.resolve(input.agentDir ?? defaultAgentDir());
-	const extensionDir = resolveIntercomExtensionDir(input, agentDir);
-	const orchestratorTarget = input.orchestratorTarget?.trim();
-	const configPath = path.resolve(input.configPath ?? defaultIntercomConfigPath(agentDir));
-	const wantsIntercom = mode !== "off" && !(mode === "fork-only" && input.context !== "fork");
-	const piIntercomAvailable = fs.existsSync(extensionDir);
-	let configStatus: ReturnType<typeof intercomConfigStatus> | undefined;
-	let reason: string | undefined;
-	if (mode === "off") reason = "bridge mode is off";
-	else if (mode === "fork-only" && input.context !== "fork")
-		reason = "bridge mode is fork-only and context is not fork";
-	else if (!orchestratorTarget) reason = "orchestrator target is not available";
-	else if (!piIntercomAvailable) reason = "pi-intercom extension was not found";
-	else {
-		configStatus = intercomConfigStatus(configPath);
-		if (!configStatus.enabled) reason = "intercom config is disabled";
-	}
-	let intercomConfigError: string | undefined;
-	if (configStatus?.error) {
-		const error = configStatus.error;
-		intercomConfigError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-	}
-
-	return {
-		active: reason === undefined,
-		mode,
-		wantsIntercom,
-		piIntercomAvailable,
-		extensionDir,
-		configPath,
-		...(orchestratorTarget ? { orchestratorTarget } : {}),
-		...(reason ? { reason } : {}),
-		...(configStatus ? { intercomConfigEnabled: configStatus.enabled } : {}),
-		...(intercomConfigError ? { intercomConfigError } : {}),
-	};
-}
-
 export function resolveIntercomBridge(input: ResolveIntercomBridgeInput): IntercomBridgeState {
 	const config = resolveIntercomBridgeConfig(input.config);
 	const mode = config.mode;

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

@@ -21,7 +21,7 @@ export function resolveSubagentResultStatus(input: {
 	detached?: boolean;
 }): SubagentResultStatus {
 	if (input.detached || input.status === "continued") return "detached";
-	if (input.interrupted || input.status === "interrupted" || input.state === "paused") return "paused";
+	if (input.interrupted || input.status === "interrupted" || input.state === "interrupted") return "interrupted";
 	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";
@@ -32,7 +32,7 @@ function countStatuses(children: SubagentResultIntercomChild[]): Record<Subagent
 	const counts: Record<SubagentResultStatus, number> = {
 		completed: 0,
 		failed: 0,
-		paused: 0,
+		interrupted: 0,
 		detached: 0,
 	};
 	for (const child of children) {
@@ -45,7 +45,7 @@ function formatStatusCounts(counts: Record<SubagentResultStatus, number>): strin
 	const parts = [
 		counts.completed ? `${counts.completed} completed` : undefined,
 		counts.failed ? `${counts.failed} failed` : undefined,
-		counts.paused ? `${counts.paused} paused` : undefined,
+		counts.interrupted ? `${counts.interrupted} interrupted` : undefined,
 		counts.detached ? `${counts.detached} detached` : undefined,
 	].filter((part): part is string => Boolean(part));
 	return parts.length ? parts.join(", ") : "0 results";
@@ -54,7 +54,7 @@ function formatStatusCounts(counts: Record<SubagentResultStatus, number>): strin
 function resolveGroupedStatus(children: SubagentResultIntercomChild[]): SubagentResultStatus {
 	const counts = countStatuses(children);
 	if (counts.failed > 0) return "failed";
-	if (counts.paused > 0) return "paused";
+	if (counts.interrupted > 0) return "interrupted";
 	if (counts.completed > 0) return "completed";
 	if (counts.detached > 0) return "detached";
 	return "failed";

package/dist/builtin/subagents/src/runs/foreground/execution-parent-ask-handoff.ts

@@ -0,0 +1,78 @@
+import {
+	PARENT_ASK_HANDOFF_REQUEST_EVENT,
+	type ParentAskHandoffRequest,
+	type RunSyncOptions,
+} from "../../shared/types.js";
+
+interface ExecutionParentAskState {
+	readonly agent: string;
+	readonly isUnavailable: () => boolean;
+}
+
+const PROCESS_PARENT_ASK_CLAIMS = Symbol.for("atomic/subagents/parent-ask-claims@1");
+
+type ProcessParentAskClaimHandler = (payload: unknown) => void;
+
+interface ProcessParentAskClaimRegistry {
+	handlers: Set<ProcessParentAskClaimHandler>;
+}
+
+function processClaimSlots(): typeof globalThis & Record<symbol, ProcessParentAskClaimRegistry | undefined> {
+	return globalThis as typeof globalThis & Record<symbol, ProcessParentAskClaimRegistry | undefined>;
+}
+
+function registerProcessClaimHandler(handler: ProcessParentAskClaimHandler): () => void {
+	const slots = processClaimSlots();
+	const registry = slots[PROCESS_PARENT_ASK_CLAIMS] ?? { handlers: new Set<ProcessParentAskClaimHandler>() };
+	slots[PROCESS_PARENT_ASK_CLAIMS] = registry;
+	registry.handlers.add(handler);
+	return () => {
+		registry.handlers.delete(handler);
+		if (registry.handlers.size === 0 && slots[PROCESS_PARENT_ASK_CLAIMS] === registry) {
+			delete slots[PROCESS_PARENT_ASK_CLAIMS];
+		}
+	};
+}
+
+function isParentAskHandoffRequest(payload: unknown): payload is ParentAskHandoffRequest {
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
+	const request = payload as Partial<ParentAskHandoffRequest>;
+	return (
+		typeof request.runId === "string" &&
+		typeof request.index === "number" &&
+		typeof request.agent === "string" &&
+		typeof request.childIntercomTarget === "string" &&
+		typeof request.orchestratorTarget === "string" &&
+		(request.kind === "decision" || request.kind === "interview" || request.kind === "intercom") &&
+		typeof request.question === "string" &&
+		typeof request.claimed === "boolean"
+	);
+}
+
+/** Claim a blocking ask only for the exact live child attempt that issued it. */
+export function registerExecutionParentAskHandoff(options: RunSyncOptions, state: ExecutionParentAskState): () => void {
+	if (!options.onParentAskHandoff) return () => {};
+	const handleRequest = (payload: unknown): void => {
+		if (state.isUnavailable() || !isParentAskHandoffRequest(payload)) return;
+		if (
+			payload.claimed ||
+			payload.runId !== options.runId ||
+			payload.index !== (options.index ?? 0) ||
+			payload.agent !== state.agent ||
+			payload.childIntercomTarget !== options.intercomSessionName ||
+			payload.orchestratorTarget !== options.orchestratorIntercomTarget
+		)
+			return;
+		payload.claimed = true;
+		options.onParentAskHandoff?.(payload);
+	};
+	const eventCleanup = options.intercomEvents?.on(PARENT_ASK_HANDOFF_REQUEST_EVENT, handleRequest) ?? (() => {});
+	const processCleanup = registerProcessClaimHandler(handleRequest);
+	let cleaned = false;
+	return () => {
+		if (cleaned) return;
+		cleaned = true;
+		eventCleanup();
+		processCleanup();
+	};
+}

package/dist/builtin/subagents/src/runs/foreground/inprocess-run-sync.ts

@@ -23,6 +23,7 @@ import type { AttemptOutcome, ChildSpec, ParentContext } from "../inprocess/runn
 import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.js";
 import { buildModelCandidates } from "../shared/model-fallback.js";
 import { registerExecutionIntercomDetach } from "./execution-intercom-detach.js";
+import { registerExecutionParentAskHandoff } from "./execution-parent-ask-handoff.js";
 
 function emptyUsage(): Usage {
 	return {
@@ -349,11 +350,6 @@ export async function runSingleInProcess(
 			lastActivityAt: Date.now(),
 		});
 	}
-	control.registerAttempt(options.runId, running, {
-		model: resolvedCandidate?.model,
-		modelId: candidate,
-		thinkingLevel: spec.thinkingLevel,
-	});
 	let detached = false;
 	let resolveContinuation!: () => void;
 	const continuation = new Promise<void>((resolve) => {
@@ -369,10 +365,15 @@ export async function runSingleInProcess(
 			resolveContinuation();
 		},
 	});
+	const parentAskCleanup = registerExecutionParentAskHandoff(options, {
+		agent: agent.name,
+		isUnavailable: () => running.status !== "running" || detached,
+	});
 	const terminal = running.promise.then((value) => ({ kind: "terminal" as const, value }));
 	const winner = await Promise.race([terminal, continuation.then(() => ({ kind: "continued" as const }))]);
 	if (winner.kind === "continued") {
 		detachCleanup();
+		parentAskCleanup();
 		void running.promise.then(async (continuedOutcome) => {
 			const recovered = resultFromOutcome(agent, task, continuedOutcome, startedAt, artifactPaths, {
 				cwd,
@@ -441,6 +442,7 @@ export async function runSingleInProcess(
 		return continuedResult;
 	}
 	detachCleanup();
+	parentAskCleanup();
 	const outcome = winner.value;
 	const result = resultFromOutcome(agent, task, outcome, startedAt, artifactPaths, {
 		cwd,

package/dist/builtin/subagents/src/runs/foreground/notify.ts

@@ -21,7 +21,7 @@ interface SubagentStepResult {
 
 export interface SubagentNotifyDetails {
 	agent: string;
-	status: "completed" | "failed" | "paused";
+	status: "completed" | "failed" | "interrupted";
 	taskInfo?: string;
 	resultPreview: string;
 	durationMs?: number;
@@ -211,14 +211,13 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 		inFlight.set(key, ownership.promise);
 		const agent = result.agent ?? "unknown";
 		const summary = typeof result.summary === "string" ? result.summary : "";
-		const paused =
-			result.status === "interrupted" || result.state === "paused" || summary.startsWith("Paused after interrupt.");
-		const status = paused
-			? "paused"
+		const interrupted = result.status === "interrupted" || result.state === "interrupted";
+		const status = interrupted
+			? "interrupted"
 			: result.status === "ok"
 				? "completed"
 				: result.status === "continued"
-					? "paused"
+					? "interrupted"
 					: "failed";
 
 		const taskInfo =

package/dist/builtin/subagents/src/runs/foreground/parent-ask-output.ts

@@ -0,0 +1,48 @@
+import type { ForegroundParentAskHandoff, ParentAskHandoffRequest } from "../../shared/types.js";
+
+function formatAttachments(request: ParentAskHandoffRequest): string {
+	let text = "";
+	for (const attachment of request.attachments ?? []) {
+		if (attachment.language) {
+			text += `\n\n---\n📎 ${attachment.name}\n~~~${attachment.language}\n${attachment.content}\n~~~`;
+		} else {
+			text += `\n\n---\n📎 ${attachment.name}\n${attachment.content}`;
+		}
+	}
+	return text;
+}
+
+function formatQuestion(request: ParentAskHandoffRequest): string {
+	const parts: string[] = [];
+	if (request.question.length > 0) parts.push(request.question);
+	if (request.interview) parts.push(JSON.stringify(request.interview, null, 2));
+	return parts.join("\n\n") + formatAttachments(request);
+}
+
+function freshTask(request: ParentAskHandoffRequest): string {
+	return [
+		"[TASK_CONTEXT]",
+		"Original delegated task and objective:",
+		request.taskContext ?? "(Original task context unavailable.)",
+		"",
+		`Previous child identity: ${request.agent} (child ${request.index + 1})`,
+		"Previous child question:",
+		formatQuestion(request),
+		"",
+		"Continue with this supervisor answer: <SUPERVISOR_ANSWER>",
+	].join("\n");
+}
+
+export function formatParentAskHandoffOutput(handoff: ForegroundParentAskHandoff): string {
+	const request = handoff.request;
+	const call = JSON.stringify({ agent: request.agent, task: freshTask(request) }, null, 2);
+	return [
+		`Subagent yielded for parent input (${request.agent}, child ${request.index + 1}).`,
+		`Previous run (terminal): ${request.runId}`,
+		"Question:",
+		formatQuestion(request),
+		"",
+		"Start a fresh subagent with a new run identity, replacing <SUPERVISOR_ANSWER> with your answer:",
+		`subagent(${call})`,
+	].join("\n");
+}

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-burst-display.ts

@@ -0,0 +1,46 @@
+import type { SubagentToolResult } from "../../shared/types.js";
+
+interface BurstDisplay {
+	ownerId: string;
+	callIds: string[];
+	taskCount: number;
+	result?: SubagentToolResult;
+}
+
+const MAX_RETAINED_BURST_DISPLAYS = 100;
+const displays: BurstDisplay[] = [];
+const displayByCallId = new Map<string, BurstDisplay>();
+
+export interface BurstDisplaySnapshot {
+	owner: boolean;
+	taskCount: number;
+	result?: SubagentToolResult;
+}
+
+export function registerBurstDisplay(callIds: string[], taskCount: number): BurstDisplay {
+	const display: BurstDisplay = { ownerId: callIds[0]!, callIds, taskCount };
+	displays.push(display);
+	for (const callId of callIds) displayByCallId.set(callId, display);
+	while (displays.length > MAX_RETAINED_BURST_DISPLAYS) {
+		const expired = displays.shift();
+		if (!expired) break;
+		for (const callId of expired.callIds) {
+			if (displayByCallId.get(callId) === expired) displayByCallId.delete(callId);
+		}
+	}
+	return display;
+}
+
+export function updateBurstDisplay(display: BurstDisplay, result: SubagentToolResult): void {
+	display.result = result;
+}
+
+export function getBurstDisplay(callId: string): BurstDisplaySnapshot | undefined {
+	const display = displayByCallId.get(callId);
+	if (!display) return undefined;
+	return {
+		owner: display.ownerId === callId,
+		taskCount: display.taskCount,
+		...(display.result ? { result: display.result } : {}),
+	};
+}