pi-crew 0.9.44 → 0.9.47

package/src/state/locks.ts

@@ -447,6 +447,59 @@ const lockCtx = new AsyncLocalStorage<Set<string>>();
 // at the top of withFileLockSync for the full deadlock mechanism.
 const fileLockHeldByUs = new Map<string, string>(); // lockFile -> token
 
+// --- Async file lock (non-blocking alternative to withFileLockSync) ---
+// Uses a promise-chain pattern to serialize per-path access without blocking
+// the Node.js event loop. Unlike withFileLockSync (which uses O_EXCL +
+// sleepSync for cross-process safety), this is **in-process only** —
+// sufficient for single-process mailbox writes (team-runner is single-process).
+// Mirrors the structure of withEventLogLockAsync in event-log.ts.
+const fileAsyncLocks = new Map<string, Promise<unknown>>();
+
+// FIND-02 follow-up (P3): re-entrance guard for the async file lock, mirroring
+// the lockCtx pattern used by withRunLock. A future caller doing same-path
+// nested withFileLockAsync(path, ...) inside another withFileLockAsync(path,
+// ...) in the SAME async context would otherwise deadlock (the nested call
+// chains after the outer's still-pending promise). AsyncLocalStorage scopes
+// the held set to the current async context so cross-context callers still
+// serialize via the promise chain (Phase 1 mailbox path is unaffected).
+const fileAsyncLockCtx = new AsyncLocalStorage<Set<string>>();
+
+export async function withFileLockAsync<T>(filePath: string, fn: () => Promise<T>): Promise<T> {
+	// Re-entrant within the same async context — run fn() directly (no chaining).
+	// Same semantics as the sync guard in withFileLockSync (fileLockHeldByUs)
+	// and the async guard in withRunLock (lockCtx).
+	if (fileAsyncLockCtx.getStore()?.has(filePath)) {
+		return await fn();
+	}
+	// Merge with the parent context's held set so nested DIFFERENT-path locks
+	// also bypass correctly (prevents cross-path deadlock, matching withRunLock).
+	const prevHeld = fileAsyncLockCtx.getStore() ?? new Set<string>();
+	const held = new Set(prevHeld);
+	held.add(filePath);
+	const prev = fileAsyncLocks.get(filePath) ?? Promise.resolve();
+	// Chain fn after the previous holder. `next` may reject (propagating to the
+	// caller), but `stored` never rejects so subsequent waiters aren't blocked.
+	// fn() is wrapped in fileAsyncLockCtx.run so nested same-context calls see
+	// `held` and bypass the promise chain (re-entrant), while cross-context
+	// callers chain normally via `prev`.
+	const next = prev.then(() => fileAsyncLockCtx.run(held, () => fn()));
+	const stored = next.then(
+		() => undefined,
+		() => undefined,
+	);
+	fileAsyncLocks.set(filePath, stored);
+	try {
+		return await next;
+	} finally {
+		// Compare-and-delete: only remove our entry if it still points at `stored`.
+		// With 3+ overlapping callers, an earlier caller's finally would otherwise
+		// delete a later caller's promise, breaking mutual exclusion.
+		if (fileAsyncLocks.get(filePath) === stored) {
+			fileAsyncLocks.delete(filePath);
+		}
+	}
+}
+
 export function withRunLockSync<T>(manifest: TeamRunManifest, fn: () => T, options: RunLockOptions = {}): T {
 	const filePath = lockPath(manifest);
 	const staleMs = options.staleMs ?? DEFAULT_STALE_MS;

package/src/state/mailbox.ts

@@ -5,7 +5,7 @@ import { logInternalError } from "../utils/internal-error.ts";
 import { redactSecrets } from "../utils/redaction.ts";
 import { atomicWriteFile } from "./atomic-write.ts";
 import { withEventLogLockSync } from "./event-log.ts";
-import { withFileLockSync } from "./locks.ts";
+import { withFileLockAsync, withFileLockSync } from "./locks.ts";
 import type { TeamRunManifest } from "./types.ts";
 
 export type MailboxDirection = "inbox" | "outbox";
@@ -14,6 +14,47 @@ export type MailboxMessageKind = "message" | "steer" | "follow-up" | "response"
 export type MailboxMessagePriority = "urgent" | "normal" | "low";
 export type MailboxDeliveryMode = "interrupt" | "next_turn";
 
+// ============================================================================
+// Phase 1.3: post-append observer (single notification point)
+// ============================================================================
+// A registry of callbacks invoked AFTER a durable mailbox append completes
+// (both sync and async paths). The broker registers here to fan out live
+// notifications to connected recipients. The notifier is non-throwing and
+// never blocks the append — it queues work via queueMicrotask so a slow
+// observer cannot stall the mailbox write path. Registration is idempotent.
+
+export type MailboxAppendObserver = (message: MailboxMessage) => void;
+
+const mailboxAppendObservers = new Set<MailboxAppendObserver>();
+
+/** Register a post-append observer. Returns an unsubscribe function. */
+export function registerMailboxAppendObserver(fn: MailboxAppendObserver): () => void {
+	mailboxAppendObservers.add(fn);
+	return () => {
+		mailboxAppendObservers.delete(fn);
+	};
+}
+
+/**
+ * Internal: invoked by appendMailboxMessage[Async] AFTER the durable write +
+ * delivery RMW have completed. Non-throwing; never blocks the caller.
+ */
+function notifyMailboxAppended(message: MailboxMessage): void {
+	if (mailboxAppendObservers.size === 0) return;
+	// Snapshot the message so a later mutation by the caller cannot affect
+	// what the observer sees.
+	const snapshot = { ...message };
+	queueMicrotask(() => {
+		for (const fn of mailboxAppendObservers) {
+			try {
+				fn(snapshot);
+			} catch {
+				/* observer must not break the append path */
+			}
+		}
+	});
+}
+
 export interface MailboxMessage {
 	id: string;
 	runId: string;
@@ -377,19 +418,61 @@ function readAllInboxMessages(manifest: TeamRunManifest): MailboxMessage[] {
 	return readAllMessages(manifest, "inbox");
 }
 
+// FIND-01: in-process delivery cache to avoid O(N²) re-reads on every append.
+// Keyed by delivery file path; invalidated by mtime check on read + updated on
+// write. Team-runner is single-process so in-process caching is sufficient.
+const deliveryCache = new Map<string, { mtimeMs: number; state: MailboxDeliveryState }>();
+const MAX_DELIVERY_CACHE_ENTRIES = 256;
+// R1 review fix: setDeliveryCacheEntry stores an immutable snapshot (deep
+// copy of `messages`) so callers mutating the returned state cannot corrupt
+// the cache (TOCTOU race), and bounds the map size with FIFO eviction to
+// prevent unbounded growth across runs.
+function setDeliveryCacheEntry(filePath: string, entry: { mtimeMs: number; state: MailboxDeliveryState }): void {
+	if (deliveryCache.size >= MAX_DELIVERY_CACHE_ENTRIES) {
+		const oldest = deliveryCache.keys().next().value;
+		if (oldest !== undefined) deliveryCache.delete(oldest);
+	}
+	deliveryCache.set(filePath, {
+		mtimeMs: entry.mtimeMs,
+		state: { ...entry.state, messages: { ...entry.state.messages } },
+	});
+}
+
 export function readDeliveryState(manifest: TeamRunManifest): MailboxDeliveryState {
+	const filePath = deliveryFile(manifest);
+	let stat: fs.Stats;
+	try {
+		stat = fs.statSync(filePath);
+	} catch (e) {
+		// R1 review fix: narrow to ENOENT so permission errors aren't silently
+		// treated as "missing file" (would wipe a valid cache entry).
+		if ((e as NodeJS.ErrnoException).code !== "ENOENT") throw e;
+		deliveryCache.delete(filePath);
+		return { messages: {}, updatedAt: new Date().toISOString() };
+	}
+	const cached = deliveryCache.get(filePath);
+	if (cached && cached.mtimeMs === stat.mtimeMs) {
+		// R2 review fix: return a copy so callers mutating the result cannot
+		// leak into the cached snapshot (residual TOCTOU: the cache holds the
+		// snapshot until the next write replaces it; without this copy, a
+		// pre-write mutation by one caller would be persisted into the
+		// post-write snapshot by the next writer's setDeliveryCacheEntry).
+		return { ...cached.state, messages: { ...cached.state.messages } };
+	}
 	try {
-		const raw = JSON.parse(fs.readFileSync(deliveryFile(manifest), "utf-8")) as unknown;
+		const raw = JSON.parse(fs.readFileSync(filePath, "utf-8")) as unknown;
 		if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Invalid delivery state.");
 		const obj = raw as Record<string, unknown>;
 		const messages: Record<string, MailboxMessageStatus> = {};
 		if (obj.messages && typeof obj.messages === "object" && !Array.isArray(obj.messages)) {
 			for (const [id, status] of Object.entries(obj.messages)) if (isStatus(status)) messages[id] = status;
 		}
-		return {
+		const state: MailboxDeliveryState = {
 			messages,
 			updatedAt: typeof obj.updatedAt === "string" ? obj.updatedAt : new Date().toISOString(),
 		};
+		setDeliveryCacheEntry(filePath, { mtimeMs: stat.mtimeMs, state });
+		return state;
 	} catch {
 		return { messages: {}, updatedAt: new Date().toISOString() };
 	}
@@ -414,9 +497,20 @@ function writeDeliveryState(
 	// F4: mailbox delivery is informational — accept losing the very last write on
 	// a hard crash (the next message will overwrite it on disk). Cheaper fsync on
 	// the hot path; terminal/reply paths still pass full durability below.
-	atomicWriteFile(deliveryFile(manifest, true), `${JSON.stringify(redactSecrets(state), null, 2)}\n`, {
+	const filePath = deliveryFile(manifest, true);
+	atomicWriteFile(filePath, `${JSON.stringify(redactSecrets(state), null, 2)}\n`, {
 		durability: options?.durability ?? "best-effort",
 	});
+	// FIND-01: update cache with post-write mtime so subsequent reads get a hit.
+	try {
+		const postStat = fs.statSync(filePath);
+		// setDeliveryCacheEntry stores an immutable snapshot (deep copy of
+		// messages) so subsequent read-modify-write callers mutating the
+		// returned state cannot corrupt the cache.
+		setDeliveryCacheEntry(filePath, { mtimeMs: postStat.mtimeMs, state });
+	} catch {
+		deliveryCache.delete(filePath);
+	}
 }
 
 /**
@@ -486,6 +580,7 @@ export function appendMailboxMessage(
 		// F4: complete transitions are terminal-ish — keep full durability.
 		writeDeliveryState(manifest, delivery, { durability: "full" });
 	});
+	notifyMailboxAppended(complete);
 	return complete;
 }
 
@@ -541,6 +636,115 @@ export function appendFollowUpMessage(
 	});
 }
 
+/**
+ * FIND-02: Async variant of appendMailboxMessage for the live-session path.
+ * Uses withFileLockAsync (promise-chain, no sleepSync) instead of
+ * withEventLogLockSync/withFileLockSync, preventing event-loop stalls during
+ * steering/follow-up delivery. readDeliveryState/writeDeliveryState remain
+ * sync but are cheap thanks to the FIND-01 delivery cache.
+ */
+export async function appendMailboxMessageAsync(
+	manifest: TeamRunManifest,
+	message: Omit<MailboxMessage, "id" | "runId" | "createdAt" | "status"> & {
+		id?: string;
+		status?: MailboxMessageStatus;
+	},
+): Promise<MailboxMessage> {
+	if (message.taskId) ensureTaskMailbox(manifest, message.taskId);
+	else ensureRunMailbox(manifest);
+	const createdAt = new Date().toISOString();
+	const complete: MailboxMessage = {
+		id: message.id ?? `msg_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+		runId: manifest.runId,
+		direction: message.direction,
+		from: message.from,
+		to: message.to,
+		body: message.body,
+		createdAt,
+		status: message.status ?? "queued",
+		kind: message.kind,
+		priority: message.priority,
+		deliveryMode: message.deliveryMode,
+		taskId: message.taskId,
+		data: message.data,
+		replyTo: message.replyTo,
+		replyFrom: message.replyFrom,
+		replyDeadline: message.replyDeadline,
+		repliedAt: message.repliedAt,
+		replyContent: message.replyContent,
+	};
+	const mbFile = mailboxFile(manifest, complete.direction, complete.taskId);
+	await withFileLockAsync(mbFile, async () => {
+		await fs.promises.appendFile(mbFile, `${JSON.stringify(redactSecrets(complete))}\n`, "utf-8");
+		rotateMailboxFileIfNeeded(mbFile);
+	});
+	// R1 review fix / plan §5 #6: delivery RMW uses the cross-process sync
+	// lock (withFileLockSync) so sync callers (acknowledgeMailboxMessage,
+	// replayPendingMailboxMessages) serialize against this async path. The
+	// body has no await, so sync locking is safe and restores the
+	// cross-process safety net that the async lock cannot provide.
+	withFileLockSync(deliveryFile(manifest, true), () => {
+		const delivery = readDeliveryState(manifest);
+		delivery.messages[complete.id] = complete.status;
+		delivery.updatedAt = createdAt;
+		writeDeliveryState(manifest, delivery, { durability: "full" });
+	});
+	notifyMailboxAppended(complete);
+	return complete;
+}
+
+export async function appendSteeringMessageAsync(
+	manifest: TeamRunManifest,
+	input: {
+		taskId: string;
+		body: string;
+		from?: string;
+		to?: string;
+		priority?: MailboxMessagePriority;
+		status?: MailboxMessageStatus;
+		data?: Record<string, unknown>;
+	},
+): Promise<MailboxMessage> {
+	return appendMailboxMessageAsync(manifest, {
+		direction: "inbox",
+		from: input.from ?? "leader",
+		to: input.to ?? input.taskId,
+		taskId: input.taskId,
+		body: input.body,
+		kind: "steer",
+		priority: input.priority ?? "urgent",
+		deliveryMode: "interrupt",
+		status: input.status,
+		data: { ...(input.data ?? {}), kind: "steer" },
+	});
+}
+
+export async function appendFollowUpMessageAsync(
+	manifest: TeamRunManifest,
+	input: {
+		taskId: string;
+		body: string;
+		from?: string;
+		to?: string;
+		priority?: MailboxMessagePriority;
+		status?: MailboxMessageStatus;
+		data?: Record<string, unknown>;
+	},
+): Promise<MailboxMessage> {
+	return appendMailboxMessageAsync(manifest, {
+		direction: "inbox",
+		from: input.from ?? "leader",
+		to: input.to ?? input.taskId,
+		taskId: input.taskId,
+		body: input.body,
+		kind: "follow-up",
+		priority: input.priority ?? "normal",
+		deliveryMode: "next_turn",
+		status: input.status,
+		data: { ...(input.data ?? {}), kind: "follow-up" },
+	});
+}
+
 export function listMailboxByKind(manifest: TeamRunManifest, kind: MailboxMessageKind, direction?: MailboxDirection): MailboxMessage[] {
 	const messages = direction
 		? readAllMessages(manifest, direction)

package/src/state/run-metrics.ts

@@ -107,6 +107,16 @@ export function loadRunMetrics(cwd: string, runId: string): RunMetrics | undefin
  * List recent metrics files up to `limit` entries (newest first).
  * Returns an array of { runId, timestamp, taskCount, completedCount, failedCount, totalTokens, totalCost, durationMs, consistencyScore }.
  * Gracefully skips files that cannot be read or parsed.
+ *
+ * FIND-04 perf: sort dirents by mtime descending BEFORE reading any of
+ * them, then read at most `limit` files. Malformed files within that
+ * selected window reduce the returned count; the scan does not continue
+ * past the window to backfill them. Previously the function read up
+ * to MAX_METRIC_FILES_TO_SCAN (500) files via loadRunMetrics() and only
+ * THEN sorted+sliced to `limit` (default 25) — wasting 475 readFileSync +
+ * JSON.parse calls on the hot dashboard path. The sort is O(N log N) and
+ * uses the run-id timestamp prefix as a cheap secondary signal when
+ * mtimes tie (e.g. multiple files saved in the same millisecond).
  */
 export function getRunMetricsSummary(cwd: string, limit = 25): RunMetrics[] {
 	const dir = metricsDir(cwd);
@@ -117,21 +127,39 @@ export function getRunMetricsSummary(cwd: string, limit = 25): RunMetrics[] {
 		return [];
 	}
 
+	// Cap the directory-order candidate set before collecting mtimes. This
+	// is a safety valve against unbounded scan cost; the mtime sort below
+	// only reorders entries within this bounded candidate window.
+	const cap = Math.max(0, limit);
+	const sorted = entries
+		.filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+		.slice(0, MAX_METRIC_FILES_TO_SCAN)
+		.map((entry) => {
+			const fullPath = path.join(dir, entry.name);
+			let mtimeMs = 0;
+			try {
+				mtimeMs = fs.statSync(fullPath).mtimeMs;
+			} catch {
+				// stat failure: fall through with mtimeMs=0; the sort still
+				// produces a deterministic order (filenames tiebreak).
+			}
+			return { name: entry.name, mtimeMs };
+		})
+		.sort((a, b) => {
+			const diff = b.mtimeMs - a.mtimeMs;
+			if (diff !== 0) return diff;
+			// Filename tiebreaker: the run-id prefix is a YYYYMMDDhhmmss
+			// timestamp (e.g. team_20260720050617_abc123) so a descending
+			// string compare yields newest-first within a tie group.
+			return b.name.localeCompare(a.name);
+		});
+
 	const metrics: RunMetrics[] = [];
-	for (const entry of entries) {
-		if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-		const runId = entry.name.replace(/\.json$/, "");
+	for (const { name } of sorted.slice(0, cap)) {
+		const runId = name.replace(/\.json$/, "");
 		const m = loadRunMetrics(cwd, runId);
 		if (m) metrics.push(m);
-		if (metrics.length >= MAX_METRIC_FILES_TO_SCAN) break;
 	}
 
-	// Sort newest first (by timestamp, then runId as tiebreaker).
-	metrics.sort((a, b) => {
-		const diff = new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
-		if (diff !== 0) return diff;
-		return b.runId.localeCompare(a.runId);
-	});
-
-	return metrics.slice(0, limit);
+	return metrics;
 }

package/src/ui/key-utils.ts

@@ -0,0 +1,42 @@
+/**
+ * key-utils.ts — Centralised key matching helpers.
+ *
+ * Pi 0.81+'s TUI input layer (`@earendil-works/pi-tui`) ships a `matchesKey()`
+ * helper that handles multiple terminal key encodings: legacy CSI escapes
+ * (`\x1b[A`), application cursor mode (`\x1bOA`), and Kitty keyboard protocol
+ * variants. Pi-crew components previously compared against raw escape bytes
+ * (`data === "\x1b[A"`), which silently failed on terminals that emit the
+ * alternate encodings. This module wraps `matchesKey` with a single
+ * `keyOf()` helper so overlay code reads naturally while picking up the
+ * terminal-aware match logic for free.
+ *
+ * Returns the canonical KeyId when matchesKey recognises it, otherwise the
+ * raw input string so callers can fall through to ASCII-letter shortcuts.
+ */
+import { type KeyId, matchesKey } from "@earendil-works/pi-tui";
+
+export type PiKeyName = KeyId | string;
+
+const COMMON_IDS: readonly KeyId[] = [
+	"up",
+	"down",
+	"left",
+	"right",
+	"enter",
+	"escape",
+	"tab",
+	"shift+tab",
+	"space",
+	"backspace",
+	"home",
+	"end",
+	"pageUp",
+	"pageDown",
+];
+
+export function keyOf(data: string): KeyId | string {
+	for (const id of COMMON_IDS) {
+		if (matchesKey(data, id)) return id;
+	}
+	return data;
+}

package/src/ui/keybinding-map.ts

@@ -23,9 +23,12 @@
  * `use-global-shortcuts.ts:38-61`.
  */
 
+import { type KeyId, matchesKey } from "@earendil-works/pi-tui";
+import { keyOf } from "./key-utils.ts";
+
 export const DASHBOARD_KEYS = {
-	close: ["q", "\u001b"],
-	select: ["\r", "\n", "s"],
+	close: ["q", "escape", "\u001b"],
+	select: ["enter", "s", "\r", "\n", "tab", "\t", " "],
 	help: ["?"],
 	root: {
 		summary: ["u"],
@@ -48,7 +51,7 @@ export const DASHBOARD_KEYS = {
 		health: ["5"],
 		metrics: ["6"],
 	},
-	navigation: { up: ["k", "\u001b[A"], down: ["j", "\u001b[B"] },
+	navigation: { up: ["k", "up"], down: ["j", "down"] },
 	mailbox: {
 		ack: ["A"],
 		nudge: ["N"],
@@ -214,9 +217,32 @@ export { KEY_RESERVED };
  *                   arg skipped the `activePane === ...` branches).
  */
 export function dashboardActionForKey(data: string, activePane?: ActivePane): DashboardKeyAction | undefined {
+	// Two-pass dispatch to preserve case-sensitivity for plain ASCII keys
+	// while still normalizing escape sequences via matchesKey().
+	//
+	// Background: pi-tui's matchesKey() is case-insensitive, so matchesKey("d",
+	// "D") === true. A single-pass loop that intermixes exact + matchesKey
+	// checks would let the pane-scoped health-diagnostic-export binding
+	// (candidate "D") win over the unscoped agents binding (candidate "d")
+	// when activePane === "health" — collapsing the d/D case distinction.
+	//
+	// Pass 1 — exact string match (case-sensitive). Handles literal ASCII
+	// keystrokes ('d', 'D', 'q', 'S', …) and preserves their distinct meanings.
 	for (const binding of BINDINGS) {
 		if (binding.pane !== undefined && binding.pane !== activePane) continue;
 		if (binding.keys.includes(data)) return binding.action;
 	}
+	// Pass 2 — terminal-aware match for escape sequences / canonical KeyIds.
+	// Only reached when no exact ASCII match exists (data is e.g. '\x1b[A',
+	// '\x1bOA', or an app-cursor-mode variant). Uses matchesKey() to normalize
+	// legacy CSI, app-cursor-mode, and Kitty-protocol variants uniformly.
+	const key = keyOf(data);
+	for (const binding of BINDINGS) {
+		if (binding.pane !== undefined && binding.pane !== activePane) continue;
+		for (const candidate of binding.keys) {
+			if (key === candidate) return binding.action;
+			if (matchesKey(data, candidate as KeyId)) return binding.action;
+		}
+	}
 	return undefined;
 }

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

@@ -8,7 +8,6 @@ import type { TeamTaskState } from "../state/types.ts";
 import { aggregateUsage, formatUsage } from "../state/usage.ts";
 import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
 import { pad, truncate } from "../utils/visual.ts";
-import { Box, Text } from "./layout-primitives.ts";
 import { RenderScheduler } from "./render-scheduler.ts";
 import { runEventBusAsRenderScheduler } from "./run-event-bus.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
@@ -16,17 +15,10 @@ import { spinnerBucket, spinnerFrame } from "./spinner.ts";
 import { colorizeStatusGlyphs, iconForStatus } from "./status-colors.ts";
 import type { CrewTheme } from "./theme-adapter.ts";
 import { asCrewTheme, subscribeThemeChange } from "./theme-adapter.ts";
+import { renderLines } from "./widget/widget-renderer.ts";
 
 const TASK_READ_TTL_MS = 200;
 
-function renderLines(lines: string[], width: number): string[] {
-	const box = new Box(0, 0);
-	for (const line of lines) {
-		box.addChild(new Text(line));
-	}
-	return box.render(width);
-}
-
 type Done = (value: undefined) => void;
 
 function line(text: string, width: number): string {

package/src/ui/run-dashboard.ts

@@ -19,7 +19,6 @@ import { renderProgressPane } from "./dashboard-panes/progress-pane.ts";
 import { renderTranscriptPane } from "./dashboard-panes/transcript-pane.ts";
 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 { RenderScheduler } from "./render-scheduler.ts";
 import { runEventBusAsRenderScheduler } from "./run-event-bus.ts";
@@ -28,6 +27,7 @@ import { spinnerBucket, spinnerFrame } from "./spinner.ts";
 import { applyStatusColor, colorizeStatusGlyphs, iconForStatus, type RunStatus } from "./status-colors.ts";
 import type { CrewTheme } from "./theme-adapter.ts";
 import { asCrewTheme, subscribeThemeChange } from "./theme-adapter.ts";
+import { renderLines } from "./widget/widget-renderer.ts";
 
 /** S05 — wrap a pane render in try/catch so a single pane crash does not bring down the whole dashboard. */
 function safeRenderPane(name: string, fn: () => string[]): string[] {
@@ -159,14 +159,6 @@ function formatAge(iso: string | undefined): string | undefined {
 	return `${Math.floor(ms / 3_600_000)}h`;
 }
 
-function renderLines(lines: string[], width: number): string[] {
-	const box = new Box(0, 0);
-	for (const line of lines) {
-		box.addChild(new Text(line));
-	}
-	return box.render(width);
-}
-
 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
@@ -409,6 +401,11 @@ 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;
@@ -434,6 +431,14 @@ export class RunDashboard implements DashboardComponent {
 		theme: unknown = {},
 		options: RunDashboardOptions = {},
 	) {
+		// TEMP DIAGNOSTIC: log every constructor + handleInput + focus change
+		this._instanceId = ++RunDashboard._instanceCounter;
+		try {
+			process.stderr.write(
+				`[PI-CREW-DIAG] RunDashboard#${this._instanceId}.constructor runs=${runs.length} workspaceId=${options.workspaceId ?? "n/a"}\n`,
+			);
+		} catch {}
+		// 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
@@ -814,7 +819,22 @@ export class RunDashboard implements DashboardComponent {
 		return this.cachedLines;
 	}
 
+	// Pi 0.81+ requires the Focusable contract: a string-indexable `focused`
+	// marker that TUI toggles to track which component currently receives
+	// input. Without it, isFocusable() returns false and downstream
+	// dispatch may skip the component. Declared as an own property so
+	// `"focused" in component` is true.
+	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 {}
+		}
 		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.