pi-crew 0.9.55 → 0.9.57

package/src/ui/keybinding-map.ts

@@ -23,6 +23,8 @@
  * `use-global-shortcuts.ts:38-61`.
  */
 
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { type KeyId, matchesKey } from "@earendil-works/pi-tui";
 import { keyOf } from "./key-utils.ts";
 
@@ -113,7 +115,10 @@ export type DashboardKeyAction =
 	| "notifications-dismiss";
 
 /**
- * The dispatch table. ORDER MATTERS — first match wins.
+ * The default dispatch table. ORDER MATTERS — first match wins. These
+ * hardcoded defaults may be overridden per-action via `.crew/config.json`
+ * (`keybindings` section) and/or the `PI_CREW_KEYBINDINGS` env var — see
+ * `getEffectiveBindings` below.
  *
  * Precedence notes (must match the pre-L2 if-chain exactly):
  *   1. `close` always wins (q / Esc).
@@ -129,7 +134,7 @@ export type DashboardKeyAction =
  * reservation but are handled by the mailbox overlay's own `handleInput`,
  * not by the dashboard dispatch. Adding them here would change behavior.
  */
-const BINDINGS: readonly KeyBinding[] = [
+const DEFAULT_BINDINGS: readonly KeyBinding[] = [
 	{ keys: DASHBOARD_KEYS.close, action: "close" },
 	{ keys: DASHBOARD_KEYS.help, action: "help" },
 	{
@@ -202,13 +207,178 @@ const KEY_RESERVED = new Set<string>([
 
 export { KEY_RESERVED };
 
+// ─── Keybinding overrides (UI-2) ───────────────────────────────────────────
+//
+// The hardcoded DEFAULT_BINDINGS above can be overridden per-action via two
+// layered sources (later wins):
+//   1. `.crew/config.json` → top-level `keybindings` object, e.g.
+//        { "keybindings": { "reload": ["z"], "events": ["E"] } }
+//   2. `PI_CREW_KEYBINDINGS` env var — a JSON object string of the same shape
+//      (highest precedence; handy for ad-hoc / test overrides).
+//
+// Each entry REPLACES the default key list for that action (the action keeps
+// its original pane scope). Actions not listed keep their defaults, so the
+// parity golden snapshot is unaffected when no override is configured.
+//
+// Collision validation: an overridden key that would clash with another
+// (default or overridden) binding in a compatible pane scope is treated as a
+// collision; the offending action's override is reverted to its default and a
+// warning is recorded (getKeybindingOverrideWarnings). This keeps the
+// first-match-wins dispatch unambiguous — a shadowed override never silently
+// changes behaviour.
+
+/** Override map: action → replacement keys. `Partial` ⇒ only listed actions. */
+export type KeybindingOverride = Partial<Record<DashboardKeyAction, readonly string[]>>;
+
+const KEYBINDINGS_ENV = "PI_CREW_KEYBINDINGS";
+
+/** Every dispatched action is a valid override target. */
+const VALID_OVERRIDE_ACTIONS: ReadonlySet<string> = new Set(DEFAULT_BINDINGS.map((b) => b.action));
+
+/** Coerce an unknown parsed value into a safe {@link KeybindingOverride}. */
+function parseKeybindingOverride(raw: unknown): KeybindingOverride {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+	const result: KeybindingOverride = {};
+	for (const [action, keys] of Object.entries(raw as Record<string, unknown>)) {
+		if (!VALID_OVERRIDE_ACTIONS.has(action)) continue;
+		if (!Array.isArray(keys)) continue;
+		const clean = keys.filter((k): k is string => typeof k === "string" && k.length > 0);
+		if (clean.length > 0) result[action as DashboardKeyAction] = clean;
+	}
+	return result;
+}
+
+/**
+ * Two pane scopes are "compatible" when some `activePane` could make both
+ * bindings fire at once (so a shared key is genuinely ambiguous). Global
+ * (`undefined`) matches anything; two different concrete panes never overlap.
+ */
+function paneScopesCompatible(a: ActivePane | undefined, b: ActivePane | undefined): boolean {
+	if (a === undefined || b === undefined) return true;
+	return a === b;
+}
+
+interface EffectiveBindingsResult {
+	readonly bindings: readonly KeyBinding[];
+	/** Actions whose override was rejected due to a collision. */
+	readonly reverted: readonly DashboardKeyAction[];
+}
+
+/**
+ * Apply `overrides` onto {@link DEFAULT_BINDINGS} (replace keys per action,
+ * preserving each action's pane scope) and detect collisions. A colliding
+ * override is reverted to its default so the dispatch stays unambiguous.
+ */
+function computeEffectiveBindings(overrides: KeybindingOverride): EffectiveBindingsResult {
+	const applied = new Map<DashboardKeyAction, KeyBinding>();
+	for (const def of DEFAULT_BINDINGS) {
+		const ov = overrides[def.action];
+		applied.set(def.action, ov && ov.length > 0 ? { keys: [...ov], action: def.action, pane: def.pane } : def);
+	}
+	const effective = [...applied.values()];
+	const reverted = new Set<DashboardKeyAction>();
+	for (const def of DEFAULT_BINDINGS) {
+		const ov = overrides[def.action];
+		if (!ov || ov.length === 0) continue; // not overridden
+		const ob = applied.get(def.action);
+		if (!ob) continue;
+		for (const other of effective) {
+			if (other.action === def.action) continue;
+			if (!paneScopesCompatible(ob.pane, other.pane)) continue;
+			if (ob.keys.some((k) => other.keys.includes(k))) {
+				reverted.add(def.action);
+				break;
+			}
+		}
+	}
+	const bindings =
+		reverted.size > 0
+			? effective.map((b) => (reverted.has(b.action) ? (DEFAULT_BINDINGS.find((d) => d.action === b.action) ?? b) : b))
+			: effective;
+	return { bindings, reverted: [...reverted] };
+}
+
+/** Read the `keybindings` section from `<cwd>/.crew/config.json`. */
+function readConfigKeybindings(cwd: string): KeybindingOverride {
+	try {
+		const raw: unknown = JSON.parse(fs.readFileSync(path.join(cwd, ".crew", "config.json"), "utf-8"));
+		if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+		return parseKeybindingOverride((raw as Record<string, unknown>).keybindings);
+	} catch {
+		return {};
+	}
+}
+
+/** Read the `PI_CREW_KEYBINDINGS` env var (JSON object string). */
+function readEnvKeybindings(): KeybindingOverride {
+	const raw = process.env[KEYBINDINGS_ENV];
+	if (!raw) return {};
+	try {
+		return parseKeybindingOverride(JSON.parse(raw));
+	} catch {
+		return {};
+	}
+}
+
+function configKeybindingsMtime(cwd: string): number | undefined {
+	try {
+		return fs.statSync(path.join(cwd, ".crew", "config.json")).mtimeMs;
+	} catch {
+		return undefined;
+	}
+}
+
+interface EffectiveCache {
+	readonly env: string | undefined;
+	readonly configMtime: number | undefined;
+	readonly cwd: string;
+	readonly bindings: readonly KeyBinding[];
+}
+
+let _effectiveCache: EffectiveCache | null = null;
+let _overrideWarnings: readonly string[] = [];
+
+/**
+ * Resolve the effective dispatch table: {@link DEFAULT_BINDINGS} with config +
+ * env overrides applied (env wins per action). Memoised on (env value, config
+ * mtime, cwd); a single `statSync` per call detects on-disk config changes.
+ */
+function getEffectiveBindings(cwd: string = process.cwd()): readonly KeyBinding[] {
+	const envRaw = process.env[KEYBINDINGS_ENV];
+	const configMtime = configKeybindingsMtime(cwd);
+	if (_effectiveCache && _effectiveCache.env === envRaw && _effectiveCache.configMtime === configMtime && _effectiveCache.cwd === cwd) {
+		return _effectiveCache.bindings;
+	}
+	const merged: KeybindingOverride = { ...readConfigKeybindings(cwd), ...readEnvKeybindings() };
+	const { bindings, reverted } = computeEffectiveBindings(merged);
+	_overrideWarnings = reverted.map((a) => `keybinding override for '${a}' collides with another binding — reverting to default`);
+	_effectiveCache = { env: envRaw, configMtime, cwd, bindings };
+	return bindings;
+}
+
+/** Warnings from the most recent override resolution (e.g. collisions). */
+export function getKeybindingOverrideWarnings(): readonly string[] {
+	// Ensure a resolution has run so warnings are populated.
+	getEffectiveBindings();
+	return _overrideWarnings;
+}
+
+/** @internal — drop the memoised effective-binding cache (tests). */
+export function __test__resetKeybindingCache(): void {
+	_effectiveCache = null;
+	_overrideWarnings = [];
+}
+
 /**
  * Resolve a raw input `data` string to a dashboard action.
  *
- * Data-driven dispatch: iterates `BINDINGS` in order and returns the action of
- * the first binding whose `keys` contain `data` and whose optional `pane`
- * restriction matches `activePane`. Behavior is identical to the pre-L2
- * if-chain (verified by `test/unit/keybinding-map.parity.test.ts`).
+ * Data-driven dispatch: iterates the effective binding table (hardcoded
+ * {@link DEFAULT_BINDINGS}, optionally overridden per-action via config/env —
+ * see {@link getEffectiveBindings}) in order and returns the action of the
+ * first binding whose `keys` contain `data` and whose optional `pane`
+ * restriction matches `activePane`. With no override configured the result is
+ * identical to the pre-L2 if-chain (verified by
+ * `test/unit/keybinding-map.parity.test.ts`).
  *
  * @param data Raw key input (single char or escape sequence).
  * @param activePane Currently focused pane; pane-scoped bindings only fire
@@ -217,6 +387,9 @@ export { KEY_RESERVED };
  *                   arg skipped the `activePane === ...` branches).
  */
 export function dashboardActionForKey(data: string, activePane?: ActivePane): DashboardKeyAction | undefined {
+	// Effective table = hardcoded DEFAULT_BINDINGS with optional config/env
+	// overrides applied (see getEffectiveBindings). Memoised; one statSync/call.
+	const BINDINGS = getEffectiveBindings();
 	// Two-pass dispatch to preserve case-sensitivity for plain ASCII keys
 	// while still normalizing escape sequences via matchesKey().
 	//

package/src/ui/layout-primitives.ts

@@ -1,9 +1,11 @@
 import { pad, wrapHard } from "../utils/visual.ts";
+import type { CrewComponent } from "./component.ts";
 
-export interface RenderableComponent {
-	invalidate(): void;
-	render(width: number): string[];
-}
+// PR-G3 (UI-3): the shared CrewComponent contract (render + invalidate).
+// RenderableComponent now extends it so every layout primitive is usable
+// wherever a CrewComponent is expected. Structurally identical — no behavior
+// change.
+export interface RenderableComponent extends CrewComponent {}
 
 export class Container implements RenderableComponent {
 	private children: RenderableComponent[] = [];
@@ -102,5 +104,7 @@ export class Spacer implements RenderableComponent {
 		return Array.from({ length: Math.max(0, this.rows) }, () => pad("", width));
 	}
 
-	invalidate(): void {}
+	invalidate(): void {
+		/* no-op */
+	}
 }

package/src/ui/live-conversation-overlay.ts

@@ -4,7 +4,7 @@
  * R8: Subscribes to session events for real-time streaming updates.
  * Falls back to polling LiveAgentHandle.activity when subscribe is unavailable.
  */
-import type { LiveAgentHandle } from "../runtime/live-agent-manager.ts";
+import type { LiveAgentHandle } from "../runtime/live-session/live-agent-manager.ts";
 import { pad, truncate } from "../utils/visual.ts";
 import { computeLiveDurationMs } from "./live-duration.ts";
 import { spinnerFrame } from "./spinner.ts";

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

@@ -3,7 +3,7 @@ import type { CrewUiConfig } from "../config/config.ts";
 import { applyAttentionState, resolveCrewControlConfig } from "../runtime/agent-control.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { formatTaskGraphLines, waitingReason } from "../runtime/task-display.ts";
-import { loadRunManifestById } from "../state/state-store.ts";
+import { loadRunManifestById } from "../state/stores/state-store.ts";
 import type { TeamTaskState } from "../state/types.ts";
 import { aggregateUsage, formatUsage } from "../state/usage.ts";
 import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";

package/src/ui/overlay-stack.ts

@@ -0,0 +1,148 @@
+/**
+ * PR-G3 (UI-4) — minimal overlay stack for z-order, focus, and dismissal
+ * chaining.
+ *
+ * Before this, src/ui/ had no central router for overlay z-order/focus/
+ * dismissal. Overlays (ConfirmOverlay, MailboxDetailOverlay, AgentPickerOverlay,
+ * HelpOverlay, …) each manage their own `handleInput`, and a caller that wants
+ * two overlays up at once had no way to express "the top one gets input and
+ * ESC dismisses it, restoring focus to the one below".
+ *
+ * The `OverlayStack` is a LIFO stack of overlays. The top of the stack owns
+ * input focus and is rendered last (i.e. on top). Popping or dismissing the
+ * top restores focus to the next overlay down. Every overlay already exposes
+ * the `InteractiveComponent` contract (render + invalidate + handleInput), so
+ * existing overlays opt in automatically with zero rewrite.
+ *
+ * This is intentionally additive: no existing overlay is required to use it.
+ * Callers that want centralized z-order/focus management opt in by pushing
+ * overlays here.
+ */
+
+import type { InteractiveComponent } from "./component.ts";
+
+/**
+ * An overlay is an interactive component occupying one z-layer. Anything with
+ * `render` + `invalidate` + `handleInput` qualifies (ConfirmOverlay,
+ * MailboxDetailOverlay, AgentPickerOverlay, RunDashboard, …).
+ */
+export type Overlay = InteractiveComponent;
+
+export interface OverlayStackOptions {
+	/**
+	 * Invoked after the top-of-stack changes (push / pop / dismissTop / clear).
+	 * Use it to (re)wire host focus or request a repaint. Optional.
+	 */
+	onTopChanged?: () => void;
+}
+
+/**
+ * LIFO overlay stack providing z-order, focus, and dismissal chaining.
+ *
+ * - `push(o)`  → `o` becomes the new focus/top layer.
+ * - `top()`    → the focused overlay (or undefined when empty).
+ * - `handleInput(data)` → routed to the top overlay only; returns false when
+ *   the stack is empty so callers can fall back to base input handling.
+ * - `dismissTop()` / `pop()` → removes the top overlay, restoring focus below.
+ * - `render(width)` → renders the top overlay by default; `{ composite: true }`
+ *   returns every layer bottom-to-top for custom compositing.
+ */
+export class OverlayStack {
+	private readonly stack: Overlay[] = [];
+	private readonly onTopChanged?: () => void;
+
+	constructor(options: OverlayStackOptions = {}) {
+		this.onTopChanged = options.onTopChanged;
+	}
+
+	/** Number of overlays currently on the stack. */
+	get size(): number {
+		return this.stack.length;
+	}
+
+	/** Whether the stack currently holds any overlays. */
+	isEmpty(): boolean {
+		return this.stack.length === 0;
+	}
+
+	/** Push a new overlay on top. It becomes the input/render focus. */
+	push(overlay: Overlay): void {
+		this.stack.push(overlay);
+		this.notifyTopChanged();
+	}
+
+	/** Remove and return the top overlay, or undefined if the stack is empty. */
+	pop(): Overlay | undefined {
+		const overlay = this.stack.pop();
+		this.notifyTopChanged();
+		return overlay;
+	}
+
+	/** The top-of-stack overlay (the focus/render target), or undefined when empty. */
+	top(): Overlay | undefined {
+		return this.stack.at(-1);
+	}
+
+	/** Peek at the overlay at a given depth (0 = bottom). */
+	at(index: number): Overlay | undefined {
+		return this.stack[index];
+	}
+
+	/**
+	 * Dismiss the top overlay. Equivalent to `pop()` but returns a boolean so
+	 * callers can chain dismissal (e.g. ESC closes the topmost, then the next).
+	 * Returns true when an overlay was dismissed, false when the stack is empty.
+	 */
+	dismissTop(): boolean {
+		if (this.stack.length === 0) return false;
+		this.stack.pop();
+		this.notifyTopChanged();
+		return true;
+	}
+
+	/**
+	 * Route a raw input chunk to the top-of-stack overlay.
+	 * @returns true if an overlay handled it (stack non-empty); false if the
+	 *   stack is empty so the caller may fall back to base input handling.
+	 */
+	handleInput(data: string): boolean {
+		const overlay = this.top();
+		if (!overlay) return false;
+		overlay.handleInput(data);
+		return true;
+	}
+
+	/**
+	 * Render the stack. By default returns the top overlay's lines (the common
+	 * modal case where the top covers what is below). Pass `{ composite: true }`
+	 * to receive every layer's lines in bottom-to-top order for custom
+	 * compositing. Returns `[]` when the stack is empty.
+	 */
+	render(width: number, options: { composite?: boolean } = {}): string[] {
+		if (this.stack.length === 0) return [];
+		if (options.composite) {
+			const lines: string[] = [];
+			for (const overlay of this.stack) {
+				lines.push(...overlay.render(width));
+			}
+			return lines;
+		}
+		return this.stack.at(-1)!.render(width);
+	}
+
+	/** Invalidate every overlay on the stack (e.g. on theme change). */
+	invalidateAll(): void {
+		for (const overlay of this.stack) overlay.invalidate();
+	}
+
+	/** Remove every overlay from the stack. */
+	clear(): void {
+		const hadOverlays = this.stack.length > 0;
+		this.stack.length = 0;
+		if (hadOverlays) this.notifyTopChanged();
+	}
+
+	private notifyTopChanged(): void {
+		this.onTopChanged?.();
+	}
+}

package/src/ui/overlays/agent-picker-overlay.ts

@@ -1,6 +1,6 @@
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
-import { loadRunManifestById } from "../../state/state-store.ts";
+import { loadRunManifestById } from "../../state/stores/state-store.ts";
 import { pad, truncate } from "../../utils/visual.ts";
 import { keyOf } from "../key-utils.ts";
 import { asCrewTheme, type CrewTheme } from "../theme-adapter.ts";

package/src/ui/overlays/mailbox-compose-overlay.ts

@@ -1,4 +1,4 @@
-import type { MailboxDirection } from "../../state/mailbox.ts";
+import type { MailboxDirection } from "../../state/coordination/mailbox.ts";
 import { pad, truncate } from "../../utils/visual.ts";
 import { asCrewTheme, type CrewTheme } from "../theme-adapter.ts";
 import { ConfirmOverlay } from "./confirm-overlay.ts";

package/src/ui/overlays/mailbox-detail-overlay.ts

@@ -1,5 +1,5 @@
-import { type MailboxMessage, readDeliveryState, readMailbox } from "../../state/mailbox.ts";
-import { loadRunManifestById } from "../../state/state-store.ts";
+import { type MailboxMessage, readDeliveryState, readMailbox } from "../../state/coordination/mailbox.ts";
+import { loadRunManifestById } from "../../state/stores/state-store.ts";
 import { pad, truncate } from "../../utils/visual.ts";
 import { keyOf } from "../key-utils.ts";
 import { asCrewTheme, type CrewTheme } from "../theme-adapter.ts";

package/src/ui/powerbar-publisher.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import type { CrewUiConfig } from "../config/config.ts";
 import { listRecentRuns } from "../extension/run-index.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
-import { listLiveAgents } from "../runtime/live-agent-manager.ts";
+import { listLiveAgents } from "../runtime/live-session/live-agent-manager.ts";
 import type { ManifestCache } from "../runtime/manifest-cache.ts";
 import { isDisplayActiveRun } from "../runtime/process-status.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";

package/src/ui/render-scheduler.ts

@@ -1,7 +1,7 @@
 import { logInternalError } from "../utils/internal-error.ts";
 
 export interface RenderSchedulerEventBus {
-	on?: (event: string, handler: (payload: unknown) => void) => (() => void) | void;
+	on?: (event: string, handler: (payload: unknown) => void) => (() => void) | undefined;
 }
 
 export interface RenderSchedulerOptions {

package/src/ui/run-action-dispatcher.ts

@@ -19,9 +19,9 @@ async function handleTeamTool(
 import { isToolError, textFromToolResult } from "../extension/tool-result.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { exportDiagnostic } from "../runtime/diagnostic-export.ts";
-import { appendEvent } from "../state/event-log.ts";
-import type { MailboxDirection, MailboxMessage } from "../state/mailbox.ts";
-import { loadRunManifestById, saveRunTasks } from "../state/state-store.ts";
+import type { MailboxDirection, MailboxMessage } from "../state/coordination/mailbox.ts";
+import { appendEvent } from "../state/event-log/event-log.ts";
+import { loadRunManifestById, saveRunTasks } from "../state/stores/state-store.ts";
 
 export interface RunActionResult {
 	ok: boolean;

package/src/ui/run-dashboard.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
-import { getLiveAgentContextPercent } from "../runtime/live-agent-manager.ts";
+import { getLiveAgentContextPercent } from "../runtime/live-session/live-agent-manager.ts";
 import { isDisplayActiveRun, isLikelyOrphanedActiveRun } from "../runtime/process-status.ts";
 import type { TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { aggregateUsage } from "../state/usage.ts";
@@ -10,6 +10,7 @@ import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
 import { pad, sanitizeLine, truncate, visibleWidth } from "../utils/visual.ts";
+import type { InteractiveComponent } from "./component.ts";
 import { renderAgentsPane } from "./dashboard-panes/agents-pane.ts";
 import { summarizeTerminalReason } from "./dashboard-panes/cancellation-pane.ts";
 import { renderHealthPane } from "./dashboard-panes/health-pane.ts";
@@ -40,11 +41,9 @@ function safeRenderPane(name: string, fn: () => string[]): string[] {
 	}
 }
 
-interface DashboardComponent {
-	invalidate(): void;
-	render(width: number): string[];
-	handleInput(data: string): void;
-}
+// PR-G3 (UI-3): extend the shared InteractiveComponent contract (render +
+// invalidate + handleInput). Structurally identical — no behavior change.
+interface DashboardComponent extends InteractiveComponent {}
 
 export interface RunDashboardOptions {
 	placement?: "center" | "right";
@@ -401,11 +400,6 @@ function countByStatus(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache
 }
 
 export class RunDashboard implements DashboardComponent {
-	// TEMP DIAGNOSTIC (remove after verifying keybind fix on Pi 0.81.1)
-	private static _instanceCounter = 0;
-	private readonly _instanceId: number;
-	// END TEMP DIAGNOSTIC
-
 	private selected = 0;
 	private runScrollOffset = 0;
 	private showFullProgress = false;
@@ -431,18 +425,6 @@ export class RunDashboard implements DashboardComponent {
 		theme: unknown = {},
 		options: RunDashboardOptions = {},
 	) {
-		// TEMP DIAGNOSTIC: log every constructor + handleInput + focus change
-		this._instanceId = ++RunDashboard._instanceCounter;
-		if (process.env.PI_CREW_BROKER_DIAG_UI === "1") {
-			try {
-				process.stderr.write(
-					`[PI-CREW-DIAG] RunDashboard#${this._instanceId}.constructor runs=${runs.length} workspaceId=${options.workspaceId ?? "n/a"}\n`,
-				);
-			} catch (error) {
-				logInternalError("run-dashboard.constructor-diag", error, undefined, "debug");
-			}
-		}
-		// END TEMP DIAGNOSTIC
 		// Filter runs by workspaceId for session isolation
 		// If workspaceId is provided, only show runs owned by that session or runs with no owner (legacy)
 		const filteredRuns = options.workspaceId
@@ -822,16 +804,6 @@ export class RunDashboard implements DashboardComponent {
 	public focused = false;
 
 	handleInput(data: string): void {
-		// TEMP DIAGNOSTIC (remove after verifying keybind fix on Pi 0.81.1)
-		if (process.env.PI_CREW_BROKER_DIAG_UI === "1") {
-			try {
-				process.stderr.write(
-					`[PI-CREW-DIAG] RunDashboard#${this._instanceId}.handleInput data=${JSON.stringify(data)} focused=${this.focused}\n`,
-				);
-			} catch (error) {
-				logInternalError("run-dashboard.handleInput-diag", error, undefined, "debug");
-			}
-		}
 		const action = dashboardActionForKey(data, this.activePane);
 		// K-1: "?" toggles the help overlay; while it is shown, any other key
 		// (including Esc) just dismisses it first instead of acting.

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

@@ -1,5 +1,5 @@
-import type { TeamEvent } from "../state/event-log.ts";
-import { readEventsCursor } from "../state/event-log.ts";
+import type { TeamEvent } from "../state/event-log/event-log.ts";
+import { readEventsCursor } from "../state/event-log/event-log.ts";
 import type { RenderSchedulerEventBus } from "./render-scheduler.ts";
 
 export type RunEventType =
@@ -342,7 +342,7 @@ export const runEventBus = new RunEventBus();
 export function runEventBusAsRenderScheduler(channels: readonly EventChannel[]): RenderSchedulerEventBus {
 	const allowed = new Set<EventChannel>(channels);
 	return {
-		on: (event: string, handler: (payload: unknown) => void): (() => void) | void => {
+		on: (event: string, handler: (payload: unknown) => void): (() => void) | undefined => {
 			if (!allowed.has(event as EventChannel)) return undefined;
 			return runEventBus.onChannel(event as EventChannel, handler);
 		},

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

@@ -4,10 +4,10 @@ import * as path from "node:path";
 import { agentOutputPath, agentsPath, readCrewAgents, readCrewAgentsAsync } from "../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { isActiveRunStatus } from "../runtime/process-status.ts";
-import type { TeamEvent } from "../state/event-log.ts";
-import { sequencePath } from "../state/event-log.ts";
-import type { MailboxMessageStatus } from "../state/mailbox.ts";
-import { loadRunManifestById, loadRunManifestByIdAsync } from "../state/state-store.ts";
+import type { MailboxMessageStatus } from "../state/coordination/mailbox.ts";
+import type { TeamEvent } from "../state/event-log/event-log.ts";
+import { sequencePath } from "../state/event-log/event-log.ts";
+import { loadRunManifestById, loadRunManifestByIdAsync } from "../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { extractDwfPhaseState } from "./dwf-phase-display.ts";
 import { runEventBus } from "./run-event-bus.ts";
@@ -629,15 +629,19 @@ async function mailboxFromAsync(manifest: TeamRunManifest, agents: CrewAgentReco
 	let outbox = await readMailboxCountsAsync(path.join(root, "outbox.jsonl"), delivery);
 	const tasksRoot = path.join(root, "tasks");
 	try {
-		for (const entry of await fs.promises.readdir(tasksRoot, {
-			withFileTypes: true,
-		})) {
-			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 = mergeKindCounts(inbox, taskInbox);
-			outbox = mergeKindCounts(outbox, taskOutbox);
-		}
+		// PR-F2 / UI-5 — batch the O(tasks) per-task inbox/outbox reads in
+		// parallel instead of sequential awaits on the async render path.
+		const taskDirs = (
+			await fs.promises.readdir(tasksRoot, {
+				withFileTypes: true,
+			})
+		).filter((entry) => entry.isDirectory());
+		const [taskInboxes, taskOutboxes] = await Promise.all([
+			Promise.all(taskDirs.map((entry) => readMailboxCountsAsync(path.join(tasksRoot, entry.name, "inbox.jsonl"), delivery))),
+			Promise.all(taskDirs.map((entry) => readMailboxCountsAsync(path.join(tasksRoot, entry.name, "outbox.jsonl"), delivery))),
+		]);
+		for (const ti of taskInboxes) inbox = mergeKindCounts(inbox, ti);
+		for (const to of taskOutboxes) outbox = mergeKindCounts(outbox, to);
 	} catch {
 		// No task mailboxes yet.
 	}
@@ -991,6 +995,21 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		evictIfNeeded();
 		return entry.snapshot;
 	}
+	// PR-F2 / UI-1 — in-flight async refresh dedup. Prevents multiple
+	// concurrent `preloadStale` calls for the same runId when the render
+	// path (refreshIfStale) and event-bus handler fire close together.
+	const inFlightRefreshes = new Set<string>();
+	function triggerAsyncRefresh(runId: string): void {
+		if (inFlightRefreshes.has(runId)) return;
+		inFlightRefreshes.add(runId);
+		void preloadStale(runId)
+			.catch(() => {
+				/* best-effort; widget falls back to cached snapshot */
+			})
+			.finally(() => {
+				inFlightRefreshes.delete(runId);
+			});
+	}
 	function localRefreshIfStale(runId: string): RunUiSnapshot {
 		const previous = entries.get(runId);
 		if (!previous) return localRefresh(runId);
@@ -1007,11 +1026,10 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		if (existing) clearTimeout(existing);
 		const timer = setTimeout(() => {
 			pendingRefreshes.delete(runId);
-			try {
-				localRefreshIfStale(runId);
-			} catch {
-				/* best-effort; widget falls back gracefully */
-			}
+			// PR-F2 / UI-1 — use the async refresh path (no sync fs on the
+			// event-bus hot path). triggerAsyncRefresh deduplicates
+			// concurrent refreshes.
+			triggerAsyncRefresh(runId);
 		}, INVAL_COALESCE_MS);
 		timer.unref();
 		pendingRefreshes.set(runId, timer);
@@ -1051,6 +1069,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		},
 		dispose(): void {
 			unsubscribe();
+			inFlightRefreshes.clear();
 			entries.clear();
 		},
 	};