pi-crew 0.1.45 → 0.1.49

package/src/ui/powerbar-publisher.ts

@@ -10,6 +10,7 @@ import { logInternalError } from "../utils/internal-error.ts";
 import type { ManifestCache } from "../runtime/manifest-cache.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
 import { notificationBadge } from "./crew-widget.ts";
+import { RenderCoalescer } from "./render-coalescer.ts";
 
 type EventBus = { emit?: (event: string, data: unknown) => void; listenerCount?: (event: string) => number } | undefined;
 type StatusContext = { hasUI?: boolean; ui?: { setStatus?: (key: string, text: string | undefined) => void } } | undefined;
@@ -84,6 +85,8 @@ export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: Cre
 		return { run, agents, tasks: readTasks(run.tasksPath), snapshot };
 	}).filter((item) => isDisplayActiveRun(item.run, item.agents));
 	if (!active.length) {
+		lastEmittedActive = undefined;
+		lastEmittedProgress = undefined;
 		safeEmit(events, "powerbar:update", { id: "pi-crew-active" });
 		safeEmit(events, "powerbar:update", { id: "pi-crew-progress" });
 		if (useStatusFallback) setStatusFallback(ctx, undefined);
@@ -104,25 +107,84 @@ export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: Cre
 	const activeText = `crew ${running}a/${waiting}w${notificationBadge(notificationCount)}`;
 	const activeSuffix = [model, tokenText].filter(Boolean).join(" · ") || undefined;
 	const progressSuffix = `${completed}/${total}${tokenText ? ` · ${tokenText}` : ""}`;
-	safeEmit(events, "powerbar:update", {
-		id: "pi-crew-active",
-		icon: "⚙",
-		text: activeText,
-		suffix: activeSuffix,
-		color: running ? "accent" : "warning",
-	});
-	safeEmit(events, "powerbar:update", {
-		id: "pi-crew-progress",
-		text: (active[0]?.run as TeamRunManifest)?.team ?? "crew",
-		bar: Math.round((completed / total) * 100),
-		suffix: progressSuffix,
-		color: completed === total ? "success" : "accent",
-		barSegments: 8,
-	});
+	const activeKey = `${activeText}|${activeSuffix ?? ""}|${running}`;
+	const progressKey = `${(active[0]?.run as TeamRunManifest)?.team ?? "crew"}|${completed}/${total}|${tokenText ?? ""}`;
+	const changed = activeKey !== lastEmittedActive || progressKey !== lastEmittedProgress;
+	if (changed) {
+		lastEmittedActive = activeKey;
+		lastEmittedProgress = progressKey;
+		safeEmit(events, "powerbar:update", {
+			id: "pi-crew-active",
+			icon: "⚙",
+			text: activeText,
+			suffix: activeSuffix,
+			color: running ? "accent" : "warning",
+		});
+		safeEmit(events, "powerbar:update", {
+			id: "pi-crew-progress",
+			text: (active[0]?.run as TeamRunManifest)?.team ?? "crew",
+			bar: Math.round((completed / total) * 100),
+			suffix: progressSuffix,
+			color: completed === total ? "success" : "accent",
+			barSegments: 8,
+		});
+	}
 	if (useStatusFallback) setStatusFallback(ctx, `${activeText}${activeSuffix ? ` · ${activeSuffix}` : ""} · ${progressSuffix}`);
 }
 
