pi-crew 0.10.1 → 0.10.3

package/src/ui/inline-panel/panel-store.ts

@@ -0,0 +1,111 @@
+/**
+ * panel-store.ts — process-wide state shared by the inline panel's two halves.
+ *
+ * The editor wrapper mutates the cursor; the widget renderer and the transcript
+ * pane read it. Neither can own the state (the editor is created by pi's
+ * factory, the widget by another), so it lives here as a small observable
+ * singleton — the same shape pi-subtask keeps in its closure.
+ *
+ * Row projection is injected rather than computed here: the widget already owns
+ * the manifest/snapshot caches that produce the run list, and duplicating that
+ * read on every keypress would put disk I/O on the input path.
+ */
+
+import type { PanelRow, PanelSelection, PanelTarget } from "./panel-selection.ts";
+import { isAgentSelection } from "./panel-selection.ts";
+
+let selection: PanelSelection = null;
+let viewed: PanelTarget | undefined;
+let rowsProvider: (() => PanelRow[]) | undefined;
+const listeners = new Set<() => void>();
+
+/** Install the row projection. Called once during panel wiring. */
+export function setPanelRowsProvider(provider: (() => PanelRow[]) | undefined): void {
+	rowsProvider = provider;
+}
+
+/**
+ * Navigable rows, freshly projected on each call.
+ *
+ * A provider throw must never break input handling — a transient manifest read
+ * failure would otherwise make the panel swallow keys — so it degrades to an
+ * empty list, which the editor treats as "nothing to navigate".
+ */
+export function panelRows(): PanelRow[] {
+	if (!rowsProvider) return [];
+	try {
+		return rowsProvider();
+	} catch {
+		return [];
+	}
+}
+
+export function getPanelSelection(): PanelSelection {
+	return selection;
+}
+
+export function setPanelSelection(next: PanelSelection): void {
+	if (next === selection) return;
+	if (isAgentSelection(selection) && isAgentSelection(next) && selection.runId === next.runId && selection.taskId === next.taskId) {
+		return;
+	}
+	selection = next;
+	notifyPanelChange();
+}
+
+export function getViewedAgent(): PanelTarget | undefined {
+	return viewed;
+}
+
+export function setViewedAgent(next: PanelTarget | undefined): void {
+	if (viewed === next) return;
+	if (viewed && next && viewed.runId === next.runId && viewed.taskId === next.taskId) return;
+	viewed = next;
+	notifyPanelChange();
+}
+
+/** True while the panel holds the cursor, i.e. keys are not going to the editor. */
+export function isPanelFocused(): boolean {
+	return selection !== null;
+}
+
+/** What the widget renderer needs, in one read. */
+export function panelDisplayState(): {
+	selectedTaskId: string | undefined;
+	viewedTaskId: string | undefined;
+	focused: boolean;
+} {
+	return {
+		selectedTaskId: isAgentSelection(selection) ? selection.taskId : undefined,
+		viewedTaskId: viewed?.taskId,
+		// Cursor-driven: uncapping the row budget while the user is typing
+		// into the pane (viewed set, selection null) would jerk the layout on
+		// every pane open. The cursor entry is when the full list is needed.
+		focused: selection !== null,
+	};
+}
+
+export function subscribePanelChange(listener: () => void): () => void {
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+}
+
+export function notifyPanelChange(): void {
+	for (const listener of [...listeners]) {
+		try {
+			listener();
+		} catch {
+			// A failing repaint listener must not stop the others.
+		}
+	}
+}
+
+/** Session teardown / test isolation. */
+export function resetPanelStore(): void {
+	selection = null;
+	viewed = undefined;
+	rowsProvider = undefined;
+	listeners.clear();
+}

package/src/ui/inline-panel/view-session-store.ts

