pi-crew 0.1.45 → 0.1.49

package/src/state/state-store.ts

@@ -27,12 +27,15 @@ interface ManifestCacheEntry {
 	manifestSize: number;
 	tasksMtimeMs: number;
 	tasksSize: number;
+	cachedAt?: number;
 }
 
+const MANIFEST_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
 const manifestCache = new Map<string, ManifestCacheEntry>();
 
 function setManifestCache(stateRoot: string, entry: ManifestCacheEntry): void {
 	if (manifestCache.has(stateRoot)) manifestCache.delete(stateRoot);
+	entry.cachedAt = Date.now();
 	manifestCache.set(stateRoot, entry);
 	while (manifestCache.size > DEFAULT_CACHE.manifestMaxEntries) {
 		const oldest = manifestCache.keys().next().value;
@@ -196,7 +199,21 @@ export async function saveRunTasksAsync(manifest: TeamRunManifest, tasks: TeamTa
 	invalidateRunCache(manifest.stateRoot);
 }
 
-export function updateRunStatus(manifest: TeamRunManifest, status: TeamRunManifest["status"], summary?: string): TeamRunManifest {
+/** M8: Atomically save manifest + tasks and invalidate cache once to prevent stale reads between saves */
+export async function saveManifestAndTasksAtomic(manifest: TeamRunManifest, tasks: TeamTaskState[]): Promise<void> {
+	await Promise.all([
+		atomicWriteJsonAsync(path.join(manifest.stateRoot, "manifest.json"), manifest),
+		atomicWriteJsonAsync(manifest.tasksPath, tasks),
+	]);
+	invalidateRunCache(manifest.stateRoot);
+}
+
+export interface UpdateRunStatusOptions {
+	data?: Record<string, unknown>;
+	metadata?: Parameters<typeof appendEvent>[1]["metadata"];
+}
+
+export function updateRunStatus(manifest: TeamRunManifest, status: TeamRunManifest["status"], summary?: string, options: UpdateRunStatusOptions = {}): TeamRunManifest {
 	if (!canTransitionRunStatus(manifest.status, status)) {
 		throw new Error(`Invalid run status transition: ${manifest.status} -> ${status}`);
 	}
@@ -206,11 +223,13 @@ export function updateRunStatus(manifest: TeamRunManifest, status: TeamRunManife
 		type: `run.${status}`,
 		runId: updated.runId,
 		message: summary,
+		...(options.data ? { data: options.data } : {}),
 		metadata: {
 			provenance: "team_runner",
 			sessionIdentity: { title: updated.team, workspace: updated.cwd, purpose: updated.goal },
 			ownership: { owner: updated.team, workflowScope: updated.workflow ?? "manual", watcherAction: "act" },
 			confidence: "high",
+			...options.metadata,
 		},
 	});
 	return updated;
@@ -259,11 +278,15 @@ export function loadRunManifestById(cwd: string, runId: string): { manifest: Tea
 		&& cached.tasksMtimeMs === tasksMtimeMs
 		&& cached.tasksSize === (tasksStat?.size ?? 0)
 	) {
-		if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
+		// TTL eviction: expire stale entries even if mtime matches
+		if (cached.cachedAt && Date.now() - cached.cachedAt > MANIFEST_CACHE_TTL_MS) {
+			manifestCache.delete(stateRoot);
+		} else if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
 			manifestCache.delete(stateRoot);
 			return undefined;
+		} else {
+			return { manifest: cached.manifest, tasks: cached.tasks };
 		}
-		return { manifest: cached.manifest, tasks: cached.tasks };
 	}
 
 	const manifest = readJsonFile<TeamRunManifest>(manifestPath);
@@ -300,11 +323,15 @@ export async function loadRunManifestByIdAsync(cwd: string, runId: string): Prom
 	}
 	const tasksMtimeMs = tasksStat?.mtimeMs ?? 0;
 	if (cached && cached.manifestMtimeMs === manifestStat.mtimeMs && cached.manifestSize === manifestStat.size && cached.tasksMtimeMs === tasksMtimeMs && cached.tasksSize === (tasksStat?.size ?? 0)) {
-		if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
+		// TTL eviction: expire stale entries even if mtime matches
+		if (cached.cachedAt && Date.now() - cached.cachedAt > MANIFEST_CACHE_TTL_MS) {
+			manifestCache.delete(stateRoot);
+		} else if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
 			manifestCache.delete(stateRoot);
 			return undefined;
+		} else {
+			return { manifest: cached.manifest, tasks: cached.tasks };
 		}
-		return { manifest: cached.manifest, tasks: cached.tasks };
 	}
 	const manifest = await readJsonFileAsync<TeamRunManifest>(manifestPath);
 	if (!manifest || !validateRunManifestPaths(cwd, runId, manifest, stateRoot, tasksPath)) return undefined;