+// --- Dedup state: skip emit if segment data unchanged ---
+let lastEmittedActive: string | undefined;
+let lastEmittedProgress: string | undefined;
+
+// --- Coalesced powerbar update ---
+
+interface PowerbarUpdateArgs {
+	events: EventBus;
+	cwd: string;
+	config?: CrewUiConfig;
+	manifestCache?: ManifestCache;
+	snapshotCache?: RunSnapshotCache;
+	ctx?: StatusContext;
+	notificationCount: number;
+	preloadedManifests?: TeamRunManifest[];
+}
+
+let latestArgs: PowerbarUpdateArgs | null = null;
+
+const powerbarCoalescer = new RenderCoalescer(() => {
+	if (!latestArgs) return;
+	const a = latestArgs;
+	latestArgs = null;
+	updatePiCrewPowerbar(a.events, a.cwd, a.config, a.manifestCache, a.snapshotCache, a.ctx, a.notificationCount, a.preloadedManifests);
+}, 200);
+
+/**
+ * Request a coalesced powerbar update. Multiple rapid calls are batched into a single
+ * render pass within 200ms, preventing UI flicker from event bursts.
+ */
+export function requestPowerbarUpdate(
+	events: EventBus,
+	cwd: string,
+	config?: CrewUiConfig,
+	manifestCache?: ManifestCache,
+	snapshotCache?: RunSnapshotCache,
+	ctx?: StatusContext,
+	notificationCount = 0,
+	preloadedManifests?: TeamRunManifest[],
+): void {
+	if (config?.powerbar === false) return;
+	latestArgs = { events, cwd, config, manifestCache, snapshotCache, ctx, notificationCount, preloadedManifests };
+	powerbarCoalescer.request();
+}
+
+/** Dispose the powerbar coalescer. Call during extension cleanup. */
+export function disposePowerbarCoalescer(): void {
+	powerbarCoalescer.dispose();
+}
+
 export function clearPiCrewPowerbar(events: EventBus, ctx?: StatusContext): void {
+	lastEmittedActive = undefined;
+	lastEmittedProgress = undefined;
 	safeEmit(events, "powerbar:update", { id: "pi-crew-active" });
 	safeEmit(events, "powerbar:update", { id: "pi-crew-progress" });
 	setStatusFallback(ctx, undefined);

package/src/ui/render-coalescer.ts

@@ -0,0 +1,51 @@
+/**
+ * RenderCoalescer — batches multiple render requests into single render passes.
+ * Prevents UI flicker when many events arrive in quick succession.
+ * Inspired by oh-my-pi's PROGRESS_COALESCE_MS (150ms) pattern.
+ */
+export class RenderCoalescer {
+	#pending = false;
+	#timerId: ReturnType<typeof setTimeout> | null = null;
+	#callback: () => void;
+	#intervalMs: number;
+
+	constructor(callback: () => void, intervalMs = 32) {
+		this.#callback = callback;
+		this.#intervalMs = intervalMs;
+	}
+
+	/** Request a render. Will be coalesced with other requests within the interval. */
+	request(): void {
+		if (this.#pending) return;
+		this.#pending = true;
+		this.#timerId = setTimeout(() => {
+			this.#pending = false;
+			this.#timerId = null;
+			this.#callback();
+		}, this.#intervalMs);
+	}
+
+	/** Force an immediate render, bypassing coalescing. */
+	flush(): void {
+		if (this.#timerId !== null) {
+			clearTimeout(this.#timerId);
+			this.#timerId = null;
+		}
+		this.#pending = false;
+		this.#callback();
+	}
+
+	/** Check if a render is pending. */
+	get pending(): boolean {
+		return this.#pending;
+	}
+
+	/** Clean up timers. Call when the coalescer is no longer needed. */
+	dispose(): void {
+		if (this.#timerId !== null) {
+			clearTimeout(this.#timerId);
+			this.#timerId = null;
+		}
+		this.#pending = false;
+	}
+}

package/src/ui/run-dashboard.ts

@@ -24,6 +24,7 @@ import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
 import { spinnerBucket, spinnerFrame } from "./spinner.ts";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { runEventBus } from "./run-event-bus.ts";
 
 interface DashboardComponent {
 	invalidate(): void;
@@ -253,6 +254,7 @@ export class RunDashboard implements DashboardComponent {
 	private cachedVersion = "";
 	private cachedLines: string[] = [];
 	private readonly unsubscribeTheme: () => void;
+	private readonly unsubscribeEventBus: () => void;
 
 	constructor(
 		runs: TeamRunManifest[],
@@ -265,6 +267,7 @@ export class RunDashboard implements DashboardComponent {
 		this.theme = asCrewTheme(theme);
 		this.options = options;
 		this.unsubscribeTheme = subscribeThemeChange(theme, () => this.invalidate());
+		this.unsubscribeEventBus = runEventBus.onAny(() => this.invalidate());
 	}
 
 	private refreshRuns(): void {
@@ -301,6 +304,7 @@ export class RunDashboard implements DashboardComponent {
 
 	dispose(): void {
 		this.unsubscribeTheme();
+		this.unsubscribeEventBus();
 	}
 
 	private selectedRunId(): string | undefined {

package/src/ui/run-event-bus.ts

@@ -0,0 +1,209 @@
+import type { TeamEvent } from "../state/event-log.ts";
+
+export type RunEventType =
+	| "task_started"
+	| "task_completed"
+	| "task_failed"
+	| "task_cancelled"
+	| "worker_status"
+	| "mailbox_updated"
+	| "effectiveness_changed"
+	| "run_started"
+	| "run_completed"
+	| "run_blocked"
+	| "run_cancelled";
+
+/** Typed channel names for category-based event subscription. */
+export type EventChannel =
+	| "worker:progress"
+	| "worker:lifecycle"
+	| "worker:stream"
+	| "run:state"
+	| "ui:invalidate";
+
+/** Sets used by classifyEventChannel for O(1) lookup. */
+const WORKER_PROGRESS_TYPES = new Set([
+	"tool_execution_start", "tool_result", "agent_progress", "worker_status",
+]);
+const WORKER_LIFECYCLE_TYPES = new Set([
+	"task.started", "task.completed", "task.failed",
+	"task_started", "task_completed", "task_failed", "task_cancelled",
+	"run.started", "run.completed", "run.cancelled", "run.failed",
+	"run_started", "run_completed", "run_cancelled", "run_blocked",
+]);
+const WORKER_STREAM_TYPES = new Set([
+	"stdout_chunk", "stderr_chunk", "stream",
+]);
+const RUN_STATE_TYPES = new Set([
+	"manifest.saved", "task.claimed", "task.unclaimed", "mailbox_updated",
+]);
+const UI_INVALIDATE_TYPES = new Set([
+	"effectiveness_changed", "snapshot_stale",
+]);
+
+/** Classify an event type string into a typed channel. */
+export function classifyEventChannel(type: string): EventChannel {
+	if (WORKER_PROGRESS_TYPES.has(type)) return "worker:progress";
+	if (WORKER_LIFECYCLE_TYPES.has(type)) return "worker:lifecycle";
+	if (WORKER_STREAM_TYPES.has(type)) return "worker:stream";
+	if (RUN_STATE_TYPES.has(type)) return "run:state";
+	if (UI_INVALIDATE_TYPES.has(type)) return "ui:invalidate";
+	return "worker:progress"; // default fallback
+}
+
+export interface RunEventPayload {
+	type: RunEventType;
+	runId: string;
+	taskId?: string;
+	timestamp?: string;
+	data?: unknown;
+	channel?: EventChannel;
+}
+
+export type RunEventCallback = (event: RunEventPayload) => void;
+
+class RunEventBus {
+	#listeners = new Map<string, Set<RunEventCallback>>();
+	#globalListeners = new Set<RunEventCallback>();
+	#channelListeners = new Map<EventChannel, Set<RunEventCallback>>();
+	#channelRunListeners = new Map<string, Map<EventChannel, Set<RunEventCallback>>>();
+
+	on(runId: string, callback: RunEventCallback): () => void {
+		const listeners = this.#listeners.get(runId) ?? new Set();
+		listeners.add(callback);
+		this.#listeners.set(runId, listeners);
+		return () => { listeners.delete(callback); if (listeners.size === 0) this.#listeners.delete(runId); };
+	}
+
+	onAny(callback: RunEventCallback): () => void {
+		this.#globalListeners.add(callback);
+		return () => { this.#globalListeners.delete(callback); };
+	}
+
+	off(runId: string, callback: RunEventCallback): void {
+		const listeners = this.#listeners.get(runId);
+		if (listeners) {
+			listeners.delete(callback);
+			if (listeners.size === 0) this.#listeners.delete(runId);
+		}
+	}
+
+	/** Subscribe to all events on a specific channel. */
+	onChannel(channel: EventChannel, callback: RunEventCallback): () => void {
+		const listeners = this.#channelListeners.get(channel) ?? new Set();
+		listeners.add(callback);
+		this.#channelListeners.set(channel, listeners);
+		return () => {
+			listeners.delete(callback);
+			if (listeners.size === 0) this.#channelListeners.delete(channel);
+		};
+	}
+
+	/** Subscribe to events on a specific channel for a given runId. */
+	onChannelForRun(channel: EventChannel, runId: string, callback: RunEventCallback): () => void {
+		const runKey = `${channel}::${runId}`;
+		const runMap = this.#channelRunListeners.get(runKey) ?? new Map();
+		const listeners = runMap.get(channel) ?? new Set();
+		listeners.add(callback);
+		runMap.set(channel, listeners);
+		this.#channelRunListeners.set(runKey, runMap);
+		return () => {
+			listeners.delete(callback);
+			if (listeners.size === 0) runMap.delete(channel);
+			if (runMap.size === 0) this.#channelRunListeners.delete(runKey);
+		};
+	}
+
+	emit(event: RunEventPayload): void {
+		// Auto-classify channel if not already set.
+		// M2: Use local variable for routing, but also set on event
+		// for subscriber API contract (listeners read event.channel).
+		if (!event.channel) {
+			(event as { channel?: EventChannel }).channel = classifyEventChannel(event.type);
+		}
+		const channel = event.channel!;
+
+		// Existing: runId-specific listeners
+		const listeners = this.#listeners.get(event.runId);
+		if (listeners) {
+			for (const cb of listeners) {
+				try { cb(event); } catch { /* subscriber errors are non-fatal */ }
+			}
+		}
+
+		// Existing: global listeners
+		for (const cb of this.#globalListeners) {
+			try { cb(event); } catch { /* subscriber errors are non-fatal */ }
+		}
+
+		// New: channel listeners
+		const channelListeners = this.#channelListeners.get(channel);
+		if (channelListeners) {
+			for (const cb of channelListeners) {
+				try { cb(event); } catch { /* subscriber errors are non-fatal */ }
+			}
+		}
+
+		// New: channel+runId listeners
+		const runKey = `${channel}::${event.runId}`;
+		const runMap = this.#channelRunListeners.get(runKey);
+		if (runMap) {
+			const runChannelListeners = runMap.get(channel);
+			if (runChannelListeners) {
+				for (const cb of runChannelListeners) {
+					try { cb(event); } catch { /* subscriber errors are non-fatal */ }
+				}
+			}
+		}
+	}
+
+	/** Dispose all subscriptions including channel-based ones. */
+	dispose(): void {
+		this.#listeners.clear();
+		this.#globalListeners.clear();
+		this.#channelListeners.clear();
+		this.#channelRunListeners.clear();
+	}
+
+	listenerCount(runId?: string): number {
+		if (runId) return this.#listeners.get(runId)?.size ?? 0;
+		let total = this.#globalListeners.size;
+		for (const set of this.#listeners.values()) total += set.size;
+		for (const set of this.#channelListeners.values()) total += set.size;
+		for (const runMap of this.#channelRunListeners.values()) {
+			for (const set of runMap.values()) total += set.size;
+		}
+		return total;
+	}
+}
+
+/** Global singleton run event bus for UI-first event delivery. */
+export const runEventBus = new RunEventBus();
+
+/** Derive a RunEventType from a TeamEvent. */
+export function teamEventToRunEventType(event: TeamEvent): RunEventType | undefined {
+	const type = event.type;
+	if (type === "task.started") return "task_started";
+	if (type === "task.completed") return "task_completed";
+	if (type === "task.failed") return "task_failed";
+	if (type === "run.completed") return "run_completed";
+	if (type === "run.blocked") return "run_blocked";
+	if (type === "run.running") return "run_started";
+	if (type === "run.cancelled") return "run_cancelled";
+	if (type === "task.progress" || type === "mailbox.message_queued" || type === "mailbox.message_delivered") return "mailbox_updated";
+	if (type === "run.effectiveness" || type === "task.attention") return "effectiveness_changed";
+	return undefined;
+}
+
+/** Emit a run event from a TeamEvent. */
+export function emitFromTeamEvent(event: TeamEvent): void {
+	const type = teamEventToRunEventType(event);
+	if (!type) return;
+	runEventBus.emit({
+		type,
+		runId: event.runId,
+		taskId: event.taskId,
+		timestamp: event.time,
+		data: event.data,
+	});
+}

package/src/ui/run-snapshot-cache.ts

@@ -9,6 +9,7 @@ import type { MailboxMessageStatus } from "../state/mailbox.ts";
 import { loadRunManifestById, loadRunManifestByIdAsync } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import type { RunSnapshotCache as RunSnapshotCacheBase, RunUiGroupJoin, RunUiMailbox, RunUiProgress, RunUiSnapshot, RunUiUsage } from "./snapshot-types.ts";
+import { runEventBus } from "./run-event-bus.ts";
 
 export interface RunSnapshotCache extends RunSnapshotCacheBase {
 	preloadStale(runId: string): Promise<RunUiSnapshot | undefined>;
@@ -378,6 +379,13 @@ interface MailboxCount {
 	approximate: boolean;
 }
 
+interface MailboxKindCount extends MailboxCount {
+	steer: number;
+	followUp: number;
+	response: number;
+	message: number;
+}
+
 function tailApproximate(filePath: string): boolean {
 	try {
 		return fs.statSync(filePath).size > MAX_TAIL_BYTES;
@@ -394,34 +402,54 @@ async function tailApproximateAsync(filePath: string): Promise<boolean> {
 	}
 }
 
-function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMessageStatus>): MailboxCount {
+function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMessageStatus>): MailboxKindCount {
+	const kindCounts = { steer: 0, followUp: 0, response: 0, message: 0 };
 	const items = tailJsonlLines(filePath, MAX_TAIL_LINES, (line) => {
 		try {
 			const parsed = JSON.parse(line) as unknown;
 			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return 0;
-			const message = parsed as { id?: unknown; status?: unknown };
-			if (typeof message.id !== "string" || !isMailboxStatus(message.status)) return 0;
-			return message.status !== "acknowledged" && delivery[message.id] !== "acknowledged" ? 1 : 0;
+			const msg = parsed as { id?: unknown; status?: unknown; kind?: unknown; data?: unknown };
+			if (typeof msg.id !== "string" || !isMailboxStatus(msg.status)) return 0;
+			if (msg.status !== "acknowledged" && delivery[msg.id] !== "acknowledged") {
+				const kind = typeof msg.kind === "string" ? msg.kind : typeof (msg.data as Record<string, unknown>)?.kind === "string" ? (msg.data as Record<string, unknown>).kind as string : undefined;
+				if (kind === "steer") kindCounts.steer++;
+				else if (kind === "follow-up") kindCounts.followUp++;
+				else if (kind === "response") kindCounts.response++;
+				else kindCounts.message++;
+				return 1;
+			}
+			return 0;
 		} catch {
 			return 0;
 		}
 	}) as number[];
-	return { count: items.reduce((sum, val) => sum + val, 0), approximate: tailApproximate(filePath) };
+	const count = items.reduce((sum, val) => sum + val, 0);
+	return { count, approximate: tailApproximate(filePath), steer: kindCounts.steer, followUp: kindCounts.followUp, response: kindCounts.response, message: kindCounts.message };
 }
 
-async function readMailboxCountsAsync(filePath: string, delivery: Record<string, MailboxMessageStatus>): Promise<MailboxCount> {
+async function readMailboxCountsAsync(filePath: string, delivery: Record<string, MailboxMessageStatus>): Promise<MailboxKindCount> {
+	const kindCounts = { steer: 0, followUp: 0, response: 0, message: 0 };
 	const items = await tailJsonlLinesAsync(filePath, MAX_TAIL_LINES, (line) => {
 		try {
 			const parsed = JSON.parse(line) as unknown;
 			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return 0;
-			const message = parsed as { id?: unknown; status?: unknown };
-			if (typeof message.id !== "string" || !isMailboxStatus(message.status)) return 0;
-			return message.status !== "acknowledged" && delivery[message.id] !== "acknowledged" ? 1 : 0;
+			const msg = parsed as { id?: unknown; status?: unknown; kind?: unknown; data?: unknown };
+			if (typeof msg.id !== "string" || !isMailboxStatus(msg.status)) return 0;
+			if (msg.status !== "acknowledged" && delivery[msg.id] !== "acknowledged") {
+				const kind = typeof msg.kind === "string" ? msg.kind : typeof (msg.data as Record<string, unknown>)?.kind === "string" ? (msg.data as Record<string, unknown>).kind as string : undefined;
+				if (kind === "steer") kindCounts.steer++;
+				else if (kind === "follow-up") kindCounts.followUp++;
+				else if (kind === "response") kindCounts.response++;
+				else kindCounts.message++;
+				return 1;
+			}
+			return 0;
 		} catch {
 			return 0;
 		}
 	}) as number[];
-	return { count: items.reduce((sum, val) => sum + val, 0), approximate: await tailApproximateAsync(filePath) };
+	const count = items.reduce((sum, val) => sum + val, 0);
+	return { count, approximate: await tailApproximateAsync(filePath), steer: kindCounts.steer, followUp: kindCounts.followUp, response: kindCounts.response, message: kindCounts.message };
 }
 
 function groupJoinsFrom(manifest: TeamRunManifest): RunUiGroupJoin[] {
@@ -436,6 +464,17 @@ async function groupJoinsFromAsync(manifest: TeamRunManifest): Promise<RunUiGrou
 	return (await readGroupJoinMailboxAsync(path.join(root, "outbox.jsonl"), delivery)).slice(-5);
 }
 
+function mergeKindCounts(a: MailboxKindCount, b: MailboxKindCount): MailboxKindCount {
+	return {
+		count: a.count + b.count,
+		approximate: a.approximate || b.approximate,
+		steer: a.steer + b.steer,
+		followUp: a.followUp + b.followUp,
+		response: a.response + b.response,
+		message: a.message + b.message,
+	};
+}
+
 function mailboxFrom(manifest: TeamRunManifest, agents: CrewAgentRecord[]): RunUiMailbox {
 	const root = path.join(manifest.stateRoot, "mailbox");
 	const delivery = readDeliveryMessages(path.join(root, "delivery.json"));
@@ -447,14 +486,17 @@ function mailboxFrom(manifest: TeamRunManifest, agents: CrewAgentRecord[]): RunU
 			if (!entry.isDirectory()) continue;
 			const taskInbox = readMailboxCounts(path.join(tasksRoot, entry.name, "inbox.jsonl"), delivery);
 			const taskOutbox = readMailboxCounts(path.join(tasksRoot, entry.name, "outbox.jsonl"), delivery);
-			inbox = { count: inbox.count + taskInbox.count, approximate: inbox.approximate || taskInbox.approximate };
-			outbox = { count: outbox.count + taskOutbox.count, approximate: outbox.approximate || taskOutbox.approximate };
+			inbox = mergeKindCounts(inbox, taskInbox);
+			outbox = mergeKindCounts(outbox, taskOutbox);
 		}
 	} catch {
 		// No task mailboxes yet.
 	}
 	const attentionAgents = agents.filter((agent) => agent.progress?.activityState === "needs_attention").length;
-	return { inboxUnread: inbox.count, outboxPending: outbox.count, needsAttention: inbox.count + attentionAgents, approximate: inbox.approximate || outbox.approximate };
+	return {
+		inboxUnread: inbox.count, outboxPending: outbox.count, needsAttention: inbox.count + attentionAgents, approximate: inbox.approximate || outbox.approximate,
+		steerUnread: inbox.steer + outbox.steer, followUpUnread: inbox.followUp + outbox.followUp, responseUnread: inbox.response + outbox.response, messageUnread: inbox.message + outbox.message,
+	};
 }
 
 async function mailboxFromAsync(manifest: TeamRunManifest, agents: CrewAgentRecord[]): Promise<RunUiMailbox> {
@@ -468,14 +510,21 @@ async function mailboxFromAsync(manifest: TeamRunManifest, agents: CrewAgentReco
 			if (!entry.isDirectory()) continue;
 			const taskInbox = await readMailboxCountsAsync(path.join(tasksRoot, entry.name, "inbox.jsonl"), delivery);
 			const taskOutbox = await readMailboxCountsAsync(path.join(tasksRoot, entry.name, "outbox.jsonl"), delivery);
-			inbox = { count: inbox.count + taskInbox.count, approximate: inbox.approximate || taskInbox.approximate };
-			outbox = { count: outbox.count + taskOutbox.count, approximate: outbox.approximate || taskOutbox.approximate };
+			inbox = mergeKindCounts(inbox, taskInbox);
+			outbox = mergeKindCounts(outbox, taskOutbox);
 		}
 	} catch {
 		// No task mailboxes yet.
 	}
 	const attentionAgents = agents.filter((agent) => agent.progress?.activityState === "needs_attention").length;
-	return { inboxUnread: inbox.count, outboxPending: outbox.count, needsAttention: inbox.count + attentionAgents, approximate: inbox.approximate || outbox.approximate };
+	return {
+		inboxUnread: inbox.count, outboxPending: outbox.count, needsAttention: inbox.count + attentionAgents, approximate: inbox.approximate || outbox.approximate,
+		steerUnread: inbox.steer + outbox.steer, followUpUnread: inbox.followUp + outbox.followUp, responseUnread: inbox.response + outbox.response, messageUnread: inbox.message + outbox.message,
+	};
+}
+
+function cancellationReasonFromEvents(events: TeamEvent[]): string | undefined {
+	return [...events].reverse().find((event) => event.type === "run.cancelled" && typeof event.data?.reason === "string")?.data?.reason as string | undefined;
 }
 
 function signatureFor(input: Omit<RunUiSnapshot, "signature" | "fetchedAt">, stamps: SnapshotStamps): string {
@@ -489,7 +538,8 @@ function signatureFor(input: Omit<RunUiSnapshot, "signature" | "fetchedAt">, sta
 		usage: input.usage,
 		mailbox: input.mailbox,
 		groupJoins: input.groupJoins,
-		events: input.recentEvents.map((event) => [event.metadata?.seq, event.time, event.type, event.taskId, event.message]),
+		events: input.recentEvents.map((event) => [event.metadata?.seq, event.time, event.type, event.taskId, event.message, event.data?.reason]),
+		cancellationReason: input.cancellationReason,
 		output: input.recentOutputLines,
 		stamps,
 	}));
@@ -571,6 +621,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		}
 		const mailbox = mailboxFrom(loaded.manifest, agents);
 		const groupJoins = groupJoinsFrom(loaded.manifest);
+		const recentEvents = safeRecentEvents(loaded.manifest.eventsPath, recentEventsLimit);
 		const base = {
 			runId: loaded.manifest.runId,
 			cwd: loaded.manifest.cwd,
@@ -581,7 +632,8 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			usage: usageFrom(tasks, agents),
 			mailbox,
 			groupJoins,
-			recentEvents: safeRecentEvents(loaded.manifest.eventsPath, recentEventsLimit),
+			cancellationReason: cancellationReasonFromEvents(recentEvents),
+			recentEvents,
 			recentOutputLines: recentOutputLines(loaded.manifest, agents, recentOutputLimit),
 		};
 		const stamps = stampsFor(loaded.manifest, agents);
@@ -626,6 +678,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			usage: usageFrom(tasks, agents),
 			mailbox,
 			groupJoins,
+			cancellationReason: cancellationReasonFromEvents(recentEvents),
 			recentEvents,
 			recentOutputLines: recentOutput,
 		};
@@ -680,6 +733,12 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		}
 	}
 
+	const unsubscribe = runEventBus.onAny((event) => {
+		if (entries.has(event.runId)) {
+			entries.delete(event.runId);
+		}
+	});
+
 	return {
 		get(runId: string): RunUiSnapshot | undefined {
 			const entry = entries.get(runId);
@@ -711,6 +770,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			return new Map([...entries.entries()].map(([key, entry]) => [key, entry.snapshot]));
 		},
 		dispose(): void {
+			unsubscribe();
 			entries.clear();
 		},
 	};

package/src/ui/snapshot-types.ts

@@ -23,6 +23,14 @@ export interface RunUiMailbox {
 	inboxUnread: number;
 	outboxPending: number;
 	needsAttention: number;
+	/** Urgent steering messages count. Default 0. */
+	steerUnread?: number;
+	/** Follow-up / continuation messages count. Default 0. */
+	followUpUnread?: number;
+	/** Response / reply messages count. Default 0. */
+	responseUnread?: number;
+	/** Generic messages count. Default 0. */
+	messageUnread?: number;
 	/** True when counts come from bounded tail reads and older messages may be omitted. */
 	approximate?: boolean;
 }
@@ -46,6 +54,8 @@ export interface RunUiSnapshot {
 	usage: RunUiUsage;
 	mailbox: RunUiMailbox;
 	groupJoins?: RunUiGroupJoin[];
+	/** Structured cancellation reason from run.cancelled event data, when available. */
+	cancellationReason?: string;
 	recentEvents: TeamEvent[];
 	recentOutputLines: string[];
 }