@@ -0,0 +1,36 @@
+/**
+ * view-session-store.ts — session-switch guard for run protection.
+ *
+ * Agent views are in-document panes (see agent-pane.ts / inline-panel's
+ * openPane): viewing an agent NEVER switches, resumes, or tears down a
+ * session. This store is the one piece of session-switch machinery that
+ * remains, and it protects runs from switches the USER makes (/resume, /new,
+ * /fork): a switch tears the current session down via session.abort(), which
+ * fires the abort signal of any tool call still in flight — a foreground
+ * team run created by that tool is linked to the turn's abort, so ANY switch
+ * seconds after a run starts used to kill the run's workers ("Child Pi
+ * exited with 143" → run cancelled). While the guard is set, the
+ * caller-abort propagation is suppressed (run-deadline.ts).
+ *
+ * Set by the session_before_switch handler (runs before teardown's abort),
+ * cleared on the next session_start (the switch landed) and on reconcile.
+ */
+
+let sessionSwitchInFlight = false;
+
+export function markSessionSwitchInFlight(): void {
+	sessionSwitchInFlight = true;
+}
+
+export function clearSessionSwitchInFlight(): void {
+	sessionSwitchInFlight = false;
+}
+
+export function isSessionSwitchInFlight(): boolean {
+	return sessionSwitchInFlight;
+}
+
+/** Test isolation. */
+export function resetCrewViewSessionState(): void {
+	sessionSwitchInFlight = false;
+}

package/src/ui/pi-ui-compat.ts

@@ -46,6 +46,15 @@ export function setExtensionWidget(
 	ctx.ui.setWidget(key, content as never, widgetOptions as WidgetOptions);
 }
 
+/**
+ * Map the crew widget placement onto pi's `WidgetPlacement`. `"bottom"` is a
+ * crew-only placement (rendered inside the crew-vibes footer, below the quota
+ * lines); when a raw widget slot is involved it falls back to `belowEditor`.
+ */
+export function toPiWidgetPlacement(placement: "aboveEditor" | "belowEditor" | "bottom"): "aboveEditor" | "belowEditor" {
+	return placement === "bottom" ? "belowEditor" : placement;
+}
+
 type FooterFactory = (tui: unknown, theme: unknown, footerData: unknown) => unknown;
 
 /** Install a custom footer component, or pass `undefined` to restore pi's built-in footer.

package/src/ui/render-diff.ts

@@ -36,10 +36,10 @@ const WORD_DIFF_MIN_SIM = 0.15;
  * characters relative to the longer of the two strings, using word-level
  * diff to identify the common (unchanged) parts. Returns a value in [0, 1].
  */
