pi-crew 0.9.41 → 0.9.44

package/src/ui/render-coalescer.ts

@@ -3,26 +3,67 @@
  * Prevents UI flicker when many events arrive in quick succession.
  * Inspired by oh-my-pi's PROGRESS_COALESCE_MS (150ms) pattern.
  */
+import { logInternalError } from "../utils/internal-error.ts";
+
+export interface RenderCoalescerOptions {
+	/**
+	 * Invoked once per coalesce window with the number of `request()` calls
+	 * that were collapsed into the most recent scheduled render. Defaults to
+	 * a debug-scoped `logInternalError` so dropped bursts surface in logs
+	 * (gated behind PI_TEAMS_DEBUG) without callers having to wire one up.
+	 */
+	onDrop?: (droppedCount: number) => void;
+}
+
 export class RenderCoalescer {
 	#pending = false;
 	#timerId: ReturnType<typeof setTimeout> | null = null;
 	#callback: () => void;
 	#intervalMs: number;
+	#onDrop: (droppedCount: number) => void;
+	#dropped = 0;
 
-	constructor(callback: () => void, intervalMs = 32) {
+	constructor(callback: () => void, intervalMs = 32, options: RenderCoalescerOptions = {}) {
 		this.#callback = callback;
 		this.#intervalMs = intervalMs;
+		this.#onDrop =
+			options.onDrop ??
+			((count) => {
+				logInternalError(
+					"render-coalescer",
+					new Error(`coalesced ${count} dropped request(s) into a single render`),
+					undefined,
+					"debug",
+				);
+			});
 	}
 
 	/** Request a render. Will be coalesced with other requests within the interval. */
 	request(): void {
-		if (this.#pending) return;
+		if (this.#pending) {
+			// A render is already scheduled — coalesce this request and bump
+			// the drop counter so the scheduled flush can report how many
+			// bursts were collapsed (useful for diagnosing UI lag).
+			this.#dropped += 1;
+			return;
+		}
 		this.#pending = true;
-		this.#timerId = setTimeout(() => {
+		const timer = setTimeout(() => {
 			this.#pending = false;
 			this.#timerId = null;
+			const dropped = this.#dropped;
+			this.#dropped = 0;
+			if (dropped > 0) {
+				try {
+					this.#onDrop(dropped);
+				} catch {
+					/* drop callback errors are non-fatal */
+				}
+			}
 			this.#callback();
 		}, this.#intervalMs);
+		timer.unref();
+		this.#timerId = timer;
 	}
 
 	/** Force an immediate render, bypassing coalescing. */

package/src/ui/render-diff.ts

@@ -108,7 +108,7 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 			const removedLines: DiffLineContent[] = [];
 			while (i < lines.length) {
 				const nextParsed = parseDiffLine(lines[i] ?? "");
-				if (!nextParsed || nextParsed.prefix !== "-") break;
+				if (nextParsed?.prefix !== "-") break;
 				removedLines.push({
 					lineNum: nextParsed.lineNum,
 					content: nextParsed.content,
@@ -119,7 +119,7 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 			const addedLines: DiffLineContent[] = [];
 			while (i < lines.length) {
 				const nextParsed = parseDiffLine(lines[i] ?? "");
-				if (!nextParsed || nextParsed.prefix !== "+") break;
+				if (nextParsed?.prefix !== "+") break;
 				addedLines.push({
 					lineNum: nextParsed.lineNum,
 					content: nextParsed.content,

package/src/ui/run-dashboard.ts

@@ -21,7 +21,8 @@ import { DynamicCrewBorder } from "./dynamic-border.ts";
 import { dashboardActionForKey } from "./keybinding-map.ts";
 import { Box, Text } from "./layout-primitives.ts";
 import { HelpOverlay } from "./overlays/help-overlay.ts";
-import { runEventBus } from "./run-event-bus.ts";
+import { RenderScheduler } from "./render-scheduler.ts";
+import { runEventBusAsRenderScheduler } from "./run-event-bus.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
 import { spinnerBucket, spinnerFrame } from "./spinner.ts";
 import { applyStatusColor, colorizeStatusGlyphs, iconForStatus, type RunStatus } from "./status-colors.ts";
@@ -105,6 +106,17 @@ const TASK_READ_TTL_MS = 1000;
 /** Max run rows rendered in the dashboard run-list block (L-1 window budget). */
 const RUN_LIST_MAX = 8;
 
+/**
+ * 1.10 (UI-P1-2) — short TTL for the buildSignature cache. `buildSignature`
+ * iterates every run and calls `snapshotFor → refreshIfStale`, which can
+ * stat multiple files per run when the TTL expires. Rendering fires several
+ * times per second (spinner + event-bus), so we cache the computed signature
+ * for 100ms: enough to coalesce one render burst without holding the cache
+ * across genuinely new data (>100ms idle means a fresh signature will be
+ * computed on the next render anyway).
+ */
+const SIGNATURE_CACHE_TTL_MS = 100;
+
 /**
  * F-4 — a live run's snapshot is considered "possibly stale" once its
  * `fetchedAt` is this old. A progressing run rebuilds on every stamp change,
@@ -155,7 +167,17 @@ function renderLines(lines: string[], width: number): string[] {
 	return box.render(width);
 }
 
-function readProgressPreview(run: TeamRunManifest, maxLines = 5): string[] {
+function readProgressPreview(run: TeamRunManifest, maxLines = 5, snapshotCache?: RunSnapshotCache): 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);
+	if (snapshot?.recentOutputLines?.length) {
+		return ["Progress:", ...snapshot.recentOutputLines.slice(0, maxLines)];
+	}
+	if (snapshotCache) return ["Progress: (loading…)"];
+	// Legacy fallback: tests/dev paths without a snapshot cache still read the
+	// progress artifact directly so existing assertions keep working.
 	const progress = [...run.artifacts].reverse().find((artifact) => artifact.kind === "progress");
 	if (!progress) return ["Progress: (none)"];
 	try {
@@ -192,6 +214,10 @@ function snapshotFor(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): Ru
 function readRunTasks(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): TeamTaskState[] {
 	const snapshot = 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
+	// of reading the tasks.json file synchronously every render tick.
+	if (snapshotCache) return [];
 	const parse = () => {
 		if (!fs.existsSync(run.tasksPath)) return [];
 		const parsed = JSON.parse(fs.readFileSync(run.tasksPath, "utf-8"));
@@ -248,7 +274,11 @@ function agentPreviewLine(agent: CrewAgentRecord, task: TeamTaskState | undefine
 function readAgentPreview(run: TeamRunManifest, maxLines = 5, options: RunDashboardOptions = {}): string[] {
 	try {
 		const snapshot = snapshotFor(run, options.snapshotCache);
-		const agents = snapshot?.agents ?? readCrewAgents(run);
+		// 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);
 		if (!agents.length) return ["Agents: (none)"];
 		const totals = tasks.reduce(
@@ -283,6 +313,10 @@ function readAgentPreview(run: TeamRunManifest, maxLines = 5, options: RunDashbo
 function agentsFor(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): CrewAgentRecord[] {
 	const snapshot = 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
+	// `readCrewAgents` synchronously on every render tick.
+	if (snapshotCache) return [];
 	try {
 		return readCrewAgents(run);
 	} catch {
@@ -387,8 +421,12 @@ export class RunDashboard implements DashboardComponent {
 	private cachedWidth = 0;
 	private cachedVersion = "";
 	private cachedLines: string[] = [];
+	/** 1.10 (UI-P1-2) — short-TTL cache for `buildSignature()` so per-run
+	 *  `snapshotFor → refreshIfStale` calls don't fire on every render tick. */
+	private cachedSignatureAt = 0;
+	private cachedSignature = "";
 	private readonly unsubscribeTheme: () => void;
-	private readonly unsubscribeEventBus: () => void;
+	private readonly renderScheduler: RenderScheduler | undefined;
 
 	constructor(
 		runs: TeamRunManifest[],
@@ -405,17 +443,61 @@ export class RunDashboard implements DashboardComponent {
 		this.done = done;
 		this.theme = asCrewTheme(theme);
 		this.options = options;
-		this.unsubscribeTheme = subscribeThemeChange(theme, () => this.invalidateAndRender());
-		this.unsubscribeEventBus = (() => {
-			const unsub1 = runEventBus.onChannel("run:state", () => this.invalidateAndRender());
-			const unsub2 = runEventBus.onChannel("worker:lifecycle", () => this.invalidateAndRender());
-			const unsub3 = runEventBus.onChannel("ui:invalidate", () => this.invalidateAndRender());
-			return () => {
-				unsub1();
-				unsub2();
-				unsub3();
-			};
-		})();
+		// 1.10 (UI-P1-1): route run:state / worker:lifecycle / ui:invalidate
+		// through a RenderScheduler (debounce + fallback) instead of registering
+		// 3 raw runEventBus subscriptions that each schedule an immediate
+		// invalidate+requestRender. With 3 overlays subscribing independently,
+		// a single event triggered up to 9 callbacks and ~150 invalidates/sec.
+		// The scheduler keeps the per-channel subscriptions but collapses them
+		// into one debounced render + one coalesced invalidate per runId.
+		//
+		// FIND-07: scheduler must be constructed BEFORE the theme subscription
+		// and the input-handler paths so they can route their invalidate+render
+		// calls through `this.scheduleRender()` (debounced + coalesced) instead
+		// of bypassing it with direct `invalidateAndRender()` calls. Each direct
+		// call would otherwise skip the scheduler's debounce window and force
+		// a synchronous repaint, recreating the burst-storm that this scheduler
+		// was introduced to eliminate.
+		const renderTick = (): void => {
+			this.invalidateAndRender();
+		};
+		this.renderScheduler = new RenderScheduler(
+			runEventBusAsRenderScheduler(["run:state", "worker:lifecycle", "ui:invalidate"]),
+			renderTick,
+			{
+				debounceMs: 75,
+				fallbackMs: 750,
+				events: ["run:state", "worker:lifecycle", "ui:invalidate"],
+				onInvalidate: () => {
+					// Drop any cached signature — data underneath may have
+					// changed so the next buildSignature() needs to recompute.
+					this.cachedSignature = "";
+					this.cachedSignatureAt = 0;
+				},
+			},
+		);
+		// FIND-07: route theme changes through the scheduler so they coalesce
+		// with run:state / worker:lifecycle / ui:invalidate bursts instead of
+		// each firing their own immediate invalidate+requestRender.
+		this.unsubscribeTheme = subscribeThemeChange(theme, () => this.scheduleRender());
+	}
+
+	/**
+	 * FIND-07: route an external invalidation through the RenderScheduler.
+	 *
+	 * Use this for any caller-driven invalidation (theme change, input
+	 * handler action) instead of calling `invalidateAndRender()` directly.
+	 * The scheduler debounces + coalesces these so a theme change arriving
+	 * in the middle of a run:state burst doesn't force a separate synchronous
+	 * repaint. Falls back to a direct render if the scheduler was not created
+	 * (defensive — currently always created in the constructor).
+	 */
+	private scheduleRender(): void {
+		if (this.renderScheduler) {
+			this.renderScheduler.schedule();
+			return;
+		}
+		this.invalidateAndRender();
 	}
 
 	/**
@@ -489,6 +571,17 @@ export class RunDashboard implements DashboardComponent {
 	}
 
 	private buildSignature(): 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
+		// dashboard's render is called several times per second (spinner +
+		// event-bus). Cache the full computed signature for ~100ms: long
+		// enough to coalesce one render burst, short enough that idle pauses
+		// still pick up new data promptly.
+		const now = Date.now();
+		if (this.cachedSignature && now - this.cachedSignatureAt < SIGNATURE_CACHE_TTL_MS) {
+			return this.cachedSignature;
+		}
 		let hasRunning = false;
 		const statuses = this.runs
 			.map((run) => {
@@ -503,17 +596,25 @@ export class RunDashboard implements DashboardComponent {
 			.join("|");
 		const metricsSig =
 			this.activePane === "metrics" ? `:metrics=${this.options.registry?.snapshot().length ?? 0}:${spinnerBucket()}` : "";
-		return `${this.selected}:${this.showHelp ? 1 : 0}:${this.showFullProgress ? 1 : 0}:${this.activePane}:${statuses}${hasRunning ? `:spin=${spinnerBucket()}` : ""}${metricsSig}`;
+		const sig = `${this.selected}:${this.showHelp ? 1 : 0}:${this.showFullProgress ? 1 : 0}:${this.activePane}:${statuses}${hasRunning ? `:spin=${spinnerBucket()}` : ""}${metricsSig}`;
+		this.cachedSignature = sig;
+		this.cachedSignatureAt = now;
+		return sig;
 	}
 
 	invalidate(): void {
 		this.cachedVersion = "";
 		this.cachedLines = [];
+		// 1.10 (UI-P1-2): also drop the short-TTL signature cache so the next
+		// render can't return a stale snapshot-derived signature that was
+		// computed before the invalidating event arrived.
+		this.cachedSignature = "";
+		this.cachedSignatureAt = 0;
 	}
 
 	dispose(): void {
 		this.unsubscribeTheme();
-		this.unsubscribeEventBus();
+		this.renderScheduler?.dispose();
 	}
 
 	private selectedRunId(): string | undefined {
@@ -644,7 +745,7 @@ export class RunDashboard implements DashboardComponent {
 														}),
 													)
 												: safeRenderPane("transcript", () => renderTranscriptPane(snap))
-							: [...readAgentPreview(r, 4, this.options), ...readProgressPreview(r, 2)];
+							: [...readAgentPreview(r, 4, this.options), ...readProgressPreview(r, 2, this.options.snapshotCache)];
 						const filteredPane = paneLines.filter((l) => l && !l.includes("(none)") && l.trim() !== "");
 						if (filteredPane.length > 0) {
 							lines.push(row(fg("dim", `── ${this.activePane} ──`)));
@@ -719,12 +820,12 @@ export class RunDashboard implements DashboardComponent {
 		// (including Esc) just dismisses it first instead of acting.
 		if (action === "help") {
 			this.showHelp = !this.showHelp;
-			this.invalidateAndRender();
+			this.scheduleRender();
 			return;
 		}
 		if (this.showHelp) {
 			this.showHelp = false;
-			this.invalidateAndRender();
+			this.scheduleRender();
 			return;
 		}
 		const selectedRunId = this.selectedRunId();
@@ -786,7 +887,7 @@ export class RunDashboard implements DashboardComponent {
 		}
 		if (action) {
 			lastActivePane = this.activePane;
-			this.invalidateAndRender();
+			this.scheduleRender();
 		}
 	}
 }

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

@@ -1,5 +1,6 @@
 import type { TeamEvent } from "../state/event-log.ts";
 import { readEventsCursor } from "../state/event-log.ts";
+import type { RenderSchedulerEventBus } from "./render-scheduler.ts";
 
 export type RunEventType =
 	| "task_started"
@@ -80,6 +81,14 @@ class RunEventBus {
 	#globalListeners = new Set<RunEventCallback>();
 	#channelListeners = new Map<EventChannel, Set<RunEventCallback>>();
 	#channelRunListeners = new Map<string, Map<EventChannel, Set<RunEventCallback>>>();
+	// 1.10 (FIND-13): microtask-batched listener fan-out. Events emitted in
+	// the same synchronous tick are coalesced into a single microtask flush
+	// instead of one synchronous fan-out per emit. Reduces listener dispatch
+	// overhead when many events arrive back-to-back (e.g. from a single
+	// appendEvent chain that emits several derived events).
+	#emitQueue: RunEventPayload[] = [];
+	#flushScheduled = false;
+	#disposed = false;
 
 	on(runId: string, callback: RunEventCallback): () => void {
 		const listeners = this.#listeners.get(runId) ?? new Set();
@@ -202,12 +211,41 @@ class RunEventBus {
 	}
 
 	emit(event: RunEventPayload): void {
+		if (this.#disposed) return;
 		// 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);
 		}
+		// 1.10 (FIND-13): queue and defer fan-out to a microtask so multiple
+		// emits in the same synchronous tick collapse into one listener-pass
+		// each (one per emit, all in the same microtask).
+		this.#emitQueue.push(event);
+		if (this.#flushScheduled) return;
+		this.#flushScheduled = true;
+		queueMicrotask(() => {
+			this.#flushScheduled = false;
+			if (this.#disposed) {
+				this.#emitQueue.length = 0;
+				return;
+			}
+			// Swap the queue before dispatching so a listener that re-emits
+			// enqueues into a fresh queue (scheduled by its own emit() call)
+			// instead of stomping the current iteration.
+			const queue = this.#emitQueue;
+			this.#emitQueue = [];
+			for (const queued of queue) this.#dispatchSync(queued);
+		});
+	}
+
+	/**
+	 * Synchronous per-event listener fan-out. Called from the microtask flush
+	 * scheduled by emit(); not part of the public API. Mirrors the original
+	 * (pre-batching) emit body so a single emit still visits every listener
+	 * registered for the event's runId / channel / global set.
+	 */
+	#dispatchSync(event: RunEventPayload): void {
 		const channel = event.channel!;
 
 		// Existing: runId-specific listeners
@@ -262,10 +300,13 @@ class RunEventBus {
 
 	/** Dispose all subscriptions including channel-based ones. */
 	dispose(): void {
+		this.#disposed = true;
 		this.#listeners.clear();
 		this.#globalListeners.clear();
 		this.#channelListeners.clear();
 		this.#channelRunListeners.clear();
+		this.#emitQueue.length = 0;
+		this.#flushScheduled = false;
 	}
 
 	listenerCount(runId?: string): number {
@@ -283,6 +324,31 @@ class RunEventBus {
 /** Global singleton run event bus for UI-first event delivery. */
 export const runEventBus = new RunEventBus();
 
+/**
+ * 1.10 (UI-P1-1): adapt `runEventBus.onChannel` to the
+ * `RenderSchedulerEventBus` interface so overlays can route their
+ * `run:state` / `worker:lifecycle` / `ui:invalidate` subscriptions through
+ * a `RenderScheduler` (debounce + fallback + per-runId coalescing) instead of
+ * calling `runEventBus.onChannel(...)` directly three times. Without the
+ * scheduler, a single event triggers up to 9 callbacks across the 3 overlays
+ * (dashboard + sidebar + widget) and bursts into ~150 invalidate+requestRender
+ * /sec under load.
+ *
+ * Returns a fresh adapter whose `on(event, handler)` is a thin shim over
+ * `runEventBus.onChannel`. The channels list is closed-over so we can do a
+ * defensive membership check without re-reading the channel set on every
+ * subscription.
+ */
+export function runEventBusAsRenderScheduler(channels: readonly EventChannel[]): RenderSchedulerEventBus {
+	const allowed = new Set<EventChannel>(channels);
+	return {
+		on: (event: string, handler: (payload: unknown) => void): (() => void) | void => {
+			if (!allowed.has(event as EventChannel)) return undefined;
+			return runEventBus.onChannel(event as EventChannel, handler);
+		},
+	};
+}
+
 /** Derive a RunEventType from a TeamEvent. */
 export function teamEventToRunEventType(event: TeamEvent): RunEventType | undefined {
 	const type = event.type;

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

@@ -126,46 +126,33 @@ function combineStamps(stamps: FileStamp[]): FileStamp {
 
 function mailboxStamp(manifest: TeamRunManifest): FileStamp {
 	const root = path.join(manifest.stateRoot, "mailbox");
-	const stamps: FileStamp[] = [
+	const tasksRoot = path.join(root, "tasks");
+	// 1.10 (UI-P1-3): replace the O(tasks) per-task inbox/outbox stat loop
+	// with a single stat on the tasks dir. The dir mtime changes whenever a
+	// task mailbox subdir is created or removed (the dominant cost when a run
+	// has many tasks), and per-file content changes are still caught by the
+	// top-level inbox/outbox/delivery stats below. The event-bus
+	// (`crew.mailbox.*`) also drives invalidation, so the stamp is the
+	// fallback poll, not the only source of truth.
+	return combineStamps([
 		stampFile(path.join(root, "inbox.jsonl")),
 		stampFile(path.join(root, "outbox.jsonl")),
 		stampFile(path.join(root, "delivery.json")),
-	];
-	const tasksRoot = path.join(root, "tasks");
-	try {
-		for (const entry of fs.readdirSync(tasksRoot, {
-			withFileTypes: true,
-		})) {
-			if (!entry.isDirectory()) continue;
-			stamps.push(stampFile(path.join(tasksRoot, entry.name, "inbox.jsonl")));
-			stamps.push(stampFile(path.join(tasksRoot, entry.name, "outbox.jsonl")));
-		}
-	} catch {
-		// No task mailbox yet.
-	}
-	return combineStamps(stamps);
+		stampFile(tasksRoot),
+	]);
 }
 
 async function mailboxStampAsync(manifest: TeamRunManifest): Promise<FileStamp> {
 	const root = path.join(manifest.stateRoot, "mailbox");
-	const stamps: FileStamp[] = [
+	const tasksRoot = path.join(root, "tasks");
+	// 1.10 (UI-P1-3): see sync `mailboxStamp` above — single tasksRoot stat
+	// replaces the O(tasks) per-task loop.
+	return combineStamps([
 		await stampFileAsync(path.join(root, "inbox.jsonl")),
 		await stampFileAsync(path.join(root, "outbox.jsonl")),
 		await stampFileAsync(path.join(root, "delivery.json")),
-	];
-	const tasksRoot = path.join(root, "tasks");
-	try {
-		for (const entry of await fs.promises.readdir(tasksRoot, {
-			withFileTypes: true,
-		})) {
-			if (!entry.isDirectory()) continue;
-			stamps.push(await stampFileAsync(path.join(tasksRoot, entry.name, "inbox.jsonl")));
-			stamps.push(await stampFileAsync(path.join(tasksRoot, entry.name, "outbox.jsonl")));
-		}
-	} catch {
-		// No task mailbox yet.
-	}
-	return combineStamps(stamps);
+		await stampFileAsync(tasksRoot),
+	]);
 }
 
 function safeAgentOutputPath(manifest: TeamRunManifest, agent: CrewAgentRecord): string | undefined {
@@ -673,54 +660,20 @@ function cancellationReasonFromEvents(events: TeamEvent[]): string | undefined {
 		| undefined;
 }
 
-function signatureFor(input: Omit<RunUiSnapshot, "signature" | "fetchedAt" | "sliceSignatures">, stamps: SnapshotStamps): string {
-	try {
-		const digest = createHash("sha256");
-		digest.update(
-			JSON.stringify({
-				run: [input.manifest.runId, input.manifest.status, input.manifest.updatedAt, input.manifest.artifacts.length],
-				tasks: input.tasks.map((task) => [task.id, task.status, task.startedAt, task.finishedAt, task.agentProgress, task.usage]),
-				agents: input.agents.map((agent) => [
-					agent.id,
-					agent.status,
-					agent.startedAt,
-					agent.completedAt,
-					agent.toolUses,
-					agent.progress,
-					agent.usage,
-					agent.model,
-				]),
-				progress: input.progress,
-				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,
-					event.data?.reason,
-				]),
-				cancellationReason: input.cancellationReason,
-				dwfPhaseState: input.dwfPhaseState,
-				output: input.recentOutputLines,
-				stamps,
-			}),
-		);
-		return digest.digest("hex").slice(0, 16);
-	} catch {
-		// Circular reference or non-serializable data — fall back to timestamp.
-		return String(Date.now());
-	}
-}
+type SliceSignatures = NonNullable<RunUiSnapshot["sliceSignatures"]>;
 
 /**
- * 1.6 / 1.7 — compute one short hash per logical slice of the snapshot so
- * dashboard panes / widget can short-circuit when their slice hasn't moved.
- * The slice contents must mirror what `signatureFor` packs into each branch.
+ * FIND-08: compute the per-slice short hashes once per build and reuse the
+ * result for both the full-snapshot `signature` and the per-pane
+ * `sliceSignatures`. Previously, `signatureFor` and `sliceSignaturesFor` each
+ * called `JSON.stringify` + `createHash("sha256")` on the tasks, agents, and
+ * recentEvents projections independently — twice the work for the slices the
+ * two signatures share. The per-slice hashes are embedded into the full
+ * signature so the full-snapshot signature still changes whenever any slice
+ * changes (collision risk: 1 in 16^16 per build, well within tolerance for
+ * cache-invalidation use).
  */
-function sliceSignaturesFor(input: Omit<RunUiSnapshot, "signature" | "fetchedAt" | "sliceSignatures">): RunUiSnapshot["sliceSignatures"] {
+function computeSliceSignatures(input: Omit<RunUiSnapshot, "signature" | "fetchedAt" | "sliceSignatures">): SliceSignatures {
 	const hash = (value: unknown): string => {
 		try {
 			return createHash("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 12);
@@ -757,6 +710,45 @@ function sliceSignaturesFor(input: Omit<RunUiSnapshot, "signature" | "fetchedAt"
 	};
 }
 
+function signatureFor(
+	input: Omit<RunUiSnapshot, "signature" | "fetchedAt" | "sliceSignatures">,
+	stamps: SnapshotStamps,
+	sliceSignatures: SliceSignatures,
+): string {
+	try {
+		const digest = createHash("sha256");
+		digest.update(
+			JSON.stringify({
+				run: [input.manifest.runId, input.manifest.status, input.manifest.updatedAt, input.manifest.artifacts.length],
+				tasks: sliceSignatures.tasks,
+				agents: sliceSignatures.agents,
+				progress: input.progress,
+				usage: input.usage,
+				mailbox: input.mailbox,
+				groupJoins: input.groupJoins,
+				events: sliceSignatures.events,
+				cancellationReason: input.cancellationReason,
+				dwfPhaseState: input.dwfPhaseState,
+				output: input.recentOutputLines,
+				stamps,
+			}),
+		);
+		return digest.digest("hex").slice(0, 16);
+	} catch {
+		// Circular reference or non-serializable data — fall back to timestamp.
+		return String(Date.now());
+	}
+}
+
+/**
+ * 1.6 / 1.7 — compute one short hash per logical slice of the snapshot so
+ * dashboard panes / widget can short-circuit when their slice hasn't moved.
+ * The slice contents must mirror what `signatureFor` packs into each branch.
+ */
+function sliceSignaturesFor(sliceSignatures: SliceSignatures): SliceSignatures {
+	return sliceSignatures;
+}
+
 function stampsFor(manifest: TeamRunManifest, _agents: CrewAgentRecord[]): SnapshotStamps {
 	// 1.4: use events sequence file instead of stat-ing the events log directly.
 	// 1.5: drop per-agent output.log stamping; rely on event-bus invalidation
@@ -807,8 +799,17 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 
 	function evictIfNeeded(): void {
 		while (entries.size > maxEntries) {
-			const oldestInactive = [...entries.entries()].find(([, entry]) => !isActiveRunStatus(entry.snapshot.manifest.status));
-			const key = oldestInactive?.[0] ?? entries.keys().next().value;
+			// Map iteration respects insertion order, so the first inactive entry
+			// we see IS the oldest inactive entry — no Array.from(...).sort()
+			// allocation, no copy of the entries map.
+			let key: string | undefined;
+			for (const [k, entry] of entries) {
+				if (!isActiveRunStatus(entry.snapshot.manifest.status)) {
+					key = k;
+					break;
+				}
+			}
+			if (!key) key = entries.keys().next().value;
 			if (!key) break;
 			entries.delete(key);
 		}
@@ -854,11 +855,12 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			recentOutputLines: recentOutputLines(loaded.manifest, agents, recentOutputLimit),
 		};
 		const stamps = stampsFor(loaded.manifest, agents);
+		const sliceSignatures = computeSliceSignatures(base);
 		const snapshot: RunUiSnapshot = {
 			...base,
 			fetchedAt: Date.now(),
-			signature: signatureFor(base, stamps),
-			sliceSignatures: sliceSignaturesFor(base),
+			signature: signatureFor(base, stamps, sliceSignatures),
+			sliceSignatures,
 		};
 		return {
 			snapshot,
@@ -911,11 +913,12 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			recentOutputLines: recentOutput,
 		};
 		const stamps = await stampsForAsync(loaded.manifest, agents);
+		const sliceSignatures = computeSliceSignatures(base);
 		const snapshot: RunUiSnapshot = {
 			...base,
 			fetchedAt: Date.now(),
-			signature: signatureFor(base, stamps),
-			sliceSignatures: sliceSignaturesFor(base),
+			signature: signatureFor(base, stamps, sliceSignatures),
+			sliceSignatures,
 		};
 		return {
 			snapshot,