@arhen/pi-core-subagent 1.3.65 → 1.3.67

package/src/manager.ts

@@ -2,13 +2,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync
 import { rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, sep } from "node:path";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import {
-	type Api,
-	type AssistantMessage,
-	clampThinkingLevel,
-	getSupportedThinkingLevels,
-	type Model,
-} from "@earendil-works/pi-ai";
+import type { Api, AssistantMessage, Model } from "@earendil-works/pi-ai";
 import {
 	type AgentSessionEvent,
 	createAgentSession,
@@ -16,32 +10,39 @@ import {
 	type ExtensionAPI,
 	type ExtensionContext,
 	getAgentDir,
-	ModelRuntime,
 	SessionManager,
 	type ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
-import type { TUI } from "@earendil-works/pi-tui";
 import { resolveAgentFile } from "./agentfile.ts";
 import { CHILD_TALK_TOOLS, type ChildHandlers, createChildTools } from "./child.ts";
-import {
-	activitySnippet,
-	describeCall,
-	getFirstText,
-	isTalking,
-	makeAskNotice,
-	makeNotice,
-	makeTaskArtifactNotice,
-	makeTaskNotice,
-	SubagentsWidget,
-	truncateText,
-} from "./format.ts";
+import { readSubagentConfig, writeSubagentConfig } from "./config.ts";
+import { LeaderDelivery } from "./delivery.ts";
+import { activitySnippet, describeCall, getFirstText, truncateText } from "./format.ts";
 import { applyUpstream, resolveNeeds, runWaveScheduler } from "./graph.ts";
 import { createMailbox, type Mailbox } from "./mailbox.ts";
 import { chooseModel, resolveChildModel } from "./models.ts";
-import { artifactFingerprint, outcomeFingerprint, textFingerprint } from "./notification-state.ts";
+import { textFingerprint } from "./notification-state.ts";
+import {
+	aggregateUsage,
+	classifyFailure,
+	cloneRun,
+	emptyUsage,
+	failureError,
+	lastAssistantFailure,
+	updateUsageFromMessage,
+} from "./outcome.ts";
+import { RunWidget } from "./run-widget.ts";
+import {
+	clampResumeThinking,
+	codemodeFactories,
+	createChildModelRuntime,
+	ensureUsableModel,
+	validateThinking,
+} from "./runtime.ts";
 import type { SubagentParamsShape, TaskInput } from "./schemas.ts";
 import {
 	MAX_TASKS,
+	type ParkedMsg,
 	type PendingReply,
 	type RunDetails,
 	type RunMode,
@@ -50,7 +51,6 @@ import {
 	type TaskSnapshot,
 	type TaskStatus,
 	TERMINAL,
-	type UsageStats,
 } from "./types.ts";
 import {
 	attachWorktree,
@@ -64,8 +64,9 @@ import {
 	type Worktree,
 } from "./worktree.ts";
 
-/** Legacy callers import the resolver from here; its owner is `models.ts`. */
-export { resolveChildModel };
+export type { ParkedMsg };
+/** Legacy callers import these from here; their owners are `models.ts`, `outcome.ts`, `runtime.ts`. */
+export { clampResumeThinking, classifyFailure, cloneRun, ensureUsableModel, resolveChildModel, validateThinking };
 
 export const DEFAULT_CONCURRENCY = 3;
 export const MAX_CONCURRENCY = 8;
@@ -77,51 +78,11 @@ const READONLY_TOOLS = ["read", "grep", "find", "ls", "codemode"];
 const WRITE_TOOLS = ["read", "grep", "find", "ls", "bash", "edit", "write", "codemode"];
 const WRITE_CAPABLE = ["bash", "edit", "write"];
 const SAFE_TASK_ID = /^[A-Za-z0-9_-]{1,64}$/;
-const WIDGET_THROTTLE_MS = 150;
-/** A submitted notice missing from the canonical context this long is treated as lost. */
-const RECEIPT_GRACE_MS = 3_000;
-/** Minimum wait before retrying a failed submission, so one flush cannot burn every attempt. */
-const RETRY_BACKOFF_MS = 1_000;
-/** Total submission attempts before a notice is declared lost. */
-const MAX_DELIVERY_ATTEMPTS = 3;
 
 function newId(prefix: string): string {
 	return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
 
-type ChildExtensionFactories = ConstructorParameters<typeof DefaultResourceLoader>[0]["extensionFactories"];
-
-/**
- * Children run with `noExtensions`, so they get none of the configured extensions — codemode is the
- * one exception, because it is how a child batches tool calls. `createCodemodeExtension()` is the
- * supported factory (pi >= 1.0); hosts that do not export it simply give children no codemode.
- */
-async function codemodeFactories(): Promise<ChildExtensionFactories> {
-	try {
-		const host = (await import("@earendil-works/pi-coding-agent")) as unknown as {
-			createCodemodeExtension?: () => unknown;
-		};
-		const factory = host.createCodemodeExtension?.();
-		return factory ? ([factory] as ChildExtensionFactories) : [];
-	} catch {
-		return [];
-	}
-}
-function emptyUsage(): UsageStats {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-}
-function aggregateUsage(tasks: TaskSnapshot[]): UsageStats {
-	const total = emptyUsage();
-	for (const task of tasks) {
-		total.input += task.usage.input;
-		total.output += task.usage.output;
-		total.cacheRead += task.usage.cacheRead;
-		total.cacheWrite += task.usage.cacheWrite;
-		total.cost += task.usage.cost;
-		total.turns += task.usage.turns;
-	}
-	return total;
-}
 function safeRealPath(path: string): string {
 	try {
 		return realpathSync(path);
@@ -136,150 +97,6 @@ function getParentSessionFile(ctx: ExtensionContext): string | undefined {
 		return undefined;
 	}
 }
-export function classifyFailure(
-	stopReason: string | undefined,
-	errorMessage?: string,
-): { status: "failed" | "aborted"; message: string } | undefined {
-	if (!stopReason || stopReason === "stop" || stopReason === "end") return undefined;
-	if (stopReason === "aborted") return { status: "aborted", message: errorMessage || "Subagent was aborted." };
-	return { status: "failed", message: errorMessage || `Subagent ended with stopReason "${stopReason}".` };
-}
-function lastAssistantFailure(
-	messages: AssistantMessage[] | undefined,
-): { status: "failed" | "aborted"; message: string } | undefined {
-	for (const message of [...(messages ?? [])].reverse()) {
-		if (message?.role !== "assistant") continue;
-		return classifyFailure(message.stopReason, message.errorMessage);
-	}
-	return undefined;
-}
-function failureError(failure: { status: "failed" | "aborted"; message: string }): Error {
-	const error = new Error(failure.message);
-	(error as Error & { subagentStatus?: string }).subagentStatus = failure.status;
-	return error;
-}
-function updateUsageFromMessage(task: TaskSnapshot, message: AssistantMessage): void {
-	if (message?.role !== "assistant") return;
-	task.usage.turns += 1;
-	const usage = message.usage;
-	if (!usage) return;
-	task.usage.input += usage.input ?? 0;
-	task.usage.output += usage.output ?? 0;
-	task.usage.cacheRead += usage.cacheRead ?? 0;
-	task.usage.cacheWrite += usage.cacheWrite ?? 0;
-	task.usage.cost += usage.cost?.total ?? 0;
-	if (message.model && !task.model) task.model = message.model;
-}
-export function cloneRun(run: RunSnapshot): RunSnapshot {
-	return JSON.parse(JSON.stringify(run)) as RunSnapshot;
-}
-/**
- * A resumed task keeps its stored thinking level, clamped to what the target model accepts — a
- * resume that swaps model must not fail on an effort the new model does not define.
- */
-export function clampResumeThinking(
-	model: Model<Api> | undefined,
-	thinking: ThinkingLevel | undefined,
-): ThinkingLevel | undefined {
-	if (!thinking || !model) return thinking;
-	return clampThinkingLevel(model, thinking) as ThinkingLevel;
-}
-
-const PROBE_THINKING_LEVELS: ThinkingLevel[] = ["low", "minimal", "medium", "high", "xhigh", "max"];
-
-/**
- * Thinking level for the usability probe: exactly what the child session will send — the clamped
- * requested level, or the cheapest the model accepts when none was requested. Probing without a
- * level makes adaptive-thinking providers reject the request (9router claude models answer
- * "thinking.type.disabled is not supported"), which used to make every preflight fail and fall
- * back to the session model.
- */
-function probeThinking(model: Model<Api>, thinking?: string): ThinkingLevel | undefined {
-	if (!model.reasoning) return undefined;
-	const supported = getSupportedThinkingLevels(model);
-	if (thinking && thinking !== "off") return clampThinkingLevel(model, thinking as ThinkingLevel);
-	// the child clamps an unsupported "off" up to its cheapest level, so probe that instead
-	if (thinking === "off") return supported.includes("off") ? undefined : supported[0];
-	return PROBE_THINKING_LEVELS.find((level) => supported.includes(level));
-}
-
-async function probeModel(
-	ctx: ExtensionContext,
-	model: Model<Api>,
-	signal: AbortSignal | undefined,
-	thinking?: string,
-): Promise<string | undefined> {
-	try {
-		const reasoningEffort = probeThinking(model, thinking);
-		const reply = await ctx.modelRegistry.complete(
-			model,
-			{ messages: [{ role: "user", content: "ping", timestamp: Date.now() }] },
-			{ maxTokens: 16, signal, ...(reasoningEffort ? { reasoningEffort } : {}) },
-		);
-		return reply.stopReason === "error" ? (reply.errorMessage ?? "provider returned an error") : undefined;
-	} catch (err) {
-		return err instanceof Error ? err.message : String(err);
-	}
-}
-
-export async function ensureUsableModel(
-	ctx: ExtensionContext,
-	model: Model<Api> | undefined,
-	signal: AbortSignal | undefined,
-	thinking?: string,
-): Promise<{ model: Model<Api> | undefined; note?: string }> {
-	const session = ctx.model;
-	if (!model || !ctx.modelRegistry) return { model };
-	if (session && model.provider === session.provider && model.id === session.id) return { model };
-	const error = await probeModel(ctx, model, signal, thinking);
-	if (!error) return { model };
-	if (model.provider === "opencode-go" && /MissingSessionID|x-opencode-session/i.test(error)) {
-		// ponytail: opencode-go rejects stateless probes but accepts AgentSession requests, which add the session header.
-		// Upgrade path: remove this exception when modelRegistry.complete can carry AgentSession request transforms.
-		return { model, note: `preflight unavailable (${error}); child session will validate the model` };
-	}
-	if (!session) throw new Error(`Model ${model.provider}/${model.id} is unusable: ${error}`);
-	return {
-		model: session,
-		note: `${model.provider}/${model.id} failed preflight (${error}); using session model ${session.provider}/${session.id}`,
-	};
-}
-
-async function createChildModelRuntime(ctx: ExtensionContext) {
-	const ids = ctx.modelRegistry.getRegisteredProviderIds?.() ?? [];
-	if (ids.length === 0) return undefined;
-	const agentDir = getAgentDir();
-	const runtime = await ModelRuntime.create({
-		authPath: join(agentDir, "auth.json"),
-		modelsPath: join(agentDir, "models.json"),
-	});
-	for (const id of ids) {
-		const native = ctx.modelRegistry.getRegisteredNativeProvider?.(id);
-		if (native) {
-			runtime.registerNativeProvider(native);
-			continue;
-		}
-		const config = ctx.modelRegistry.getRegisteredProviderConfig?.(id);
-		if (config) runtime.registerProvider(id, config);
-	}
-	await runtime.refresh({ allowNetwork: false });
-	return runtime;
-}
-
-export function validateThinking(model: Model<Api> | undefined, level: string | undefined): void {
-	if (!level || level === "off") return;
-	if (!model) return;
-	const map = model.thinkingLevelMap;
-	if (map && level in map && map[level as keyof typeof map] === null) {
-		const supported = Object.keys(map).filter((k) => map[k as keyof typeof map] !== null);
-		throw new Error(
-			`Thinking level "${level}" is not supported by ${model.provider}/${model.id}. Supported: ${supported.length ? supported.join(" | ") : 'none — use thinking: "off"'}.`,
-		);
-	}
-	if (!model.reasoning) {
-		throw new Error(`Model ${model.provider}/${model.id} does not support thinking. Use thinking: "off".`);
-	}
-}
 
 interface ResumeInput {
 	sessionFile: string;
@@ -293,43 +110,6 @@ interface ChildEventState {
 	childEndResolve?: () => void;
 }
 
-export interface ParkedMsg {
-	kind: "ask" | "notify" | "done";
-	taskId: string;
-	agent: string;
-	text: string;
-	final?: boolean;
-}
-
-interface LeaderMessageReceipt {
-	runId: string;
-	taskIds: string[];
-	kind: "update" | "final" | "terminal";
-	deliverAs: "steer" | "followUp";
-	delivered: boolean;
-	submitted: boolean;
-	lost: boolean;
-	submittedAt: number;
-	attempts: number;
-	/** Agent runs started when this receipt was submitted; a later run is needed to prove loss. */
-	submittedRunCount: number;
-}
-
-interface OutboxEntry {
-	runId: string;
-	taskIds: string[];
-	kind: "update" | "final" | "terminal";
-	deliverAs: "steer" | "followUp";
-	attempts?: number;
-	attemptedAt?: number;
-}
-
-interface TerminalNotice {
-	body: string;
-	fingerprint: string;
-	delivery: "pending" | "received" | "lost";
-}
-
 export class SubagentManager {
 	private runs = new Map<string, RunSnapshot>();
 	private settlers = new Map<string, true>();
@@ -342,42 +122,38 @@ export class SubagentManager {
 	private mailboxes: Mailbox = createMailbox();
 	private liveWorktrees = new Map<string, Worktree>();
 	private runControllers = new Map<string, AbortController>();
-	private widgetTimers = new Map<string, ReturnType<typeof setTimeout>>();
-	private widgetRuns: RunSnapshot[] = [];
+	private readonly widget = new RunWidget();
+	private readonly delivery: LeaderDelivery;
 	private eventSeq = 0;
 	private persistSeq = 0;
 	private persistedSeq = 0;
 	private persistChain: Promise<unknown> = Promise.resolve();
 	private readonly instanceNonce = Math.random().toString(36).slice(2, 8);
 	private cleared = false;
-	private leaderMessages = new Map<string, LeaderMessageReceipt>();
-	private outbox = new Map<string, OutboxEntry>();
-	private parkedBodies = new Map<string, Set<string>>();
-	private agentRunCount = 0;
-	private terminalNotices = new Map<string, TerminalNotice>();
-	private awaitedTaskNotices = new Map<string, string>();
-	private pendingTaskNotices = new Map<string, { run: RunSnapshot; task: TaskSnapshot }>();
-	private pendingRunNotices = new Map<string, RunSnapshot>();
-	private notificationRetries = new Set<string>();
-	private notificationFlushTimer: ReturnType<typeof setTimeout> | undefined;
-	private notificationContext: ExtensionContext | undefined;
 
 	private autoLimit = false;
 
 	turnActivity = false;
 
 	constructor(private readonly pi: ExtensionAPI) {
+		this.delivery = new LeaderDelivery({
+			pi,
+			isCleared: () => this.cleared,
+			findRun: (runId) => this.runs.get(runId),
+			isLive: (key) => this.liveChildren.has(key),
+			persist: (ctx) => this.persist(ctx),
+			emit: (type, payload) => this.emit(type, payload),
+			collectParked: (runId, msg) => this.collectParked(runId, msg),
+		});
 		try {
-			const cfg = JSON.parse(readFileSync(join(getAgentDir(), "subagents-config.json"), "utf8"));
+			const cfg = readSubagentConfig();
 			if (typeof cfg.autoLimit === "boolean") this.autoLimit = cfg.autoLimit;
 		} catch {}
 	}
 
 	setAutoLimit(on: boolean): boolean {
 		this.autoLimit = on;
-		void writeFile(join(getAgentDir(), "subagents-config.json"), JSON.stringify({ autoLimit: on }, null, 2)).catch(
-			() => {},
-		);
+		void writeSubagentConfig({ autoLimit: on }).catch(() => {});
 		return on;
 	}
 
@@ -393,13 +169,24 @@ export class SubagentManager {
 	}
 
 	clearWidget(ctx?: ExtensionContext): void {
-		this.widgetRuns = [];
-		this.widgetTui = null;
-		if (ctx?.hasUI) {
-			try {
-				ctx.ui.setWidget("subagents", undefined);
-			} catch {}
-		}
+		this.widget.clear(ctx);
+	}
+
+	/** An agent run started; a receipt can only be declared lost after one full later run. */
+	noteAgentStart(): void {
+		this.delivery.noteAgentStart();
+	}
+	markAwaitCoverage(run: RunSnapshot, coveredTaskIds?: ReadonlySet<string>): void {
+		this.delivery.markAwaitCoverage(run, coveredTaskIds);
+	}
+	confirmLeaderMessages(ctx: ExtensionContext): void {
+		this.delivery.confirmLeaderMessages(ctx);
+	}
+	flushPendingNotifications(ctx: ExtensionContext): void {
+		this.delivery.flushPendingNotifications(ctx);
+	}
+	scheduleNotificationFlush(ctx: ExtensionContext, delayMs?: number): void {
+		this.delivery.scheduleNotificationFlush(ctx, delayMs);
 	}
 
 	listRuns(): RunSnapshot[] {
@@ -432,17 +219,7 @@ export class SubagentManager {
 			pending.resolve("(session ended — stop work immediately)");
 		}
 		this.parked.clear();
-		this.leaderMessages.clear();
-		this.outbox.clear();
-		this.parkedBodies.clear();
-		this.terminalNotices.clear();
-		this.awaitedTaskNotices.clear();
-		this.pendingTaskNotices.clear();
-		this.pendingRunNotices.clear();
-		this.notificationRetries.clear();
-		if (this.notificationFlushTimer) clearTimeout(this.notificationFlushTimer);
-		this.notificationFlushTimer = undefined;
-		this.notificationContext = undefined;
+		this.delivery.reset();
 
 		this.liveWorktrees.clear();
 		this.runs.clear();
@@ -452,14 +229,7 @@ export class SubagentManager {
 		this.runControllers.clear();
 		this.cleared = true;
 		this.mailboxes = createMailbox();
-		this.widgetTui = null;
-		if (this.pulseTimer) {
-			clearTimeout(this.pulseTimer);
-			this.pulseTimer = null;
-		}
-		for (const t of this.widgetTimers.values()) clearTimeout(t);
-		this.widgetTimers.clear();
-		this.widgetRuns = [];
+		this.widget.dispose();
 	}
 
 	async restoreFromSidecar(ctx: ExtensionContext): Promise<void> {
@@ -511,7 +281,7 @@ export class SubagentManager {
 		}
 		if (added > 0) {
 			this.emit("subagent:runs-restored", { count: added });
-			this.scheduleWidget(this.listRuns()[0], ctx);
+			this.widget.schedule(this.listRuns()[0], ctx);
 		}
 	}
 	private persist(ctx: ExtensionContext): void {
@@ -542,698 +312,6 @@ export class SubagentManager {
 		this.pi.events.emit(type, { type, timestamp: Date.now(), ...payload });
 	}
 
-	private finalReportMatches(task: TaskSnapshot): boolean {
-		const report = task.finalParentReport;
-		if (!report || report.toolCalls !== task.toolCalls) return false;
-		const fingerprint = task.finalTextFingerprint ?? textFingerprint(task.finalText ?? "");
-		return report.fingerprint === fingerprint;
-	}
-
-	private hasArtifactDelta(task: TaskSnapshot): boolean {
-		return artifactFingerprint(task) !== task.finalParentReport?.artifacts;
-	}
-
-	private leaderMessageText(content: unknown): string {
-		return typeof content === "string"
-			? content
-			: Array.isArray(content)
-				? content
-						.filter((part) => part?.type === "text")
-						.map((part) => part.text ?? "")
-						.join("\n")
-				: "";
-	}
-
-	/**
-	 * One pass over the finalized leader projection. Returns undefined when the pinned pi build
-	 * cannot project (never treat that as loss, or every receipt would be replayed).
-	 */
-	private projectionBody(ctx: ExtensionContext): string | undefined {
-		try {
-			const manager = ctx.sessionManager as unknown as {
-				buildSessionProjection?: () => { messages: readonly { role?: string; content?: unknown }[] };
-			};
-			if (typeof manager.buildSessionProjection !== "function") return undefined;
-			const messages = manager.buildSessionProjection().messages;
-			const parts: string[] = [];
-			for (const message of messages) {
-				if (message.role !== "user" && message.role !== "custom") continue;
-				parts.push(this.leaderMessageText(message.content));
-			}
-			return parts.join("\n");
-		} catch {
-			return undefined;
-		}
-	}
-
-	/** An agent run started; a receipt can only be declared lost after one full later run. */
-	noteAgentStart(): void {
-		this.agentRunCount += 1;
-	}
-
-	/** True when a terminal await already rendered this task's outcome. */
-	private coveredByAwait(runId: string, taskId: string, fingerprint: string): boolean {
-		return this.awaitedTaskNotices.get(`${runId}:${taskId}`) === fingerprint;
-	}
-
-	/** Record what a terminal await actually rendered, so held notices are dropped instead of echoed. */
-	markAwaitCoverage(run: RunSnapshot, coveredTaskIds?: ReadonlySet<string>): void {
-		for (const task of run.tasks) {
-			if (!TERMINAL.includes(task.status)) continue;
-			if (coveredTaskIds && !coveredTaskIds.has(task.id)) continue;
-			const scope = `${run.id}:${task.id}`;
-			this.awaitedTaskNotices.set(scope, outcomeFingerprint(task));
-			this.pendingTaskNotices.delete(scope);
-		}
-		for (const [body, entry] of [...this.outbox]) {
-			if (entry.runId !== run.id) continue;
-			if (!this.outboxCovered(entry)) continue;
-			const task = run.tasks.find((t) => t.id === entry.taskIds[0]);
-			// An update is not part of the rendered summary; only terminal/aggregate entries are safe to drop.
-			if (entry.kind === "update") continue;
-			if (entry.kind === "final" && (!task || !this.finalReportMatches(task))) continue;
-			this.dropOutbox(body, entry, "awaited");
-		}
-	}
-
-	private outboxCovered(entry: OutboxEntry): boolean {
-		const run = this.runs.get(entry.runId);
-		if (!run) return false;
-		return entry.taskIds.every((taskId) => {
-			const task = run.tasks.find((t) => t.id === taskId);
-			if (!task || !TERMINAL.includes(task.status)) return false;
-			return this.coveredByAwait(entry.runId, taskId, outcomeFingerprint(task));
-		});
-	}
-
-	private dropOutbox(body: string, entry: OutboxEntry, delivery: string): void {
-		this.outbox.delete(body);
-		const task = this.runs.get(entry.runId)?.tasks.find((t) => t.id === entry.taskIds[0]);
-		if (entry.kind === "final" && task?.finalParentReport?.body === body) task.finalParentReport.delivery = "awaited";
-		if (entry.kind === "terminal") {
-			for (const taskId of entry.taskIds) {
-				const notice = this.terminalNotices.get(`${entry.runId}:${taskId}`);
-				if (notice?.body === body) notice.delivery = "received";
-			}
-		}
-		this.emit("subagent:notification", {
-			runId: entry.runId,
-			taskId: entry.taskIds[0],
-			kind: "completed",
-			body: "",
-			suppressed: true,
-			delivery,
-		});
-	}
-
-	private enqueueNotification(body: string, entry: OutboxEntry, ctx?: ExtensionContext): void {
-		this.outbox.set(body, entry);
-		const flushContext = ctx ?? this.notificationContext;
-		if (flushContext) this.scheduleNotificationFlush(flushContext);
-	}
-
-	private noteTerminal(runId: string, taskId: string, body: string, fingerprint: string): void {
-		this.terminalNotices.set(`${runId}:${taskId}`, { body, fingerprint, delivery: "pending" });
-	}
-
-	private submitLeaderReport(
-		run: RunSnapshot,
-		task: TaskSnapshot,
-		message: string,
-		level: "info" | "warning" | "error",
-		final: boolean,
-		ctx: ExtensionContext,
-	): boolean {
-		if (this.cleared) return false;
-		this.notificationContext = ctx;
-		const body = `[Subagent ${task.agent} (${task.id}, ${run.id})]${final ? " Final result:" : ""}${level === "info" ? "" : ` [${level}]`} ${message}`;
-		const previous = this.leaderMessages.get(body);
-		if ((previous && !previous.lost) || this.outbox.has(body)) {
-			if (final) {
-				task.finalParentReport = {
-					body,
-					message,
-					toolCalls: task.toolCalls,
-					fingerprint: textFingerprint(message),
-					artifacts: artifactFingerprint(task),
-					delivery: previous?.delivered ? "message" : "pending",
-				};
-			}
-			return true;
-		}
-		if (previous?.lost) this.leaderMessages.delete(body);
-		const report: TaskSnapshot["finalParentReport"] = final
-			? {
-					body,
-					message,
-					toolCalls: task.toolCalls,
-					fingerprint: textFingerprint(message),
-					artifacts: artifactFingerprint(task),
-					delivery: "pending",
-				}
-			: undefined;
-		if (report) task.finalParentReport = report;
-		this.emit("subagent:intercom", { runId: run.id, taskId: task.id, kind: "notify", level, message, final });
-		if (this.collectParked(run.id, { kind: "notify", taskId: task.id, agent: task.agent, text: message, final })) {
-			let parked = this.parkedBodies.get(run.id);
-			if (!parked) {
-				parked = new Set();
-				this.parkedBodies.set(run.id, parked);
-			}
-			if (parked.has(body)) return true;
-			parked.add(body);
-			task.notifiedParent = true;
-			if (report) report.delivery = "parked";
-			return true;
-		}
-		this.enqueueNotification(body, {
-			runId: run.id,
-			taskIds: [task.id],
-			kind: final ? "final" : "update",
-			deliverAs: "followUp",
-		});
-		return true;
-	}
-
-	private hasPendingSuccessMessages(run: RunSnapshot): boolean {
-		return run.tasks.some((task) => {
-			const notice = this.terminalNotices.get(`${run.id}:${task.id}`);
-			if (notice?.delivery !== "pending") return false;
-			const receipt = this.leaderMessages.get(notice.body);
-			return receipt ? !receipt.delivered && !receipt.lost : this.outbox.has(notice.body);
-		});
-	}
-
-	confirmLeaderMessages(ctx: ExtensionContext): void {
-		if (this.cleared) return;
-		const projection = this.projectionBody(ctx);
-		let changed = false;
-		for (const [body, receipt] of [...this.leaderMessages]) {
-			if (receipt.delivered || receipt.lost || projection === undefined || !projection.includes(body)) continue;
-			receipt.delivered = true;
-			changed = true;
-			const run = this.runs.get(receipt.runId);
-			for (const taskId of receipt.taskIds) {
-				const task = run?.tasks.find((t) => t.id === taskId);
-				if (!task) continue;
-				task.notifiedParent = true;
-				if (task.finalParentReport?.body === body) task.finalParentReport.delivery = "message";
-				const key = `${receipt.runId}:${taskId}`;
-				const notice = this.terminalNotices.get(key);
-				if (notice?.body === body) notice.delivery = "received";
-				const pending = this.pendingTaskNotices.get(key);
-				if (pending && this.finalReportMatches(task)) {
-					this.pendingTaskNotices.delete(key);
-					if (this.hasArtifactDelta(task)) this.notifyTask(pending.run, task, "completed");
-				}
-			}
-			if (run && !this.hasPendingSuccessMessages(run)) this.pendingRunNotices.delete(run.id);
-		}
-		if (changed) this.persist(ctx);
-		for (const [body, receipt] of this.leaderMessages) {
-			if (!receipt.delivered && !receipt.lost) continue;
-			const run = this.runs.get(receipt.runId);
-			const tasks = run?.tasks.filter((task) => receipt.taskIds.includes(task.id)) ?? [];
-			if (
-				tasks.length > 0 &&
-				tasks.every((task) => TERMINAL.includes(task.status) && !this.liveChildren.has(`${receipt.runId}:${task.id}`))
-			)
-				this.leaderMessages.delete(body);
-		}
-	}
-
-	/**
-	 * A submitted receipt that never appears in the canonical context after a grace period is lost.
-	 * The grace period keeps the check from racing Pi's input/auth/start hooks, which run before the
-	 * message is appended to the session and can be slow while the session still reports idle.
-	 */
-	private markLostReceipts(ctx: ExtensionContext, existing: ReadonlySet<string>): void {
-		const now = Date.now();
-		const projection = this.projectionBody(ctx);
-		if (projection === undefined) return;
-		for (const [body, receipt] of [...this.leaderMessages]) {
-			if (receipt.delivered || receipt.lost || !existing.has(body)) continue;
-			if (this.outbox.has(body)) continue;
-			if (now - receipt.submittedAt < RECEIPT_GRACE_MS) continue;
-			// A later agent run proves the submitted prompt had its turn; a message that never runs
-			// at all is caught by the longer bound. While a prompt is still queued or in preflight
-			// (deferred settle, slow input/auth hooks) the session can report idle without the
-			// message being appended yet, so the short window alone must not declare loss.
-			const laterRun = this.agentRunCount > receipt.submittedRunCount;
-			const longWait = now - receipt.submittedAt >= RECEIPT_GRACE_MS * 2;
-			if (!laterRun && !longWait) continue;
-			if (projection.includes(body)) continue;
-			if (receipt.attempts < MAX_DELIVERY_ATTEMPTS) {
-				this.leaderMessages.delete(body);
-				this.outbox.set(body, {
-					runId: receipt.runId,
-					taskIds: receipt.taskIds,
-					kind: receipt.kind,
-					deliverAs: receipt.deliverAs,
-					attempts: receipt.attempts,
-					attemptedAt: now,
-				});
-				continue;
-			}
-			receipt.lost = true;
-			for (const taskId of receipt.taskIds) {
-				const key = `${receipt.runId}:${taskId}`;
-				const notice = this.terminalNotices.get(key);
-				if (notice?.body === body) notice.delivery = "lost";
-				const task = this.runs.get(receipt.runId)?.tasks.find((t) => t.id === taskId);
-				if (task?.finalParentReport?.body === body) task.finalParentReport.delivery = "lost";
-			}
-			this.emit("subagent:notification", {
-				runId: receipt.runId,
-				taskId: receipt.taskIds[0],
-				kind: "completed",
-				body,
-				delivery: "lost",
-			});
-			// A lost final report must still reach the leader: per-task hold or a direct full fallback.
-			if (receipt.kind === "final") {
-				const run = this.runs.get(receipt.runId);
-				for (const taskId of receipt.taskIds) {
-					if (this.pendingTaskNotices.has(`${receipt.runId}:${taskId}`)) continue;
-					const task = run?.tasks.find((t) => t.id === taskId);
-					if (run && task) this.notifyTask(run, task, "completed");
-				}
-			}
-		}
-	}
-
-	private flushOutbox(): void {
-		for (const [body, entry] of [...this.outbox]) {
-			if (this.outboxCovered(entry)) {
-				this.dropOutbox(body, entry, "awaited");
-				continue;
-			}
-			if (entry.attemptedAt && Date.now() - entry.attemptedAt < RETRY_BACKOFF_MS) continue;
-			this.outbox.delete(body);
-			try {
-				this.pi.sendUserMessage(body, { deliverAs: entry.deliverAs });
-				this.leaderMessages.set(body, {
-					runId: entry.runId,
-					taskIds: entry.taskIds,
-					kind: entry.kind,
-					deliverAs: entry.deliverAs,
-					delivered: false,
-					submitted: true,
-					lost: false,
-					submittedAt: Date.now(),
-					attempts: (entry.attempts ?? 0) + 1,
-					submittedRunCount: this.agentRunCount,
-				});
-				if (entry.kind === "terminal") {
-					for (const taskId of entry.taskIds) {
-						const notice = this.terminalNotices.get(`${entry.runId}:${taskId}`);
-						if (notice?.body === body) notice.delivery = "pending";
-					}
-				}
-				this.emit("subagent:notification", {
-					runId: entry.runId,
-					taskId: entry.taskIds[0],
-					kind: "completed",
-					body,
-					delivery: "submitted",
-				});
-			} catch {
-				const attempts = (entry.attempts ?? 0) + 1;
-				if (attempts < MAX_DELIVERY_ATTEMPTS) {
-					this.outbox.set(body, { ...entry, attempts, attemptedAt: Date.now() });
-					continue;
-				}
-				this.emit("subagent:notification", {
-					runId: entry.runId,
-					taskId: entry.taskIds[0],
-					kind: "completed",
-					body,
-					delivery: "failed",
-				});
-			}
-		}
-	}
-
-	flushPendingNotifications(ctx: ExtensionContext): void {
-		const existing = new Set([...this.leaderMessages.keys(), ...this.outbox.keys()]);
-		this.confirmLeaderMessages(ctx);
-		if (this.cleared) return;
-		let idle = false;
-		try {
-			idle = ctx.isIdle() && !ctx.hasPendingMessages();
-		} catch {
-			idle = false;
-		}
-		if (idle) this.markLostReceipts(ctx, existing);
-		const outstandingReceipts = () =>
-			[...this.leaderMessages.values()].some((receipt) => !receipt.delivered && !receipt.lost);
-		if (!this.pendingTaskNotices.size && !this.pendingRunNotices.size && !this.outbox.size && !outstandingReceipts())
-			return;
-		if (idle) {
-			this.flushOutbox();
-			for (const [key, pending] of [...this.pendingTaskNotices]) {
-				const report = pending.task.finalParentReport;
-				if (report?.delivery === "lost") {
-					this.pendingTaskNotices.delete(key);
-					pending.task.finalParentReport = undefined;
-					this.notifyTask(pending.run, pending.task, "completed");
-					continue;
-				}
-				if (report?.delivery === "pending") {
-					const outstanding = this.leaderMessages.has(report.body) || this.outbox.has(report.body);
-					if (outstanding) continue;
-					this.pendingTaskNotices.delete(key);
-					pending.task.finalParentReport = undefined;
-					this.notifyTask(pending.run, pending.task, "completed");
-					continue;
-				}
-				this.pendingTaskNotices.delete(key);
-				if (report && this.finalReportMatches(pending.task) && this.hasArtifactDelta(pending.task))
-					this.notifyTask(pending.run, pending.task, "completed");
-			}
-			for (const [key, run] of [...this.pendingRunNotices]) {
-				const notices = run.tasks
-					.map((task) => this.terminalNotices.get(`${run.id}:${task.id}`))
-					.filter((notice): notice is TerminalNotice => Boolean(notice));
-				const waiting = notices.some((notice) => {
-					const receipt = this.leaderMessages.get(notice.body);
-					return notice.delivery === "pending" && (!receipt || (!receipt.delivered && !receipt.lost));
-				});
-				if (waiting) continue;
-				this.pendingRunNotices.delete(key);
-				const lost = notices.some((notice) => notice.delivery === "lost");
-				if (!lost || this.notificationRetries.has(run.id)) continue;
-				this.notificationRetries.add(run.id);
-				this.notifyParent(run, run.status === "aborted" ? "aborted" : run.status === "failed" ? "failed" : "completed");
-			}
-			this.flushOutbox();
-		}
-		// Anything still unresolved (including a retry backoff) must be revisited without unrelated activity.
-		this.scheduleNotificationFlush(ctx, RETRY_BACKOFF_MS);
-	}
-
-	scheduleNotificationFlush(ctx: ExtensionContext, delayMs = 100): void {
-		if (
-			this.notificationFlushTimer ||
-			this.cleared ||
-			(!this.pendingTaskNotices.size &&
-				!this.pendingRunNotices.size &&
-				!this.outbox.size &&
-				![...this.leaderMessages.values()].some((receipt) => !receipt.delivered && !receipt.lost))
-		)
-			return;
-		this.notificationFlushTimer = setTimeout(() => {
-			this.notificationFlushTimer = undefined;
-			this.flushPendingNotifications(ctx);
-		}, delayMs);
-		this.notificationFlushTimer.unref?.();
-	}
-
-	private notifyTask(run: RunSnapshot, task: TaskSnapshot, kind: "completed" | "failed" | "aborted"): void {
-		const key = `${run.id}:${task.id}`;
-		const outcome = outcomeFingerprint(task);
-		const final = kind === "completed" && this.finalReportMatches(task);
-		const report = task.finalParentReport;
-		if (final && report?.delivery === "pending") {
-			this.pendingTaskNotices.set(key, { run, task });
-			if (this.notificationContext) this.scheduleNotificationFlush(this.notificationContext);
-			this.emit("subagent:notification", {
-				runId: run.id,
-				taskId: task.id,
-				kind,
-				body: "",
-				suppressed: true,
-				delivery: "pending",
-			});
-			return;
-		}
-		if (
-			final &&
-			report &&
-			report.delivery !== "lost" &&
-			report.delivery !== "pending" &&
-			!this.hasArtifactDelta(task)
-		) {
-			this.emit("subagent:notification", {
-				runId: run.id,
-				taskId: task.id,
-				kind,
-				body: "",
-				suppressed: true,
-				delivery: report.delivery,
-			});
-			return;
-		}
-		const covered = this.terminalNotices.get(key);
-		if (covered?.fingerprint === outcome && covered.delivery !== "lost") {
-			this.emit("subagent:notification", {
-				runId: run.id,
-				taskId: task.id,
-				kind,
-				body: "",
-				suppressed: true,
-				delivery: covered.delivery,
-			});
-			return;
-		}
-		if (this.coveredByAwait(run.id, task.id, outcome)) {
-			this.emit("subagent:notification", {
-				runId: run.id,
-				taskId: task.id,
-				kind,
-				body: "",
-				suppressed: true,
-				delivery: "awaited",
-			});
-			return;
-		}
-		const artifactOnly = final && report?.delivery !== "lost";
-		const body = artifactOnly ? makeTaskArtifactNotice(run, task) : makeTaskNotice(run, task, kind);
-		if (this.collectParked(run.id, { kind: "done", taskId: task.id, agent: task.agent, text: body })) {
-			this.noteTerminal(run.id, task.id, body, outcome);
-			this.terminalNotices.get(key)!.delivery = "received";
-			this.emit("subagent:notification", { runId: run.id, taskId: task.id, kind, body, delivery: "parked" });
-			return;
-		}
-		if (kind === "failed") {
-			this.noteTerminal(run.id, task.id, body, outcome);
-			try {
-				this.pi.sendUserMessage(body, { deliverAs: "steer" });
-				this.leaderMessages.set(body, {
-					runId: run.id,
-					taskIds: [task.id],
-					kind: "terminal",
-					deliverAs: "steer",
-					delivered: false,
-					submitted: true,
-					lost: false,
-					submittedAt: Date.now(),
-					attempts: 0,
-					submittedRunCount: this.agentRunCount,
-				});
-				this.emit("subagent:notification", { runId: run.id, taskId: task.id, kind, body, delivery: "submitted" });
-				if (this.notificationContext) this.scheduleNotificationFlush(this.notificationContext, RECEIPT_GRACE_MS);
-			} catch {
-				this.terminalNotices.get(key)!.delivery = "lost";
-				this.emit("subagent:notification", { runId: run.id, taskId: task.id, kind, body, delivery: "failed" });
-			}
-			return;
-		}
-		this.noteTerminal(run.id, task.id, body, outcome);
-		this.enqueueNotification(body, {
-			runId: run.id,
-			taskIds: [task.id],
-			kind: "terminal",
-			deliverAs: "followUp",
-		});
-		this.emit("subagent:notification", { runId: run.id, taskId: task.id, kind, body, delivery: "held" });
-	}
-
-	private notifyParent(
-		run: RunSnapshot,
-		kind: "completed" | "failed" | "aborted" | "asked",
-		extra?: { taskId?: string; agent?: string; question?: string; urgent?: boolean },
-	): void {
-		if (kind !== "asked" && run.completionAwaited) return;
-		let tasks = run.tasks;
-		if (kind !== "asked") {
-			tasks = tasks.filter((task) => {
-				const key = `${run.id}:${task.id}`;
-				const outcome = outcomeFingerprint(task);
-				const covered = this.terminalNotices.get(key);
-				if (covered?.fingerprint === outcome && covered.delivery !== "lost") return false;
-				if (this.pendingTaskNotices.has(key)) return false;
-				if (this.coveredByAwait(run.id, task.id, outcome)) return false;
-				if (
-					kind === "completed" &&
-					task.finalParentReport?.delivery !== "lost" &&
-					this.finalReportMatches(task) &&
-					!this.hasArtifactDelta(task)
-				)
-					return false;
-				return true;
-			});
-			if (tasks.length === 0) {
-				if (!this.notificationRetries.has(run.id) && this.hasPendingSuccessMessages(run)) {
-					this.pendingRunNotices.set(run.id, run);
-					if (this.notificationContext) this.scheduleNotificationFlush(this.notificationContext);
-				}
-				this.emit("subagent:notification", { runId: run.id, kind, body: "", suppressed: true });
-				return;
-			}
-			// Aggregate-only mode has no per-task hold: keep a run-level watch so a pending report
-			// that later goes lost still produces a fallback.
-			if (
-				!this.notificationRetries.has(run.id) &&
-				!this.pendingRunNotices.has(run.id) &&
-				run.tasks.some((task) => task.finalParentReport?.delivery === "pending")
-			) {
-				this.pendingRunNotices.set(run.id, run);
-				if (this.notificationContext) this.scheduleNotificationFlush(this.notificationContext);
-			}
-		}
-		if (kind === "asked") {
-			const body = makeAskNotice(run, extra ?? {});
-			try {
-				this.pi.sendUserMessage(body, { deliverAs: "steer" });
-				this.emit("subagent:notification", { runId: run.id, taskId: extra?.taskId, kind, body, delivery: "submitted" });
-			} catch {
-				this.emit("subagent:notification", { runId: run.id, taskId: extra?.taskId, kind, body, delivery: "failed" });
-			}
-			return;
-		}
-		const body = makeNotice(run, kind, tasks);
-		const deliverAs = kind === "failed" ? "steer" : "followUp";
-		for (const task of tasks) this.noteTerminal(run.id, task.id, body, outcomeFingerprint(task));
-		if (deliverAs === "steer") {
-			try {
-				this.pi.sendUserMessage(body, { deliverAs });
-				this.leaderMessages.set(body, {
-					runId: run.id,
-					taskIds: tasks.map((t) => t.id),
-					kind: "terminal",
-					deliverAs,
-					delivered: false,
-					submitted: true,
-					lost: false,
-					submittedAt: Date.now(),
-					attempts: 0,
-					submittedRunCount: this.agentRunCount,
-				});
-				if (this.notificationContext) this.scheduleNotificationFlush(this.notificationContext, RECEIPT_GRACE_MS);
-			} catch {
-				for (const task of tasks) {
-					const notice = this.terminalNotices.get(`${run.id}:${task.id}`);
-					if (notice?.body === body) notice.delivery = "lost";
-				}
-			}
-			this.emit("subagent:notification", { runId: run.id, kind, body, delivery: "submitted" });
-			this.holdRunFallback(run, tasks);
-			return;
-		}
-		this.enqueueNotification(body, {
-			runId: run.id,
-			taskIds: tasks.map((t) => t.id),
-			kind: "terminal",
-			deliverAs,
-		});
-		this.emit("subagent:notification", { runId: run.id, kind, body, delivery: "held" });
-		this.holdRunFallback(run, tasks);
-	}
-
-	/** Keep one bounded retry for aggregates whose per-task receipts never arrived. */
-	private holdRunFallback(run: RunSnapshot, tasks: TaskSnapshot[]): void {
-		if (this.notificationRetries.has(run.id)) return;
-		const covered = tasks.filter((task) => {
-			const notice = this.terminalNotices.get(`${run.id}:${task.id}`);
-			return Boolean(notice && notice.body !== "");
-		});
-		if (covered.length === 0) return;
-		this.pendingRunNotices.set(run.id, run);
-		if (this.notificationContext) this.scheduleNotificationFlush(this.notificationContext);
-	}
-
-	private widgetTui: TUI | null = null;
-
-	/** Settled runs are history (subagent_status/result still reach them) — the widget shows live work only. */
-	private pruneSettledWidget(): void {
-		this.widgetRuns = this.widgetRuns.filter((r) => !TERMINAL.includes(r.status));
-	}
-	private upsertWidgetRun(run: RunSnapshot | undefined): void {
-		this.pruneSettledWidget();
-		if (!run || TERMINAL.includes(run.status)) return;
-		const idx = this.widgetRuns.findIndex((r) => r.id === run.id);
-		if (idx >= 0) this.widgetRuns[idx] = run;
-		else this.widgetRuns.push(run);
-	}
-	private scheduleWidget(run: RunSnapshot | undefined, ctx?: ExtensionContext): void {
-		this.upsertWidgetRun(run);
-		if (!run || this.widgetTimers.has(run.id)) return;
-		this.widgetTimers.set(
-			run.id,
-			setTimeout(() => {
-				this.widgetTimers.delete(run.id);
-				if (ctx?.hasUI) {
-					this.ensureWidget(ctx);
-					this.widgetTui?.requestRender();
-				}
-				this.maybePulse(ctx);
-			}, WIDGET_THROTTLE_MS),
-		);
-	}
-
-	private pulseTimer: ReturnType<typeof setTimeout> | null = null;
-	private maybePulse(ctx?: ExtensionContext): void {
-		if (this.pulseTimer || !this.widgetTui) return;
-		const talking = this.widgetRuns.some((r) => r.tasks.some(isTalking));
-		if (!talking) return;
-		this.pulseTimer = setTimeout(() => {
-			this.pulseTimer = null;
-			this.widgetTui?.requestRender();
-			this.maybePulse(ctx);
-		}, 700);
-	}
-	private flushWidget(run: RunSnapshot | undefined, ctx?: ExtensionContext, onUpdate?: (partial: any) => void): void {
-		if (run) {
-			const t = this.widgetTimers.get(run.id);
-			if (t) {
-				clearTimeout(t);
-				this.widgetTimers.delete(run.id);
-			}
-		}
-		this.pruneSettledWidget();
-		if (this.widgetRuns.length === 0) {
-			if (this.widgetTui) this.clearWidget(ctx);
-		} else {
-			if (ctx?.hasUI) {
-				this.ensureWidget(ctx);
-				this.widgetTui?.requestRender();
-			}
-			this.maybePulse(ctx);
-		}
-		if (!run) return;
-
-		onUpdate?.({
-			content: [
-				{
-					type: "text",
-					text: `${run.tasks.filter((t) => TERMINAL.includes(t.status)).length}/${run.tasks.length} done · ${run.status}`,
-				},
-			],
-		});
-	}
-	private ensureWidget(ctx: ExtensionContext): void {
-		if (this.widgetTui !== null || !ctx.hasUI) return;
-		ctx.ui.setWidget(
-			"subagents",
-			(tui, theme) => {
-				this.widgetTui = tui;
-				return new SubagentsWidget(() => [...this.widgetRuns], theme);
-			},
-			{ placement: "aboveEditor" },
-		);
-	}
-
 	private updateRun(run: RunSnapshot, ctx?: ExtensionContext, _onUpdate?: (partial: any) => void): void {
 		run.aggregateUsage = aggregateUsage(run.tasks);
 		this.runs.set(run.id, run);
@@ -1242,7 +320,7 @@ export class SubagentManager {
 			status: run.status,
 			live: run.tasks.filter((t) => !TERMINAL.includes(t.status)).length,
 		});
-		this.scheduleWidget(run, ctx);
+		this.widget.schedule(run, ctx);
 	}
 	private updateTask(
 		run: RunSnapshot,
@@ -1257,7 +335,7 @@ export class SubagentManager {
 	}
 
 	private makeChildHandlers(run: RunSnapshot, task: TaskSnapshot, ctx: ExtensionContext): ChildHandlers {
-		this.notificationContext = ctx;
+		this.delivery.notificationContext = ctx;
 		return {
 			onAskParent: async (_taskId, question, urgent) => {
 				if (TERMINAL.includes(task.status)) {
@@ -1266,7 +344,7 @@ export class SubagentManager {
 				this.updateTask(run, task, { status: "awaiting_parent" }, ctx);
 
 				if (!this.collectParked(run.id, { kind: "ask", taskId: task.id, agent: task.agent, text: question })) {
-					this.notifyParent(run, "asked", { taskId: task.id, agent: task.agent, question, urgent });
+					this.delivery.notifyParent(run, "asked", { taskId: task.id, agent: task.agent, question, urgent });
 				}
 
 				const reply = await this.awaitParentReply(run.id, task.id, PARENT_REPLY_TIMEOUT_MS);
@@ -1278,9 +356,9 @@ export class SubagentManager {
 				return reply;
 			},
 			onNotifyParent: (_taskId, message, level, final = false) =>
-				this.submitLeaderReport(run, task, message, level, final, ctx),
+				this.delivery.submitLeaderReport(run, task, message, level, final, ctx),
 			onSendMessage: (_taskId, to, text, final = false) => {
-				if (to === "leader") return this.submitLeaderReport(run, task, text, "info", final, ctx);
+				if (to === "leader") return this.delivery.submitLeaderReport(run, task, text, "info", final, ctx);
 
 				return this.mailboxes.send(`${run.id}:${task.id}`, `${run.id}:${to}`, text);
 			},
@@ -1350,7 +428,7 @@ export class SubagentManager {
 				onUpdate,
 			);
 		} else if (event.type === "tool_execution_end") {
-			this.scheduleWidget(run, ctx);
+			this.widget.schedule(run, ctx);
 		} else if (event.type === "message_end") {
 			const message = event.message as AssistantMessage;
 			if (message?.role === "assistant") {
@@ -1908,7 +986,7 @@ export class SubagentManager {
 				);
 				if (task.status === "completed") outputs.set(task.id, task.finalText ?? "");
 				if (run.notifyPerTask && TERMINAL.includes(task.status)) {
-					this.notifyTask(run, task, task.status as "completed" | "failed" | "aborted");
+					this.delivery.notifyTask(run, task, task.status as "completed" | "failed" | "aborted");
 				}
 			},
 		);
@@ -1946,10 +1024,10 @@ export class SubagentManager {
 		const aborted = run.tasks.some((t) => t.status === "aborted") || Boolean(signal?.aborted);
 		run.status = aborted ? "aborted" : failed ? "failed" : "completed";
 		run.endedAt = Date.now();
-		this.flushWidget(run, ctx, onUpdate);
+		this.widget.flush(run, ctx, onUpdate);
 
 		const live = this.listRuns().find((r) => !TERMINAL.includes(r.status));
-		if (live) this.scheduleWidget(live, ctx);
+		if (live) this.widget.schedule(live, ctx);
 
 		if (this.settlers.has(run.id)) {
 			this.emit("subagent:run-completed", {
@@ -1987,7 +1065,7 @@ export class SubagentManager {
 		const { run, inputs } = this.createRun(params, ctx);
 		void this.executeTasks(run, inputs, ctx, undefined, undefined)
 			.then(() => {
-				this.notifyParent(
+				this.delivery.notifyParent(
 					run,
 					run.status === "completed" ? "completed" : run.status === "aborted" ? "aborted" : "failed",
 				);
@@ -2006,7 +1084,7 @@ export class SubagentManager {
 				this.runControllers.delete(run.id);
 				for (const task of run.tasks) this.mailboxes.close(`${run.id}:${task.id}`);
 				this.emit("subagent:run-completed", { runId: run.id, status: "failed", run: cloneRun(run) });
-				this.notifyParent(run, "failed");
+				this.delivery.notifyParent(run, "failed");
 				this.persist(ctx);
 			});
 		return { run: cloneRun(run) };
@@ -2084,35 +1162,7 @@ export class SubagentManager {
 			changedFiles: undefined,
 			worktreeError: undefined,
 		});
-		const scope = `${run.id}:${task.id}`;
-		this.terminalNotices.delete(scope);
-		this.pendingTaskNotices.delete(scope);
-		this.pendingRunNotices.delete(run.id);
-		this.notificationRetries.delete(run.id);
-		for (const [body, receipt] of this.leaderMessages) {
-			if (receipt.runId !== run.id || !receipt.taskIds.includes(task.id)) continue;
-			if (receipt.taskIds.length === 1) {
-				this.leaderMessages.delete(body);
-				continue;
-			}
-			// A shared aggregate stays for its remaining tasks; the resumed task's slice is published
-			// again by the run's next settle.
-			receipt.taskIds = receipt.taskIds.filter((id) => id !== task.id);
-		}
-		for (const [body, entry] of this.outbox) {
-			if (entry.runId !== run.id || !entry.taskIds.includes(task.id)) continue;
-			if (entry.taskIds.length === 1) {
-				this.outbox.delete(body);
-				continue;
-			}
-			this.outbox.delete(body);
-			for (const otherId of entry.taskIds) {
-				if (otherId === task.id) continue;
-				const notice = this.terminalNotices.get(`${run.id}:${otherId}`);
-				if (notice) notice.delivery = "lost";
-			}
-		}
-		this.awaitedTaskNotices.delete(scope);
+		this.delivery.forgetTask(run, task);
 		run.status = "running";
 		run.endedAt = undefined;
 		run.awaited = false;
@@ -2135,7 +1185,7 @@ export class SubagentManager {
 				}
 			})
 			.then(() => {
-				if (run.notifyPerTask) this.notifyTask(run, task, task.status as "completed" | "failed" | "aborted");
+				if (run.notifyPerTask) this.delivery.notifyTask(run, task, task.status as "completed" | "failed" | "aborted");
 				this.finishRunIfSettled(run, ctx);
 			});
 		return { ok: true, task, note: thinkingNote };
@@ -2147,7 +1197,7 @@ export class SubagentManager {
 		const aborted = run.tasks.some((t) => t.status === "aborted");
 		run.status = aborted ? "aborted" : failed ? "failed" : "completed";
 		run.endedAt = Date.now();
-		this.flushWidget(run, ctx);
+		this.widget.flush(run, ctx);
 		this.emit("subagent:run-completed", {
 			runId: run.id,
 			status: run.status,
@@ -2158,7 +1208,10 @@ export class SubagentManager {
 		this.runControllers.delete(run.id);
 		for (const task of run.tasks) this.mailboxes.close(`${run.id}:${task.id}`);
 		this.persist(ctx);
-		this.notifyParent(run, run.status === "completed" ? "completed" : run.status === "aborted" ? "aborted" : "failed");
+		this.delivery.notifyParent(
+			run,
+			run.status === "completed" ? "completed" : run.status === "aborted" ? "aborted" : "failed",
+		);
 	}
 
 	steerTask(runId: string, taskId: string | undefined, message: string): boolean {
@@ -2182,7 +1235,7 @@ export class SubagentManager {
 		this.pendingReplies.delete(`${runId}:${taskId}`);
 		this.liveChildren.get(`${runId}:${taskId}`)?.abort();
 		this.mailboxes.close(`${runId}:${taskId}`);
-		if (ctx) this.flushWidget(run, ctx);
+		if (ctx) this.widget.flush(run, ctx);
 		this.emit("subagent:task-aborted", { runId, taskId });
 		return true;
 	}