-function computeSimilarity(oldContent: string, newContent: string): number {
-	const wordDiff = Diff.diffWords(oldContent, newContent);
+function computeSimilarity(oldContent: string, newContent: string, wordDiff?: Diff.Change[]): number {
+	const parts = wordDiff ?? Diff.diffWords(oldContent, newContent);
 	let commonChars = 0;
-	for (const part of wordDiff) {
+	for (const part of parts) {
 		if (!part.removed && !part.added) {
 			commonChars += part.value.length;
 		}
@@ -49,14 +49,19 @@ function computeSimilarity(oldContent: string, newContent: string): number {
 	return commonChars / maxLen;
 }
 
-function renderIntraLineDiff(theme: CrewTheme, oldContent: string, newContent: string): { removedLine: string; addedLine: string } {
-	const wordDiff = Diff.diffWords(oldContent, newContent);
+function renderIntraLineDiff(
+	theme: CrewTheme,
+	oldContent: string,
+	newContent: string,
+	wordDiff?: Diff.Change[],
+): { removedLine: string; addedLine: string } {
+	const parts = wordDiff ?? Diff.diffWords(oldContent, newContent);
 	let removedLine = "";
 	let addedLine = "";
 	let isFirstRemoved = true;
 	let isFirstAdded = true;
 
-	for (const part of wordDiff) {
+	for (const part of parts) {
 		if (part.removed) {
 			let value = part.value;
 			if (isFirstRemoved) {
@@ -130,9 +135,12 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 			if (removedLines.length === 1 && addedLines.length === 1) {
 				const oldContent = replaceTabs(removedLines[0]!.content);
 				const newContent = replaceTabs(addedLines[0]!.content);
-				const similarity = computeSimilarity(oldContent, newContent);
+				// PERF (2026-08-24): diffWords is the expensive call and was run
+				// TWICE on identical inputs (similarity + render). One pass, shared.
+				const wordDiff = Diff.diffWords(oldContent, newContent);
+				const similarity = computeSimilarity(oldContent, newContent, wordDiff);
 				if (similarity >= WORD_DIFF_MIN_SIM) {
-					const { removedLine, addedLine } = renderIntraLineDiff(theme, oldContent, newContent);
+					const { removedLine, addedLine } = renderIntraLineDiff(theme, oldContent, newContent, wordDiff);
 					result.push(theme.fg("toolDiffRemoved", `-${removedLines[0]!.lineNum} ${removedLine}`));
 					result.push(theme.fg("toolDiffAdded", `+${addedLines[0]!.lineNum} ${addedLine}`));
 				} else {

package/src/ui/run-dashboard.ts

@@ -162,11 +162,11 @@ function formatAge(iso: string | undefined): string | undefined {
 	return `${Math.floor(ms / 3_600_000)}h`;
 }
 
-function readProgressPreview(run: TeamRunManifest, maxLines = 5, snapshotCache?: RunSnapshotCache): string[] {
+function readProgressPreview(run: TeamRunManifest, maxLines = 5, snapshotCache?: RunSnapshotCache, resolve?: SnapshotResolver): string[] {
 	// P0-6: prefer the snapshot's `recentOutputLines` (no disk I/O) over reading the
 	// progress artifact on every render. The progress artifact content is captured
 	// into the snapshot's recent events / output pipeline upstream.
-	const snapshot = snapshotFor(run, snapshotCache);
+	const snapshot = resolve ? resolve(run) : snapshotFor(run, snapshotCache);
 	if (snapshot?.recentOutputLines?.length) {
 		return ["Progress:", ...snapshot.recentOutputLines.slice(0, maxLines)];
 	}
@@ -206,8 +206,20 @@ function snapshotFor(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): Ru
 	}
 }
 
-function readRunTasks(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): TeamTaskState[] {
-	const snapshot = snapshotFor(run, snapshotCache);
+/**
+ * PERF (2026-08-24, task 20) — per-frame snapshot resolver. The render path
+ * used to resolve each run's snapshot 6-8 times per frame (refreshRuns,
+ * buildSignature, groupedRuns, per-row, selected-run), and every
+ * `snapshotFor → refreshIfStale` call can stat several files per run when its
+ * own TTL expires. `renderUnsafe` now builds a frame-local Map keyed by runId
+ * and threads this resolver through every render-path helper. Helpers keep
+ * their plain direct-resolution behavior when no resolver is passed
+ * (keypress handlers and other callers outside a render frame).
+ */
+type SnapshotResolver = (run: TeamRunManifest) => RunUiSnapshot | undefined;
+
+function readRunTasks(run: TeamRunManifest, snapshotCache?: RunSnapshotCache, resolve?: SnapshotResolver): TeamTaskState[] {
+	const snapshot = resolve ? resolve(run) : snapshotFor(run, snapshotCache);
 	if (snapshot) return snapshot.tasks;
 	// P0-6: when a snapshot cache is provided but hasn't populated yet, return
 	// empty (the render loop falls back to the empty pane placeholder) instead
@@ -266,15 +278,15 @@ function agentPreviewLine(agent: CrewAgentRecord, task: TeamTaskState | undefine
 	);
 }
 
-function readAgentPreview(run: TeamRunManifest, maxLines = 5, options: RunDashboardOptions = {}): string[] {
+function readAgentPreview(run: TeamRunManifest, maxLines = 5, options: RunDashboardOptions = {}, resolve?: SnapshotResolver): string[] {
 	try {
-		const snapshot = snapshotFor(run, options.snapshotCache);
+		const snapshot = resolve ? resolve(run) : snapshotFor(run, options.snapshotCache);
 		// P0-6: when a snapshot cache is provided but hasn't populated yet, return
 		// the empty-pane placeholder instead of calling `readCrewAgents` (disk I/O)
 		// on every render tick. Legacy callers (no cache) keep the disk-read path
 		// so existing unit tests continue to assert against concrete agent data.
 		const agents = snapshot?.agents ?? (options.snapshotCache ? [] : readCrewAgents(run));
-		const tasks = snapshot?.tasks ?? readRunTasks(run, options.snapshotCache);
+		const tasks = snapshot?.tasks ?? readRunTasks(run, options.snapshotCache, resolve);
 		if (!agents.length) return ["Agents: (none)"];
 		const totals = tasks.reduce(
 			(acc, task) => {
@@ -305,8 +317,8 @@ function readAgentPreview(run: TeamRunManifest, maxLines = 5, options: RunDashbo
 	}
 }
 
-function agentsFor(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): CrewAgentRecord[] {
-	const snapshot = snapshotFor(run, snapshotCache);
+function agentsFor(run: TeamRunManifest, snapshotCache?: RunSnapshotCache, resolve?: SnapshotResolver): CrewAgentRecord[] {
+	const snapshot = resolve ? resolve(run) : snapshotFor(run, snapshotCache);
 	if (snapshot) return snapshot.agents;
 	// P0-6: when a snapshot cache is provided but hasn't populated yet, return
 	// empty (callers handle the empty-state placeholder) instead of calling
@@ -319,8 +331,14 @@ function agentsFor(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): Crew
 	}
 }
 
-function runLabel(run: TeamRunManifest, selected: boolean, snapshotCache?: RunSnapshotCache, maxW?: number): string {
-	const agents = agentsFor(run, snapshotCache);
+function runLabel(
+	run: TeamRunManifest,
+	selected: boolean,
+	snapshotCache?: RunSnapshotCache,
+	maxW?: number,
+	resolve?: SnapshotResolver,
+): string {
+	const agents = agentsFor(run, snapshotCache, resolve);
 	const stale = isLikelyOrphanedActiveRun(run, agents);
 	const running = agents.find((agent) => agent.status === "running");
 	const queued = agents.find((agent) => agent.status === "queued");
@@ -366,11 +384,11 @@ interface ResolvedRun {
 	status: RunStatus;
 }
 
-function resolveRuns(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache): Map<string, ResolvedRun> {
+function resolveRuns(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache, resolve?: SnapshotResolver): Map<string, ResolvedRun> {
 	const map = new Map<string, ResolvedRun>();
 	for (const run of runs) {
-		const snapshot = snapshotFor(run, snapshotCache);
-		const agents = snapshot?.agents ?? agentsFor(run, snapshotCache);
+		const snapshot = resolve ? resolve(run) : snapshotFor(run, snapshotCache);
+		const agents = snapshot?.agents ?? agentsFor(run, snapshotCache, resolve);
 		const displayRun = snapshot?.manifest ?? run;
 		const status: RunStatus = isLikelyOrphanedActiveRun(displayRun, agents) ? "stale" : (displayRun.status as RunStatus);
 		map.set(run.runId, { manifest: run, snapshot, agents, status });
@@ -378,8 +396,12 @@ function resolveRuns(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache):
 	return map;
 }
 
-function groupedRuns(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache): Array<{ label: string; run?: TeamRunManifest }> {
-	const resolved = resolveRuns(runs, snapshotCache);
+function groupedRuns(
+	runs: TeamRunManifest[],
+	snapshotCache?: RunSnapshotCache,
+	resolve?: SnapshotResolver,
+): Array<{ label: string; run?: TeamRunManifest }> {
+	const resolved = resolveRuns(runs, snapshotCache, resolve);
 	const rows: Array<{ label: string; run?: TeamRunManifest }> = [];
 	const active = runs.filter((run) =>
 		isDisplayActiveRun(resolved.get(run.runId)?.snapshot?.manifest ?? run, resolved.get(run.runId)?.agents ?? []),
@@ -392,8 +414,13 @@ function groupedRuns(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache):
 	return rows;
 }
 
-function selectedRunFromGrouped(runs: TeamRunManifest[], selected: number, snapshotCache?: RunSnapshotCache): TeamRunManifest | undefined {
-	return groupedRuns(runs, snapshotCache).filter((row) => row.run)[selected]?.run;
+function selectedRunFromGrouped(
+	runs: TeamRunManifest[],
+	selected: number,
+	snapshotCache?: RunSnapshotCache,
+	resolve?: SnapshotResolver,
+): TeamRunManifest | undefined {
+	return groupedRuns(runs, snapshotCache, resolve).filter((row) => row.run)[selected]?.run;
 }
 
 function countByStatus(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache): string {
@@ -520,9 +547,9 @@ export class RunDashboard implements DashboardComponent {
 		return Math.max(12, Math.min(36, rows - 2));
 	}
 
-	private refreshRuns(): void {
+	private refreshRuns(resolve?: SnapshotResolver): void {
 		if (!this.options.runProvider) return;
-		const selectedRunId = this.selectedRunId();
+		const selectedRunId = this.selectedRunId(resolve);
 		const next = this.options.runProvider();
 		// P3 (#8): re-apply the workspaceId filter on EVERY refresh, not just
 		// the constructor. Without this, runs from other sessions leak back in
@@ -532,7 +559,7 @@ export class RunDashboard implements DashboardComponent {
 			? unfiltered.filter((run) => !run.ownerSessionId || run.ownerSessionId === this.options.workspaceId)
 			: unfiltered;
 		if (selectedRunId) {
-			const nextIndex = groupedRuns(this.runs, this.options.snapshotCache)
+			const nextIndex = groupedRuns(this.runs, this.options.snapshotCache, resolve)
 				.filter((row) => row.run)
 				.findIndex((row) => row.run?.runId === selectedRunId);
 			if (nextIndex >= 0) this.selected = nextIndex;
@@ -564,7 +591,7 @@ export class RunDashboard implements DashboardComponent {
 		}
 	}
 
-	private buildSignature(): string {
+	private buildSignature(resolve?: SnapshotResolver): string {
 		// 1.10 (UI-P1-2) — short-TTL cache so we don't re-read every run's
 		// snapshot on every render tick. `snapshotFor → refreshIfStale` can
 		// stat multiple files per run when its own TTL expires, and the
@@ -579,9 +606,9 @@ export class RunDashboard implements DashboardComponent {
 		let hasRunning = false;
 		const statuses = this.runs
 			.map((run) => {
-				const snapshot = snapshotFor(run, this.options.snapshotCache);
+				const snapshot = resolve ? resolve(run) : snapshotFor(run, this.options.snapshotCache);
 				const displayRun = snapshot?.manifest ?? run;
-				const agents = snapshot?.agents ?? agentsFor(run, this.options.snapshotCache);
+				const agents = snapshot?.agents ?? agentsFor(run, this.options.snapshotCache, resolve);
 				const stale = isLikelyOrphanedActiveRun(displayRun, agents);
 				const status: RunStatus = stale ? "stale" : (displayRun.status as RunStatus);
 				if (status === "running" || agents.some((agent) => agent.status === "running")) hasRunning = true;
@@ -611,8 +638,8 @@ export class RunDashboard implements DashboardComponent {
 		this.schedulerHandle?.dispose();
 	}
 
-	private selectedRunId(): string | undefined {
-		return selectedRunFromGrouped(this.runs, this.selected, this.options.snapshotCache)?.runId;
+	private selectedRunId(resolve?: SnapshotResolver): string | undefined {
+		return selectedRunFromGrouped(this.runs, this.selected, this.options.snapshotCache, resolve)?.runId;
 	}
 
 	render(width: number): string[] {
@@ -625,13 +652,25 @@ export class RunDashboard implements DashboardComponent {
 	}
 
 	private renderUnsafe(width: number): string[] {
-		this.refreshRuns();
-		const signature = this.buildSignature();
+		// PERF (2026-08-24): snapshot resolution stat'd 7-8 files per run 6-8
+		// times per frame. Resolve once per frame into a local map and thread
+		// it through every render-path consumer below.
+		const frameSnapshots = new Map<string, RunUiSnapshot | undefined>();
+		const snapshotOnce: SnapshotResolver = (run) => {
+			if (!frameSnapshots.has(run.runId)) frameSnapshots.set(run.runId, snapshotFor(run, this.options.snapshotCache));
+			return frameSnapshots.get(run.runId);
+		};
+		this.refreshRuns(snapshotOnce);
+		const signature = this.buildSignature(snapshotOnce);
 		if (signature !== this.cachedVersion || this.cachedWidth !== width) {
 			const innerWidth = Math.max(20, width - 4);
 			const borderWidth = Math.min(innerWidth, Math.max(0, width - 2));
 			const fg = (color: Parameters<CrewTheme["fg"]>[0], text: string) => this.theme.fg(color, text);
-			const borderFill = (count: number) => new DynamicCrewBorder(this.theme).render(count)[0];
+			// PERF (2026-08-24): DynamicCrewBorder caches the rendered fill per
+			// instance — a new instance per line defeated it. One per render
+			// pass; every border()/sep() call below reuses the cached line.
+			const crewBorder = new DynamicCrewBorder(this.theme);
+			const borderFill = (count: number) => crewBorder.render(count)[0];
 			const border = (left: string, right: string) => `${fg("border", left)}${borderFill(borderWidth)}${fg("border", right)}`;
 			const row = (text: string) => `│ ${pad(truncate(text, innerWidth - 1), innerWidth - 1)}│`;
 			const sep = () => border("├", "┤");
@@ -655,7 +694,7 @@ export class RunDashboard implements DashboardComponent {
 					lines.push(row(fg("dim", "Start one: team action='run' · r reload · Esc close")));
 				} else {
 					// L-1: windowed run list so the selection can never scroll off-screen.
-					const allGrouped = groupedRuns(this.runs, this.options.snapshotCache);
+					const allGrouped = groupedRuns(this.runs, this.options.snapshotCache, snapshotOnce);
 					const selectable = allGrouped.filter((rowItem) => rowItem.run);
 					const selectableCount = selectable.length;
 					if (this.selected > selectableCount - 1) this.selected = Math.max(0, selectableCount - 1);
@@ -668,11 +707,11 @@ export class RunDashboard implements DashboardComponent {
 								continue;
 							}
 							const idx = selectable.findIndex((c) => c.run?.runId === rowItem.run?.runId);
-							const snap = snapshotFor(rowItem.run, this.options.snapshotCache);
+							const snap = snapshotOnce(rowItem.run);
 							const run = snap?.manifest ?? rowItem.run;
-							const agents = snap?.agents ?? agentsFor(rowItem.run, this.options.snapshotCache);
+							const agents = snap?.agents ?? agentsFor(rowItem.run, this.options.snapshotCache, snapshotOnce);
 							const status: RunStatus = isLikelyOrphanedActiveRun(run, agents) ? "stale" : (run.status as RunStatus);
-							const label = runLabel(run, idx === this.selected, this.options.snapshotCache, innerWidth - 2);
+							const label = runLabel(run, idx === this.selected, this.options.snapshotCache, innerWidth - 2, snapshotOnce);
 							lines.push(row(applyStatusColor(this.theme, status, label)));
 						}
 					} else {
@@ -682,25 +721,28 @@ export class RunDashboard implements DashboardComponent {
 						for (let gi = this.runScrollOffset; gi < Math.min(this.runScrollOffset + win.slots, selectableCount); gi++) {
 							const rowItem = selectable[gi];
 							if (!rowItem?.run) continue;
-							const snap = snapshotFor(rowItem.run, this.options.snapshotCache);
+							const snap = snapshotOnce(rowItem.run);
 							const run = snap?.manifest ?? rowItem.run;
-							const agents = snap?.agents ?? agentsFor(rowItem.run, this.options.snapshotCache);
+							const agents = snap?.agents ?? agentsFor(rowItem.run, this.options.snapshotCache, snapshotOnce);
 							const status: RunStatus = isLikelyOrphanedActiveRun(run, agents) ? "stale" : (run.status as RunStatus);
-							const label = runLabel(run, gi === this.selected, this.options.snapshotCache, innerWidth - 2);
+							const label = runLabel(run, gi === this.selected, this.options.snapshotCache, innerWidth - 2, snapshotOnce);
 							lines.push(row(applyStatusColor(this.theme, status, label)));
 						}
 						if (win.hasBottom)
 							lines.push(row(fg("dim", `↓ ${selectableCount - (this.runScrollOffset + win.slots)} more below`)));
 					}
 
-					// Selected run detail — compact
-					const selectedRun = selectedRunFromGrouped(this.runs, this.selected, this.options.snapshotCache);
+					// Selected run detail — compact. PERF (2026-08-24): reuse the
+					// `selectable` rows already derived from the single groupedRuns()
+					// computation above instead of recomputing grouping a third time
+					// (`selectedRunFromGrouped` is exactly `selectable[selected].run`).
+					const selectedRun = selectable[Math.min(this.selected, selectable.length - 1)]?.run;
 					if (selectedRun) {
-						const snap = snapshotFor(selectedRun, this.options.snapshotCache);
+						const snap = snapshotOnce(selectedRun);
 						const r = snap?.manifest ?? selectedRun;
-						const agents = snap?.agents ?? agentsFor(selectedRun, this.options.snapshotCache);
+						const agents = snap?.agents ?? agentsFor(selectedRun, this.options.snapshotCache, snapshotOnce);
 						const statusStr: RunStatus = isLikelyOrphanedActiveRun(r, agents) ? "stale" : (r.status as RunStatus);
-						const selectedTasks = snap?.tasks ?? readRunTasks(r, this.options.snapshotCache);
+						const selectedTasks = snap?.tasks ?? readRunTasks(r, this.options.snapshotCache, snapshotOnce);
 						lines.push(sep());
 						lines.push(row(`${fg("accent", "▸")} ${truncate(sanitizeLine(r.goal), innerWidth - 6)}`));
 						// L-2: surface the failure/cancellation reason inline for terminal runs.
@@ -741,7 +783,10 @@ export class RunDashboard implements DashboardComponent {
 												: this.activePane === "plan"
 													? safeRenderPane("plan", () => renderPlanPane(snap, { diff: this.planDiff }))
 													: safeRenderPane("transcript", () => renderTranscriptPane(snap))
-							: [...readAgentPreview(r, 4, this.options), ...readProgressPreview(r, 2, this.options.snapshotCache)];
+							: [
+									...readAgentPreview(r, 4, this.options, snapshotOnce),
+									...readProgressPreview(r, 2, this.options.snapshotCache, snapshotOnce),
+								];
 						const filteredPane = paneLines.filter((l) => l && !l.includes("(none)") && l.trim() !== "");
 						if (filteredPane.length > 0) {
 							lines.push(row(fg("dim", `── ${this.activePane} ──`)));

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

@@ -359,7 +359,16 @@ export function teamEventToRunEventType(event: TeamEvent): RunEventType | undefi
 	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 === "task.progress" ||
+		type === "mailbox.message_queued" ||
+		type === "mailbox.message_delivered" ||
+		// Task 5b (§15.2 wake): broker-side worker→parent wake signal. Maps to
+		// the existing mailbox_updated/run:state channel so sidebar+widget
+		// refresh through the render scheduler without new UI code.
+		type === "worker.message"
+	)
+		return "mailbox_updated";
 	if (type === "run.effectiveness" || type === "task.attention") return "effectiveness_changed";
 	return undefined;
 }