package/src/state/types.ts

@@ -39,6 +39,17 @@ export interface VerificationEvidence {
 	notes?: string;
 }
 
+export interface TaskOutputSchema {
+	/** Output format expected from the worker */
+	format: "json" | "markdown" | "text";
+	/** JTD or JSON Schema for validating JSON output (only when format="json") */
+	schema?: Record<string, unknown>;
+	/** Human-readable description of expected output */
+	description?: string;
+	/** Example of valid output (for prompt guidance) */
+	example?: string;
+}
+
 export interface TaskPacket {
 	objective: string;
 	scope: TaskScope;
@@ -53,10 +64,11 @@ export interface TaskPacket {
 	constraints: string[];
 	expectedArtifacts: string[];
 	verification: VerificationContract;
+	outputSchema?: TaskOutputSchema;
 }
 
-export type PolicyDecisionAction = "retry" | "reassign" | "escalate" | "block" | "notify" | "cleanup" | "closeout";
-export type PolicyDecisionReason = "task_failed" | "worker_stale" | "green_unsatisfied" | "limit_exceeded" | "run_complete" | "mailbox_timeout" | "review_rejected" | "branch_stale" | "scope_mismatch";
+export type PolicyDecisionAction = "retry" | "reassign" | "escalate" | "block" | "notify" | "cleanup" | "closeout" | "fail";
+export type PolicyDecisionReason = "task_failed" | "worker_stale" | "green_unsatisfied" | "limit_exceeded" | "run_complete" | "mailbox_timeout" | "review_rejected" | "branch_stale" | "scope_mismatch" | "ineffective_worker";
 
 export interface PolicyDecision {
 	action: PolicyDecisionAction;
@@ -81,6 +93,39 @@ export interface AsyncRunState {
 	spawnedAt: string;
 }
 
+export interface RuntimeResolutionState {
+	kind: "scaffold" | "child-process" | "live-session";
+	requestedMode: "auto" | "scaffold" | "child-process" | "live-session";
+	safety: "trusted" | "explicit_dry_run" | "blocked";
+	available: boolean;
+	fallback?: "scaffold" | "child-process" | "live-session";
+	reason?: string;
+	resolvedAt: string;
+}
+
+export interface WorkerExitStatus {
+	exitCode: number | null;
+	cancelled: boolean;
+	timedOut: boolean;
+	killed: boolean;
+	signal?: string;
+	cleanupErrors: string[];
+	finalDrainMs: number;
+}
+
+export interface OperationTerminalEvidence {
+	operation: "worker" | "tool" | "model";
+	status: "cancelled" | "failed" | "completed";
+	startedAt?: string;
+	finishedAt: string;
+	attemptId?: string;
+	reason?: {
+		code: string;
+		message: string;
+	};
+	exitStatus?: WorkerExitStatus;
+}
+
 export interface PlanApprovalState {
 	required: boolean;
 	status: "pending" | "approved" | "cancelled";
@@ -125,6 +170,12 @@ export interface TeamRunManifest {
 	planApproval?: PlanApprovalState;
 	/** Pi session that created the run, when available. Used to prevent cross-session destructive actions. */
 	ownerSessionId?: string;
+	/** pi-crew skill override selected when the run was created. false disables injected skill instructions. */
+	skillOverride?: string[] | false;
+	/** Resolved runtime/safety mode used for execution. Optional for backward compatibility with older manifests. */
+	runtimeResolution?: RuntimeResolutionState;
+	/** Effective run config snapshot used by async background workers. Optional for backward compatibility. */
+	runConfig?: unknown;
 	summary?: string;
 	policyDecisions?: PolicyDecision[];
 }
@@ -166,6 +217,7 @@ export interface TaskCheckpointState {
 }
 
 export interface TaskAttemptState {
+	attemptId?: string;
 	startedAt: string;
 	endedAt?: string;
 	error?: string;
@@ -178,6 +230,7 @@ export interface TeamTaskState {
 	role: string;
 	agent: string;
 	title: string;
+	displayName?: string;
 	status: TeamTaskStatus;
 	dependsOn: string[];
 	cwd: string;
@@ -200,6 +253,8 @@ export interface TeamTaskState {
 	heartbeat?: WorkerHeartbeatState;
 	checkpoint?: TaskCheckpointState;
 	attempts?: TaskAttemptState[];
+	workerExitStatus?: WorkerExitStatus;
+	terminalEvidence?: OperationTerminalEvidence[];
 	taskPacket?: TaskPacket;
 	verification?: VerificationEvidence;
 	graph?: TaskGraphNode;
@@ -211,4 +266,11 @@ export interface TeamTaskState {
 		retryCount?: number;
 		lastDecision?: PolicyDecision;
 	};
+	controlReservation?: ControlReservation;
+}
+
+export interface ControlReservation {
+	reservedAt: string;
+	controllerId: string;
+	acceptsControlEvents: boolean;
 }

package/src/teams/team-config.ts

@@ -5,6 +5,7 @@ export interface TeamRole {
 	agent: string;
 	description?: string;
 	model?: string;
+	/** Additional skills for this role; false disables role-default injected skills for tasks using this role. */
 	skills?: string[] | false;
 	maxConcurrency?: number;
 }

package/src/ui/agent-management-overlay.ts

@@ -0,0 +1,144 @@
+/**
+ * Agent Management Overlay — displays discovered agents with their configuration.
+ * Read-only view of agent definitions from builtin/user/project sources.
+ * Future: enable/disable toggle, model override editing.
+ */
+import type { AgentConfig, ResourceSource } from "../agents/agent-config.ts";
+import { truncate } from "../utils/visual.ts";
+
+export interface AgentEntry {
+	name: string;
+	description: string;
+	source: ResourceSource;
+	model?: string;
+	thinking?: string;
+	loadMode?: string;
+	contextMode?: string;
+	disabled?: boolean;
+	filePath: string;
+}
+
+export function agentToEntry(agent: AgentConfig): AgentEntry {
+	return {
+		name: agent.name,
+		description: agent.description,
+		source: agent.source,
+		model: agent.model,
+		thinking: agent.thinking,
+		loadMode: agent.loadMode,
+		contextMode: agent.contextMode,
+		disabled: agent.disabled,
+		filePath: agent.filePath,
+	};
+}
+
+function sourceIcon(source: ResourceSource): string {
+	switch (source) {
+		case "builtin": return "📦";
+		case "user": return "👤";
+		case "project": return "📂";
+		case "git": return "🔗";
+	}
+}
+
+function sourceLabel(source: ResourceSource): string {
+	switch (source) {
+		case "builtin": return "builtin";
+		case "user": return "user";
+		case "project": return "project";
+		case "git": return "git";
+	}
+}
+
+export interface AgentOverlayState {
+	entries: AgentEntry[];
+	selectedIndex: number;
+	scrollOffset: number;
+	expanded: Set<number>;
+	maxVisible: number;
+}
+
+export function createAgentOverlayState(entries: AgentEntry[], maxVisible = 20): AgentOverlayState {
+	return {
+		entries: entries.sort((a, b) => {
+			const order: Record<ResourceSource, number> = { project: 0, user: 1, git: 2, builtin: 3 };
+			const diff = (order[a.source] ?? 4) - (order[b.source] ?? 4);
+			return diff !== 0 ? diff : a.name.localeCompare(b.name);
+		}),
+		selectedIndex: 0,
+		scrollOffset: 0,
+		expanded: new Set(),
+		maxVisible,
+	};
+}
+
+export function moveSelection(state: AgentOverlayState, direction: -1 | 1): AgentOverlayState {
+	const next = Math.max(0, Math.min(state.entries.length - 1, state.selectedIndex + direction));
+	const visibleStart = state.scrollOffset;
+	const visibleEnd = state.scrollOffset + state.maxVisible;
+	const newScroll = next < visibleStart
+		? next
+		: next >= visibleEnd
+			? Math.max(0, next - state.maxVisible + 1)
+			: state.scrollOffset;
+	return { ...state, selectedIndex: next, scrollOffset: newScroll };
+}
+
+export function toggleExpand(state: AgentOverlayState): AgentOverlayState {
+	const expanded = new Set(state.expanded);
+	if (expanded.has(state.selectedIndex)) {
+		expanded.delete(state.selectedIndex);
+	} else {
+		expanded.add(state.selectedIndex);
+	}
+	return { ...state, expanded };
+}
+
+export function renderAgentOverlay(state: AgentOverlayState, width: number): string[] {
+	const lines: string[] = [];
+	const header = ` Agent Configuration (${state.entries.length} agents)`;
+	lines.push(truncate(header, width));
+	lines.push(truncate("─".repeat(Math.min(width, 60)), width));
+
+	if (state.entries.length === 0) {
+		lines.push(truncate(" No agents discovered.", width));
+		return lines;
+	}
+
+	const visible = state.entries.slice(
+		state.scrollOffset,
+		state.scrollOffset + state.maxVisible,
+	);
+
+	for (const [i, entry] of visible.entries()) {
+		const globalIndex = state.scrollOffset + i;
+		const isSelected = globalIndex === state.selectedIndex;
+		const isExpanded = state.expanded.has(globalIndex);
+		const cursor = isSelected ? "▸" : " ";
+	const disabled = entry.disabled ? " [disabled]" : "";
+	const model = entry.model ? ` (${entry.model})` : "";
+
+	const summary = `${cursor} ${sourceIcon(entry.source)} ${entry.name}${model}${disabled}`;
+	lines.push(truncate(summary, width));
+
+	if (isExpanded) {
+		const desc = `    ${entry.description}`;
+		lines.push(truncate(desc, width));
+		const meta: string[] = [`    source: ${sourceLabel(entry.source)}`];
+		if (entry.model) meta.push(`model: ${entry.model}`);
+		if (entry.thinking) meta.push(`thinking: ${entry.thinking}`);
+		if (entry.loadMode) meta.push(`loadMode: ${entry.loadMode}`);
+		if (entry.contextMode) meta.push(`context: ${entry.contextMode}`);
+		meta.push(`file: ${entry.filePath}`);
+		lines.push(truncate(meta.join(" · "), width));
+		lines.push(truncate("─".repeat(Math.min(width - 4, 50)), width));
+	}
+	}
+
+	if (state.scrollOffset + state.maxVisible < state.entries.length) {
+		const remaining = state.entries.length - state.scrollOffset - state.maxVisible;
+		lines.push(truncate(`  … +${remaining} more`, width));
+	}
+
+	return lines;
+}

package/src/ui/crew-widget.ts

@@ -13,6 +13,8 @@ import { asCrewTheme, subscribeThemeChange } from "./theme-adapter.ts";
 import { Box, Text } from "./layout-primitives.ts";
 import { requestRender, setExtensionWidget } from "./pi-ui-compat.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
+import { runEventBus } from "./run-event-bus.ts";
+import { DEFAULT_UI } from "../config/defaults.ts";
 
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 const TOOL_LABELS: Record<string, string> = {
@@ -28,7 +30,7 @@ const LEGACY_WIDGET_KEY = "pi-crew";
 const WIDGET_KEY = "pi-crew-active";
 const STATUS_KEY = "pi-crew";
 
-const MAX_LINES_DEFAULT = 10;
+const MAX_LINES_DEFAULT = DEFAULT_UI.widgetMaxLines;
 const MAX_AGENTS_DISPLAY = 3;
 
 type WidgetComponent = { render(width: number): string[]; invalidate(): void };
@@ -77,7 +79,11 @@ function agentActivity(agent: CrewAgentRecord): string {
 	if (recent) return recent.replace(/\s+/g, " ").trim();
 	if (agent.progress?.activityState === "needs_attention") return "needs attention";
 	if (agent.status === "queued") return "queued";
-	if (agent.status === "running") return "thinking…";
+	if (agent.status === "running") {
+		const age = agent.startedAt ? Date.now() - new Date(agent.startedAt).getTime() : Infinity;
+		if (age < 5000 && !agent.progress?.currentTool) return "spawning…";
+		return "thinking…";
+	}
 	if (agent.status === "failed") return agent.error ?? "failed";
 	return "done";
 }
@@ -218,6 +224,7 @@ class CrewWidgetComponent implements WidgetComponent {
 	private cachedBaseLines: string[] = [];
 	private cachedTheme: CrewTheme;
 	private readonly unsubscribeTheme: () => void;
+	private readonly unsubscribeEventBus: () => void;
 
 	constructor(model: CrewWidgetModel, themeLike: unknown) {
 		this.model = model;
@@ -225,6 +232,7 @@ class CrewWidgetComponent implements WidgetComponent {
 		this.cachedTheme = this.theme;
 		this.cacheSignature = "";
 		this.unsubscribeTheme = subscribeThemeChange(themeLike, () => this.invalidate());
+		this.unsubscribeEventBus = runEventBus.onAny(() => this.invalidate());
 	}
 
 	private buildSignature(runs: WidgetRun[]): string {
@@ -249,6 +257,7 @@ class CrewWidgetComponent implements WidgetComponent {
 
 	dispose(): void {
 		this.unsubscribeTheme();
+		this.unsubscribeEventBus();
 	}
 
 	render(width: number): string[] {
@@ -273,7 +282,8 @@ class CrewWidgetComponent implements WidgetComponent {
 		// Update only spinner and command icon on header line to avoid full re-color for every frame.
 		const updatedHeader = `${runningGlyph}${this.cachedBaseLines[0]?.slice(1) ?? ""}`;
 		this.cachedLines[0] = truncate(colorWidgetLine(updatedHeader, 0, this.theme), width);
-		return this.cachedLines;
+		// Safety: ensure all lines fit within terminal width (handles emoji/CJK width mismatch)
+		return this.cachedLines.map((line) => truncate(line, width));
 	}
 }
 
@@ -290,7 +300,7 @@ export function updateCrewWidget(
 	const maxLines = config?.widgetMaxLines ?? MAX_LINES_DEFAULT;
 	const runs = activeWidgetRuns(ctx.cwd, manifestCache, snapshotCache, preloadedManifests);
 	const lines = buildCrewWidgetLines(ctx.cwd, state.frame, maxLines, runs, state.notificationCount ?? 0);
-	const placement = config?.widgetPlacement ?? "aboveEditor";
+	const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
 	ctx.ui.setStatus(STATUS_KEY, lines.length ? statusSummary(runs) : undefined);
 	const shouldClearLegacy = state.legacyCleared !== true || state.lastPlacement !== placement;
 	if (shouldClearLegacy) {
@@ -341,7 +351,7 @@ export function stopCrewWidget(ctx: Pick<ExtensionContext, "hasUI" | "ui"> | und
 	if (state.interval) clearInterval(state.interval);
 	state.interval = undefined;
 	if (ctx?.hasUI) {
-		const placement = config?.widgetPlacement ?? "aboveEditor";
+		const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 		setExtensionWidget(ctx, LEGACY_WIDGET_KEY, undefined, { placement });
 		setExtensionWidget(ctx, WIDGET_KEY, undefined, { placement });

package/src/ui/dashboard-panes/cancellation-pane.ts

@@ -0,0 +1,43 @@
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+
+export interface CancellationPaneOptions {
+	maxReasons?: number;
+}
+
+export function renderCancellationPane(manifest: TeamRunManifest, tasks: TeamTaskState[], opts: CancellationPaneOptions = {}): string[] {
+	const maxReasons = opts.maxReasons ?? 5;
+	if (manifest.status !== "cancelled" && manifest.status !== "blocked") {
+		const cancellingTasks = tasks.filter((t) => t.status === "cancelled");
+		if (cancellingTasks.length === 0) return ["Cancellation pane: no active cancellations"];
+	}
+
+	const lines: string[] = ["Cancellation pane"];
+
+	if (manifest.status === "cancelled") {
+		lines.push(`  Run status: cancelled`);
+	} else if (manifest.status === "blocked") {
+		lines.push(`  Run status: blocked`);
+	}
+
+	const cancelledTasks = tasks.filter((t) => t.status === "cancelled");
+	if (cancelledTasks.length > 0) {
+		lines.push(`  Cancelled tasks (${cancelledTasks.length}):`);
+		for (const task of cancelledTasks.slice(0, maxReasons)) {
+			const reason = task.error ?? "unknown";
+			lines.push(`    ✗ ${task.id}: ${reason}`);
+		}
+		if (cancelledTasks.length > maxReasons) {
+			lines.push(`    ... and ${cancelledTasks.length - maxReasons} more`);
+		}
+	}
+
+	if (manifest.policyDecisions?.length) {
+		const decisions = manifest.policyDecisions.slice(0, maxReasons);
+		lines.push(`  Policy decisions (${manifest.policyDecisions.length}):`);
+		for (const d of decisions) {
+			lines.push(`    ${d.action}: ${d.message}`);
+		}
+	}
+
+	return lines;
+}

package/src/ui/dashboard-panes/capability-pane.ts

@@ -0,0 +1,60 @@
+import { buildCapabilityInventory } from "../../runtime/capability-inventory.ts";
+import type { PiTeamsConfig } from "../../config/config.ts";
+import type { CapabilityItem } from "../../runtime/capability-inventory.ts";
+
+export interface CapabilityPaneOptions {
+	config?: PiTeamsConfig;
+	filter?: string;
+}
+
+function kindIcon(kind: string): string {
+	switch (kind) {
+		case "team": return "👥";
+		case "workflow": return "📋";
+		case "agent": return "🤖";
+		case "skill": return "🔧";
+		case "tool": return "🛠";
+		case "runtime": return "⚙";
+		default: return "•";
+	}
+}
+
+function stateLabel(state: string): string {
+	switch (state) {
+		case "active": return "";
+		case "disabled": return " [DISABLED]";
+		case "shadowed": return " [SHADOWED]";
+		case "missing": return " [MISSING]";
+		default: return "";
+	}
+}
+
+export function renderCapabilityPane(cwd: string, opts: CapabilityPaneOptions = {}): string[] {
+	const inventory = buildCapabilityInventory(cwd, opts.config);
+	const filtered = opts.filter
+		? inventory.filter((item) => item.kind.includes(opts.filter!.toLowerCase()) || item.name.toLowerCase().includes(opts.filter!.toLowerCase()) || item.id.toLowerCase().includes(opts.filter!.toLowerCase()))
+		: inventory;
+
+	if (filtered.length === 0) return ["Capability pane: no items found"];
+
+	const byKind = new Map<string, CapabilityItem[]>();
+	for (const item of filtered) {
+		const group = byKind.get(item.kind) ?? [];
+		group.push(item);
+		byKind.set(item.kind, group);
+	}
+
+	const lines = [`Capability pane: ${filtered.length} item(s) (filter: ${opts.filter ?? "none"})`];
+	for (const [kind, items] of byKind) {
+		lines.push(`  ${kindIcon(kind)} ${kind} (${items.length}):`);
+		for (const item of items.slice(0, 10)) {
+			const icon = item.state === "active" ? "✓" : "✗";
+			lines.push(`    ${icon} ${item.name}${stateLabel(item.state)} [${item.source}]`);
+		}
+		if (items.length > 10) lines.push(`    ... and ${items.length - 10} more`);
+	}
+
+	const disabled = filtered.filter((i) => i.state === "disabled").length;
+	if (disabled > 0) lines.push(`  Disabled: ${disabled}`);
+	return lines;
+}

package/src/ui/dashboard-panes/mailbox-pane.ts

@@ -1,11 +1,35 @@
-import type { RunUiSnapshot } from "../snapshot-types.ts";
-
-export function renderMailboxPane(snapshot: RunUiSnapshot | undefined): string[] {
-	if (!snapshot) return ["Mailbox pane: snapshot unavailable"];
-	const mailbox = snapshot.mailbox;
-	const approx = mailbox.approximate ? " · approximate (tail)" : "";
-	return [
-		`Mailbox pane: inbox unread=${mailbox.inboxUnread} · outbox pending=${mailbox.outboxPending} · attention=${mailbox.needsAttention}${approx}`,
-		mailbox.needsAttention > 0 ? "Needs attention: press Enter for detail · A ack · N nudge · C compose · X ack all." : "No mailbox items need attention. Press Enter for detail or C compose.",
-	];
-}
+import type { RunUiSnapshot } from "../snapshot-types.ts";
+
+export function renderMailboxPane(snapshot: RunUiSnapshot | undefined): string[] {
+	if (!snapshot) return ["Mailbox pane: snapshot unavailable"];
+	const mailbox = snapshot.mailbox;
+	const approx = mailbox.approximate ? " · approximate (tail)" : "";
+	const lines: string[] = [
+		`Mailbox pane: inbox unread=${mailbox.inboxUnread} · outbox pending=${mailbox.outboxPending} · attention=${mailbox.needsAttention}${approx}`,
+	];
+	// Kind-separated breakdown
+	const kindParts: string[] = [];
+	const steer = mailbox.steerUnread ?? 0;
+	const followUp = mailbox.followUpUnread ?? 0;
+	const response = mailbox.responseUnread ?? 0;
+	const message = mailbox.messageUnread ?? 0;
+	if (steer > 0) kindParts.push(`steer=${steer}`);
+	if (followUp > 0) kindParts.push(`follow-up=${followUp}`);
+	if (response > 0) kindParts.push(`response=${response}`);
+	if (message > 0) kindParts.push(`message=${message}`);
+	if (kindParts.length > 0) {
+		lines.push(`  Breakdown: ${kindParts.join(" · ")}`);
+		if (steer > 0) {
+			lines.push("  ⚠ Urgent: steering messages require immediate attention.");
+		}
+		if (followUp > 0) {
+			lines.push(`  📋 ${followUp} follow-up(s) pending review.`);
+		}
+	}
+	if (mailbox.needsAttention > 0) {
+		lines.push("Needs attention: press Enter for detail · A ack · N nudge · C compose · X ack all.");
+	} else {
+		lines.push("No mailbox items need attention. Press Enter for detail or C compose.");
+	}
+	return lines;
+}

package/src/ui/dashboard-panes/progress-pane.ts

@@ -5,8 +5,10 @@ export function renderProgressPane(snapshot: RunUiSnapshot | undefined): string[
 	const progress = snapshot.progress;
 	const groupJoins = snapshot.groupJoins ?? [];
 	const groupJoinLines = groupJoins.length ? groupJoins.map((item) => `group join ${item.partial ? "partial" : "completed"}: ${item.requestId} ack=${item.ack}`) : ["group joins: none"];
+	const cancellationLine = snapshot.cancellationReason ? [`cancelled: reason=${snapshot.cancellationReason}`] : [];
 	return [
 		`Progress pane: ${progress.completed}/${progress.total} completed · running=${progress.running} queued=${progress.queued} failed=${progress.failed}`,
+		...cancellationLine,
 		...groupJoinLines,
 		...snapshot.recentEvents.slice(-10).map((event) => {
 			const seq = event.metadata?.seq !== undefined ? `#${event.metadata.seq}` : "#?";

package/src/ui/live-run-sidebar.ts

@@ -14,6 +14,7 @@ import { asCrewTheme, subscribeThemeChange } from "./theme-adapter.ts";
 import { Box, Text } from "./layout-primitives.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
 import { spinnerBucket, spinnerFrame } from "./spinner.ts";
+import { runEventBus } from "./run-event-bus.ts";
 
 const TASK_READ_TTL_MS = 200;
 
@@ -59,6 +60,7 @@ export class LiveRunSidebar {
 	private readonly theme: CrewTheme;
 	private readonly config: CrewUiConfig;
 	private readonly unsubscribeTheme: () => void;
+	private readonly unsubscribeEventBus: () => void;
 	private readonly snapshotCache?: RunSnapshotCache;
 	private cachedLines: string[] = [];
 	private cachedWidth = 0;
@@ -72,6 +74,7 @@ export class LiveRunSidebar {
 		this.config = input.config ?? {};
 		this.snapshotCache = input.snapshotCache;
 		this.unsubscribeTheme = subscribeThemeChange(input.theme, () => this.invalidate());
+		this.unsubscribeEventBus = runEventBus.onAny(() => this.invalidate());
 	}
 
 	private buildSignature(manifestStatus: string, tasks: TeamTaskState[], agents: ReturnType<typeof readCrewAgents>, waitingCount: number, snapshot?: RunUiSnapshot): string {
@@ -99,6 +102,7 @@ export class LiveRunSidebar {
 
 	dispose(): void {
 		this.unsubscribeTheme();
+		this.unsubscribeEventBus();
 	}
 
 	render(width: number): string[] {