pi-crew 0.11.7 → 0.11.9

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

@@ -1,3 +1,4 @@
+import { formatCount } from "../format-helpers.ts";
 import { formatHint } from "../rail.ts";
 import type { RunUiSnapshot } from "../snapshot-types.ts";
 
@@ -8,24 +9,28 @@ export function renderMailboxPane(snapshot: RunUiSnapshot | undefined): string[]
 	const unread = mailbox.inboxUnread ?? 0;
 	const outgoing = mailbox.outboxPending ?? 0;
 	const attention = mailbox.needsAttention ?? 0;
-	const lines: string[] = [`Mailbox pane: inbox unread=${unread} · outbox pending=${outgoing} · attention=${attention}${approx}`];
-	// Kind-separated breakdown
+	// L7 dialect: counts speak the compactUsage TUI form (the `↑2.8k ↓3.7k`
+	// pattern from live-run-sidebar.ts), NOT the `unread=2` wire format. ↓ =
+	// received (inbox), ↑ = sent (outbox pending); ⚠ marks attention (the same
+	// pane-local warning glyph the steering line below already uses).
+	const lines: string[] = [`Mailbox pane: ↓${unread} unread · ↑${outgoing} pending · ⚠${attention} attention${approx}`];
+	// Kind-separated breakdown — every kind here is an inbox (received) count.
 	const kindParts: string[] = [];
 	const steer = mailbox.steerUnread ?? 0;
 	const followUp = mailbox.followUpUnread ?? 0;
 	const response = mailbox.responseUnread ?? 0;
 	const message = mailbox.messageUnread ?? 0;
-	if (steer > 0) kindParts.push(`steer=${steer}`);
-	if (followUp > 0) kindParts.push(`follow-up=${followUp}`);
-	if (response > 0) kindParts.push(`response=${response}`);
-	if (message > 0) kindParts.push(`message=${message}`);
+	if (steer > 0) kindParts.push(`↓${steer} steer`);
+	if (followUp > 0) kindParts.push(`↓${followUp} follow-up`);
+	if (response > 0) kindParts.push(`↓${response} response`);
+	if (message > 0) kindParts.push(`↓${message} message`);
 	if (kindParts.length > 0) {
 		lines.push(`  Breakdown: ${kindParts.join(" · ")}`);
 		if (steer > 0) {
 			lines.push("  ⚠ Urgent: steering messages require immediate attention.");
 		}
 		if (followUp > 0) {
-			lines.push(`  📋 ${followUp} follow-up(s) pending review.`);
+			lines.push(`  📋 ${formatCount(followUp, "follow-up")} pending review.`);
 		}
 	}
 	if (attention > 0) {

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

@@ -17,6 +17,7 @@
 import { isPlanApprovalPending } from "../../runtime/plan-approval.ts";
 import { deriveItemProgress } from "../../state/stores/plan-store.ts";
 import type { PlanItemStatus, TeamTaskState } from "../../state/types.ts";
+import { formatCount } from "../format-helpers.ts";
 import { ACTIVE, formatHint, statusIcon } from "../rail.ts";
 
 /**
@@ -99,7 +100,9 @@ export function planRevisionDiff(snapshot: RunUiSnapshot): string[] {
 		const beforeTasks = before.taskIds?.length ?? 0;
 		const currentTasks = item.taskIds?.length ?? 0;
 		if (before.status !== item.status || beforeTasks !== currentTasks) {
-			lines.push(`  ~ ${item.id} ${item.title ?? "?"} [${before.status}→${item.status} · ${beforeTasks}→${currentTasks} tasks]`);
+			lines.push(
+				`  ~ ${item.id} ${item.title ?? "?"} [${before.status}→${item.status} · ${beforeTasks}→${formatCount(currentTasks, "task")}]`,
+			);
 		}
 		prevItems.delete(item.id);
 	}
@@ -128,7 +131,7 @@ export function renderPlanPane(snapshot: RunUiSnapshot, options: PlanPaneOptions
 	const itemById = new Map(items.map((i) => [i.id, i]));
 
 	const pending = isPlanApprovalPending(snapshot.manifest);
-	const header = `Plan pane: ${current.title ?? "?"} @v${current.version} (${phases.length} phases · ${items.length} items)`;
+	const header = `Plan pane: ${current.title ?? "?"} @v${current.version} (${formatCount(phases.length, "phase")} · ${formatCount(items.length, "item")})`;
 	// Hint join format is the rail one (` · `, close/deny last). NOT routed
 	// through `formatHint` (yet): its `keyToken` upper-cases a bare letter
 	// (`n` → `N`) and the locked pane test

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

@@ -8,8 +8,14 @@ export function renderProgressPane(snapshot: RunUiSnapshot | undefined): string[
 	if (!snapshot) return ["Progress pane: snapshot unavailable"];
 	const progress = snapshot.progress;
 	const groupJoins = snapshot.groupJoins ?? [];
+	// L7 judgment: the header and group-join lines speak the count-first tally
+	// dialect (`1 running · 0 queued`, `req-123 · acknowledged`), not the
+	// `running=1`/`ack=acknowledged` wire format. The ONE deliberate
+	// key=value survivor is `reason=` below: the cancellation reason is a
+	// machine code (`leader_interrupted`) — diagnostic data, not prose, and
+	// the shape (not the wording) is what the operator greps for.
 	const groupJoinLines = groupJoins.length
-		? groupJoins.map((item) => `group join ${item.partial ? "partial" : "completed"}: ${item.requestId} ack=${item.ack}`)
+		? groupJoins.map((item) => `group join ${item.partial ? "partial" : "completed"}: ${item.requestId} · ${item.ack}`)
 		: ["group joins: none"];
 	const cancellationLine = snapshot.cancellationReason ? [`cancelled: reason=${snapshot.cancellationReason}`] : [];
 	const runProgress = computePhaseProgress(snapshot.tasks);
@@ -30,7 +36,7 @@ export function renderProgressPane(snapshot: RunUiSnapshot | undefined): string[
 	// uncolored by design). One line while the run is parked on approval.
 	const planBanner = isPlanApprovalPending(snapshot.manifest) ? [`⚠ plan approval pending — ${PLAN_APPROVAL_HINT}`] : [];
 	return [
-		`Progress pane: ${progress.completed}/${progress.total} completed · running=${progress.running} queued=${progress.queued} failed=${progress.failed}`,
+		`Progress pane: ${progress.completed}/${progress.total} completed · ${progress.running} running · ${progress.queued} queued · ${progress.failed} failed`,
 		...planBanner,
 		...dwfPhaseLines,
 		...phaseHeader,

package/src/ui/format-helpers.ts

@@ -12,6 +12,17 @@ export function formatTokens(n: number): string {
 	return `${(n / 1_000_000).toFixed(1)}M`;
 }
 
+/**
+ * Canonical generic duration formatter (QW#5 collision resolution):
+ * `45ms` / `12.3s` / `3m5s` / `75m` — minutes are unbounded (no hours
+ * bucket) and there is no invalid-input guard. Two same-stemmed helpers are
+ * DELIBERATELY separate dialects and must not be merged into this one
+ * (their output formats are design-pinned):
+ *   - `formatTaskElapsed` (ui/widget/task-list.ts) — plan-card elapsed:
+ *     `2m 49s` / `1h 03m`, empty string on invalid input.
+ *   - `formatRelativeCompact` (utils/relative-time.ts) — relative-time
+ *     ladder buckets `84m` / `14h` / `2d14h`.
+ */
 export function formatDuration(ms: number): string {
 	if (ms < 1000) return `${ms}ms`;
 	if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;

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

@@ -28,7 +28,7 @@
 import { matchesKey } from "@earendil-works/pi-tui";
 import type { LiveAgentHandle } from "../runtime/live-session/live-agent-manager.ts";
 import { truncate } from "../utils/visual.ts";
-import { formatCount } from "./format-helpers.ts";
+import { formatCount, formatDuration } from "./format-helpers.ts";
 import { computeLiveDurationMs } from "./live-duration.ts";
 import { canopyLine, formatHint, gaugeBar, RAIL, railLeaders, railLine, statusSlot } from "./rail.ts";
 import { spinnerFrame } from "./spinner.ts";
@@ -120,7 +120,9 @@ export class LiveConversationOverlay {
 
 	private refreshSummary(): void {
 		const act = this.handle.activity;
-		const summary = `${LiveConversationOverlay.SUMMARY_PREFIX}[${formatCount(act.turnCount ?? 0, "turn")} · ${formatCount(act.toolUses ?? 0, "tool")} · ${(computeLiveDurationMs(act, this.nowMs()) / 1000).toFixed(1)}s]`;
+		// L9: durations speak formatDuration (`5m44s`), never raw
+		// `(ms/1000).toFixed(1)s` seconds (`344.0s`).
+		const summary = `${LiveConversationOverlay.SUMMARY_PREFIX}[${formatCount(act.turnCount ?? 0, "turn")} · ${formatCount(act.toolUses ?? 0, "tool")} · ${formatDuration(computeLiveDurationMs(act, this.nowMs()))}]`;
 		const lastLine = this.cachedLines[this.cachedLines.length - 1];
 		if (lastLine?.startsWith(LiveConversationOverlay.SUMMARY_PREFIX)) {
 			this.cachedLines[this.cachedLines.length - 1] = summary;
@@ -270,7 +272,7 @@ export class LiveConversationOverlay {
 		if (act.maxTurns != null) parts.push(`turn ${act.turnCount ?? 0}/${act.maxTurns}`);
 		else if ((act.turnCount ?? 0) > 0) parts.push(`turn ${act.turnCount}`);
 		if ((act.toolUses ?? 0) > 0) parts.push(formatCount(act.toolUses ?? 0, "tool"));
-		parts.push(`${(computeLiveDurationMs(act, this.nowMs()) / 1000).toFixed(1)}s`);
+		parts.push(formatDuration(computeLiveDurationMs(act, this.nowMs())));
 		try {
 			const ctxPct = this.handle.session.getSessionStats?.()?.contextUsage?.percent;
 			if (ctxPct != null) {

package/src/ui/live-duration.ts

@@ -49,7 +49,8 @@ export function computeLiveDurationMs(activity: LiveActivity, nowMs: number = Da
 	return Number.isFinite(ms) && ms >= 0 ? ms : 0;
 }
 
-/** Format a live duration in seconds, e.g. `12.3s`. Returns `0.0s` for 0. */
-export function formatLiveDuration(activity: LiveActivity, nowMs: number = Date.now()): string {
-	return `${(computeLiveDurationMs(activity, nowMs) / 1000).toFixed(1)}s`;
-}
+// L9 note: the `formatLiveDuration` export was deleted (2026-10-07). It had
+// zero production importers — its raw-seconds `(ms/1000).toFixed(1)s` output
+// was exactly the wire format the dialect sweep retires; every live surface
+// now formats via `formatDuration` (format-helpers.ts) over
+// `computeLiveDurationMs`.

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

@@ -12,9 +12,12 @@ import { formatCount, teamWorkflowLabel } from "./format-helpers.ts";
 import { goalFlagSuffix } from "./goal-flag.ts";
 import { DASHBOARD_KEYS } from "./keybinding-map.ts";
 import { ACTIVE, canopyLine, formatHint, RAIL, type RailSlot, railLine, sectionLine, shortId, statusSlot } from "./rail.ts";
+// L5: the EXTENDED cache interface — the base type in snapshot-types.ts does
+// not declare the paint-path accessor (readForRender) or scheduleRefresh.
+import type { RunSnapshotCache } from "./run-snapshot-cache.ts";
 import type { OverlaySchedulerHandle } from "./shared-overlay-scheduler.ts";
 import { registerOverlayScheduler } from "./shared-overlay-scheduler.ts";
-import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
+import type { RunUiSnapshot } from "./snapshot-types.ts";
 import { spinnerBucket, spinnerFrame } from "./spinner.ts";
 import { colorizeStatusGlyphs, iconForStatus } from "./status-colors.ts";
 import type { CrewTheme } from "./theme-adapter.ts";
@@ -79,6 +82,9 @@ export class LiveRunSidebar {
 	private cachedWidth = 0;
 	private cachedSignature = "";
 	private autoCloseTimeout?: NodeJS.Timeout;
+	/** L4 (real-test 2026-10-07): FIXED close deadline (epoch ms), captured
+	 * ONCE on first eligibility — re-renders must never slide it. */
+	private autoCloseDeadline?: number;
 	private hasAutoClosed = false;
 
 	constructor(input: {
@@ -157,10 +163,7 @@ export class LiveRunSidebar {
 		// M-10 fix (code-review 2026-06-23): clear the auto-close timer so a
 		// disposed sidebar (not closed via the normal path) doesn't fire this.done()
 		// on a disposed component.
-		if (this.autoCloseTimeout) {
-			clearTimeout(this.autoCloseTimeout);
-			this.autoCloseTimeout = undefined;
-		}
+		this.clearAutoClose();
 		this.unsubscribeTheme();
 		this.schedulerHandle.dispose();
 	}
@@ -180,8 +183,15 @@ export class LiveRunSidebar {
 		let rawAgents: ReturnType<typeof readCrewAgents>;
 		let snapshot: RunUiSnapshot | undefined;
 		if (this.snapshotCache) {
+			// L5 (real-test 2026-10-07): the paint path reads the cache ONLY.
+			// refreshIfStale rebuilt synchronously between paints (multiple stats +
+			// manifest/tasks parse + sha256), stuttering frame pacing. readForRender
+			// returns the cached snapshot and schedules the COALESCED ASYNC refresh
+			// when the entry's TTL has lapsed; a missing entry schedules nothing, so
+			// kick one here or the pre-load frame below would never fill.
 			try {
-				snapshot = this.snapshotCache.refreshIfStale(this.runId);
+				snapshot = this.snapshotCache.readForRender(this.runId);
+				if (!snapshot) this.snapshotCache.scheduleRefresh(this.runId);
 			} catch {
 				snapshot = undefined;
 			}
@@ -331,25 +341,29 @@ export class LiveRunSidebar {
 			}
 			// F-6: compute the auto-close countdown BEFORE the cap so the countdown
 			// renders inside the frame rather than below it.
-			// Auto-close logic: if run is terminal and no active agents, close after delay
+			// Auto-close logic: if run is terminal and no active agents, close after delay.
+			// L4 (real-test 2026-10-07): the deadline is captured ONCE on FIRST
+			// eligibility and never re-armed while eligibility persists. The old code
+			// did clearTimeout+setTimeout(full delay) on every fresh render, so any
+			// trailing event < autoCloseMs apart slid the deadline forever and the
+			// countdown froze while the sidebar stayed open indefinitely.
 			const isTerminal = ["completed", "failed", "cancelled", "blocked"].includes(run.status);
 			const hasActiveAgents = agents.some((a) => a.status === "running");
 			if (isTerminal && !hasActiveAgents && !this.hasAutoClosed) {
 				const autoCloseMs = this.config?.autoCloseDashboardMs ?? 3000;
 				if (autoCloseMs > 0) {
-					if (this.autoCloseTimeout) clearTimeout(this.autoCloseTimeout);
-					this.autoCloseTimeout = setTimeout(() => {
-						this.hasAutoClosed = true;
-						this.done(undefined);
-					}, autoCloseMs);
-					this.autoCloseTimeout?.unref();
-					lines.push(this.bodyRow(this.theme.fg("dim", `auto-close in ${Math.round(autoCloseMs / 1000)}s…`), budget));
+					if (this.autoCloseDeadline === undefined) {
+						this.autoCloseDeadline = Date.now() + autoCloseMs;
+						this.armAutoClose(this.autoCloseDeadline);
+					}
+					const remainingMs = Math.max(0, this.autoCloseDeadline - Date.now());
+					lines.push(this.bodyRow(this.theme.fg("dim", `auto-close in ${Math.ceil(remainingMs / 1000)}s…`), budget));
 				}
-			}
-			// Clear timeout if conditions change
-			else if (this.autoCloseTimeout) {
-				clearTimeout(this.autoCloseTimeout);
-				this.autoCloseTimeout = undefined;
+			} else {
+				// Off the terminal window (run resumed, active agents (re)appeared) or
+				// already closed: cancel AND forget the deadline — the NEXT eligibility
+				// captures a fresh one. hasAutoClosed keeps done() from re-arming.
+				this.clearAutoClose();
 			}
 			this.cachedLines = renderLines(this.renderFrame(lines, budget, slot), w);
 			this.cachedSignature = signature;
@@ -363,13 +377,69 @@ export class LiveRunSidebar {
 		return railLine(RAIL.body, "border", content, this.theme, budget);
 	}
 
-	/** Append the `┗ <hint>` cap and colorize the glyphs (F-1 / V-3). */
+	/** L4: arm the close callback for a FIXED deadline. Re-renders never touch
+	 * it, so the close lands at firstEligibility + autoCloseMs regardless of
+	 * how many trailing events repaint the frame in between. */
+	private armAutoClose(deadline: number): void {
+		if (this.autoCloseTimeout) clearTimeout(this.autoCloseTimeout);
+		this.autoCloseTimeout = setTimeout(
+			() => {
+				this.hasAutoClosed = true;
+				this.done(undefined);
+			},
+			Math.max(0, deadline - Date.now()),
+		);
+		this.autoCloseTimeout?.unref();
+	}
+
+	/** L4: cancel the fixed deadline — only a NEW eligibility re-arms it. */
+	private clearAutoClose(): void {
+		if (this.autoCloseTimeout) {
+			clearTimeout(this.autoCloseTimeout);
+			this.autoCloseTimeout = undefined;
+		}
+		this.autoCloseDeadline = undefined;
+	}
+
+	/** Append the `┗ <hint>` cap, lock the frame to ONE stable height (L6)
+	 * and colorize the glyphs (F-1 / V-3). */
 	private renderFrame(lines: string[], budget: number, slot: RailSlot): string[] {
 		const hint = this.theme.fg("dim", formatHint(SIDEBAR_HINT));
 		const framed = [...lines, railLine(RAIL.close, slot, hint, this.theme, budget)];
+		this.lockHeight(framed, budget);
 		return framed.map((entry) => this.colorLine(entry));
 	}
 
+	/**
+	 * L6 (real-test 2026-10-07): pad with blank rail rows (cap stays LAST) or
+	 * slice (cap preserved) so EVERY frame — the 3-line pre-load frame and the
+	 * 20+ line loaded frame — is exactly targetHeight() lines. The host
+	 * positions overlays by the returned line count; a frame that flips
+	 * between heights moves the anchor row and the differential renderer
+	 * leaves a ghost footprint below the sidebar. Same contract as
+	 * run-dashboard's targetHeight() clamp.
+	 */
+	private lockHeight(lines: string[], budget: number): void {
+		const target = this.targetHeight();
+		if (lines.length < target) {
+			const blankRow = railLine(RAIL.body, "border", "", this.theme, budget);
+			const bottom = lines.pop();
+			while (lines.length < target - 1) lines.push(blankRow);
+			if (bottom !== undefined) lines.push(bottom);
+		} else if (lines.length > target) {
+			const bottom = lines[lines.length - 1];
+			lines.length = target - 1;
+			lines.push(bottom);
+		}
+	}
+
+	/** L6: stable overlay height — clamped like run-dashboard's targetHeight()
+	 * but scaled for the sidebar's single column (12–30 instead of 12–36). */
+	private targetHeight(): number {
+		const rows = Number.isFinite(process.stdout?.rows) ? Number(process.stdout?.rows) : 30;
+		return Math.max(12, Math.min(30, rows - 2));
+	}
+
 	handleInput(data: string): void {
 		if (data === "q" || data === "\u001b") this.done(undefined);
 	}

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

@@ -14,11 +14,16 @@
  * canopy/hint rows are NOT part of the split any more, so the hint keeps its
  * full width instead of being cropped to 60% of the overlay.
  *
+ * R3-6 (IME): the ACTIVE field emits pi-tui's zero-width `CURSOR_MARKER` at
+ * its value end — the host TUI strips it and parks the hardware cursor there
+ * so the IME candidate window follows the logical text cursor (CJK input).
+ *
  * Keys/behaviour are unchanged (same `overlay:*` dispatch, same free-text
  * passthrough, same validation errors, same discard confirmation). Hints come
  * from `formatHint` (discard LAST, keys through `keyToken`).
  */
 
+import * as piTui from "@earendil-works/pi-tui";
 import type { MailboxDirection } from "../../state/coordination/mailbox.ts";
 import { pad, sanitizeLine, truncate } from "../../utils/visual.ts";
 import { overlayActionForKey } from "../keybinding-map.ts";
@@ -27,6 +32,22 @@ import { asCrewTheme, type CrewTheme } from "../theme-adapter.ts";
 import { ConfirmOverlay } from "./confirm-overlay.ts";
 import { renderComposePreview } from "./mailbox-compose-preview.ts";
 
+/** Resolve pi-tui's zero-width IME cursor anchor defensively (L8, policy
+ *  W4/G22) — same typeof-guard shape as hyperlink() at widget-renderer.ts:
+ *  118-128 and the sibling resolver in settings-overlay.ts. The peer range is
+ *  `*`, so a host running a pi-tui build without the export must still render
+ *  instead of failing the named import at link time. Exported for the
+ *  fallback pin in test/unit/ui/settings-overlay-cursor-marker.test.ts. */
+export function resolveCursorMarker(mod: unknown): string {
+	const candidate = (mod as { CURSOR_MARKER?: unknown }).CURSOR_MARKER;
+	return typeof candidate === "string" ? candidate : "";
+}
+
+/** "" on hosts whose pi-tui predates CURSOR_MARKER — the active field then
+ *  renders without the IME anchor (marker is zero-width, stripped before
+ *  painting; pure enhancement, never a layout dependency). */
+const CURSOR_MARKER = resolveCursorMarker(piTui);
+
 export interface MailboxComposePayload {
 	from: string;
 	to: string;
@@ -117,7 +138,16 @@ export class MailboxComposeOverlay {
 		// (the field is a single-line cell; multi-line content belongs to the
 		// preview column).
 		const value = sanitizeLine(this.fields[field] ?? "");
-		return `${active ? CURSOR : " "} ${label}: ${truncate(value, Math.max(8, width - label.length - 5))}`;
+		// R3-6 (IME): CURSOR_MARKER is pi-tui's zero-width APC sequence — the host
+		// TUI finds it, positions the HARDWARE cursor there (IME candidate window
+		// anchor for CJK input), and strips it before painting. This overlay's
+		// fields append/backspace at end-of-value only, so the logical cursor IS
+		// the value end — same pattern as pi-tui's own Input component
+		// (marker + fake cursor). The `›` prefix stays: it is the RAIL list-selection
+		// glyph, orthogonal to the text cursor. Direction checkbox row gets NO
+		// marker — it toggles on space and has no text insertion point.
+		const marker = active && !this.confirm ? CURSOR_MARKER : "";
+		return `${active ? CURSOR : " "} ${label}: ${truncate(value, Math.max(8, width - label.length - 5))}${marker}`;
 	}
 
 	private activeName(): FieldName {

package/src/ui/rail.ts

@@ -58,7 +58,20 @@ export const RAIL = { open: "┏", section: "┣", body: "┃", close: "┗" } a
  */
 export const PI_EXPAND_CHORD = "ctrl+o";
 
-/** Selection cursor (lists) and active/step marker (sections, goals). */
+/** Selection cursor (lists) and active/step marker (sections, goals).
+ *
+ * R3-6 audit (2026-10-04): this glyph marks LIST SELECTION in dashboards,
+ * pickers, settings menus, and compose field rows — a navigation affordance,
+ * not a text insertion point. It therefore deliberately does NOT adopt
+ * pi-tui's `CURSOR_MARKER` (the zero-width APC sequence that anchors the
+ * IME candidate window at a TEXT cursor). Sites that DO own a text cursor —
+ * mailbox-compose field values, settings text-input/edit buffers — emit
+ * `CURSOR_MARKER` at their buffer end in addition to any visual glyph.
+ * Not converted, by design: run-dashboard run rows, settings menu rows,
+ * agents-jobs-browser rows, mailbox-detail rows, agent-picker rows,
+ * schedules-pane job rows (all list selection); widget dock `❯` (a
+ * single-line focus acknowledgement, not an input); mascot `█` frames
+ * (animation glyphs). */
 export const CURSOR = "›";
 export const ACTIVE = "▸";
 

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

@@ -19,6 +19,7 @@ import type { MailboxDirection, MailboxMessage } from "../state/coordination/mai
 import { appendEventBuffered } from "../state/event-log/event-log.ts";
 import { loadRunManifestById, saveRunTasks } from "../state/stores/state-store.ts";
 import { logInternalError } from "../utils/internal-error.ts";
+import { formatCount } from "./format-helpers.ts";
 
 export interface RunActionResult {
 	ok: boolean;
@@ -107,7 +108,7 @@ export async function dispatchMailboxAckAll(ctx: ExtensionContext, runId: string
 	}
 	return {
 		ok: true,
-		message: `Acknowledged ${count} messages.`,
+		message: `Acknowledged ${formatCount(count, "message")}.`,
 		data: { count },
 	};
 }

package/src/ui/run-dashboard.ts

@@ -28,7 +28,7 @@ import { renderPlanPane } from "./dashboard-panes/plan-pane.ts";
 import { renderProgressPane } from "./dashboard-panes/progress-pane.ts";
 import { renderScheduleDetails, renderSchedulesPane } from "./dashboard-panes/schedules-pane.ts";
 import { renderTranscriptPane } from "./dashboard-panes/transcript-pane.ts";
-import { formatCount, teamWorkflowLabel } from "./format-helpers.ts";
+import { formatCount, formatDuration, formatTokens, teamWorkflowLabel } from "./format-helpers.ts";
 import { goalFlagSuffix } from "./goal-flag.ts";
 import { type DashboardKeyAction, dashboardActionForKey } from "./keybinding-map.ts";
 import { HelpOverlay } from "./overlays/help-overlay.ts";
@@ -228,14 +228,14 @@ function runListWindow(scrollOffset: number, count: number): RunListWindow {
 	return { slots, hasTop, hasBottom };
 }
 
+/** L7 (real-test 2026-10-07): agent age in the shared formatDuration dialect
+ *  (`5m44s`), rendered bare — the retired `age=` prefix was wire format.
+ *  Sub-second ages read `now` (quieter than `123ms` on a rail row). */
 function formatAge(iso: string | undefined): string | undefined {
 	if (!iso) return undefined;
 	const ms = Math.max(0, Date.now() - new Date(iso).getTime());
 	if (!Number.isFinite(ms)) return undefined;
-	if (ms < 1000) return "now";
-	if (ms < 60_000) return `${Math.floor(ms / 1000)}s`;
-	if (ms < 3_600_000) return `${Math.floor(ms / 60_000)}m`;
-	return `${Math.floor(ms / 3_600_000)}h`;
+	return ms < 1000 ? "now" : formatDuration(ms);
 }
 
 function readProgressPreview(run: TeamRunManifest, maxLines = 5, snapshotCache?: RunSnapshotCache, resolve?: SnapshotResolver): string[] {
@@ -271,17 +271,21 @@ function readProgressPreview(run: TeamRunManifest, maxLines = 5, snapshotCache?:
 	}
 }
 
-function formatTokens(usage: UsageState | undefined): string | undefined {
+/**
+ * L7 (real-test 2026-10-07): TUI usage dialect — `↑1.0k ↓250 $0.012` —
+ * mirroring the compactUsage pattern in live-run-sidebar.ts (kept local
+ * because the sidebar's helper is module-private; do not edit that file).
+ * Replaces the retired `tok=…/in=…/out=…/cache=…/$…` wire format, which
+ * leaked log-line grammar onto rail rows and buried the numbers behind
+ * key=value prefixes. cacheRead/cacheWrite stay hidden (sidebar parity).
+ */
+function compactUsage(usage: UsageState | undefined): string | undefined {
 	if (!usage) return undefined;
-	const total = (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
-	if (!total) return undefined;
-	const compact = total >= 1000 ? `${(total / 1000).toFixed(total >= 10_000 ? 0 : 1)}k` : `${total}`;
-	const parts = [`tok=${compact}`];
-	if (usage.input) parts.push(`in=${usage.input}`);
-	if (usage.output) parts.push(`out=${usage.output}`);
-	if (usage.cacheRead) parts.push(`cache=${usage.cacheRead}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	return parts.join("/");
+	const parts: string[] = [];
+	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
+	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
+	if (usage.cost) parts.push(`$${usage.cost.toFixed(3)}`);
+	return parts.length ? parts.join(" ") : undefined;
 }
 
 function snapshotFor(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): RunUiSnapshot | undefined {
@@ -292,6 +296,38 @@ function snapshotFor(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): Ru
 	}
 }
 
+/**
+ * L5 (real-test 2026-10-07): paint-path snapshot read for the frame-local
+ * SnapshotResolver in `renderUnsafe`. Uses the cache's `readForRender`
+ * accessor when present — cached snapshot ONLY; a lapsed TTL schedules the
+ * coalesced async refresh off the paint path; a missing entry schedules one
+ * refresh so the pre-load rows fill on a later frame (sidebar precedent,
+ * live-run-sidebar.ts render()). Feature-detected because
+ * `RunDashboardOptions.snapshotCache` keeps the BASE interface
+ * (snapshot-types.ts): production wires the extended cache, while test mocks
+ * and legacy callers may implement only get/refreshIfStale — for those a
+ * plain get() keeps the render read-only. Keypress handlers and other
+ * read-your-writes sites keep `snapshotFor()` (sync refreshIfStale) — Tier 11a.
+ */
+function snapshotForRender(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): RunUiSnapshot | undefined {
+	const cache = snapshotCache as
+		| (RunSnapshotCache & {
+				readForRender?: (runId: string) => RunUiSnapshot | undefined;
+				scheduleRefresh?: (runId: string) => void;
+		  })
+		| undefined;
+	if (typeof cache?.readForRender === "function") {
+		try {
+			const snapshot = cache.readForRender(run.runId);
+			if (!snapshot && typeof cache.scheduleRefresh === "function") cache.scheduleRefresh(run.runId);
+			return snapshot;
+		} catch {
+			return snapshotCache?.get(run.runId);
+		}
+	}
+	return snapshotCache?.get(run.runId);
+}
+
 /**
  * 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,
@@ -344,16 +380,16 @@ function usageForAgent(agent: CrewAgentRecord, task: TeamTaskState | undefined):
 function agentPreviewLine(agent: CrewAgentRecord, task: TeamTaskState | undefined, options: RunDashboardOptions): string {
 	const stats = [
 		agent.progress?.activityState,
-		options.showModel !== false && modelForAgent(agent, task) ? `model=${modelForAgent(agent, task)}` : undefined,
+		options.showModel !== false ? modelForAgent(agent, task) : undefined,
 		options.showTokens !== false
-			? (formatTokens(usageForAgent(agent, task)) ??
-				(agent.progress?.tokens !== undefined ? `tok=${agent.progress.tokens}` : undefined))
+			? (compactUsage(usageForAgent(agent, task)) ??
+				(agent.progress?.tokens !== undefined ? `↑${formatTokens(agent.progress.tokens)}` : undefined))
 			: undefined,
 		options.showTools !== false && agent.progress?.currentTool ? `tool=${agent.progress.currentTool}` : undefined,
 		options.showTools !== false && agent.toolUses !== undefined ? formatCount(agent.toolUses, "tool") : undefined,
-		agent.progress?.turns !== undefined ? `${agent.progress.turns} turns` : undefined,
+		agent.progress?.turns !== undefined ? formatCount(agent.progress.turns, "turn") : undefined,
 		agent.progress?.failedTool ? `failedTool=${agent.progress.failedTool}` : undefined,
-		agent.startedAt ? `age=${formatAge(agent.completedAt ?? agent.startedAt)}` : undefined,
+		agent.startedAt ? formatAge(agent.completedAt ?? agent.startedAt) : undefined,
 	].filter((part): part is string => Boolean(part));
 	const recent = agent.progress?.recentOutput?.at(-1);
 	const icon = iconForStatus(agent.status, {
@@ -394,7 +430,8 @@ function readAgentPreview(run: TeamRunManifest, maxLines = 5, options: RunDashbo
 				cost: number;
 			},
 		);
-		const header = formatTokens(totals) ? `Agents: ${formatTokens(totals)}` : "Agents:";
+		const usage = compactUsage(totals);
+		const header = usage ? `Agents: ${usage}` : "Agents:";
 		return [
 			header,
 			...agents.slice(0, maxLines).map((agent) => agentPreviewLine(agent, taskForAgent(tasks, agent), options)),
@@ -834,9 +871,12 @@ export class RunDashboard implements DashboardComponent {
 		// 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.
+		// L5 (real-test 2026-10-07): the resolver reads the cache ONLY
+		// (snapshotForRender → readForRender) — the sync refreshIfStale rebuild
+		// moved off the paint path; refreshes are coalesced + async.
 		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));
+			if (!frameSnapshots.has(run.runId)) frameSnapshots.set(run.runId, snapshotForRender(run, this.options.snapshotCache));
 			return frameSnapshots.get(run.runId);
 		};
 		this.refreshRuns(snapshotOnce);

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

@@ -27,6 +27,14 @@ export interface RunSnapshotCache extends RunSnapshotCacheBase {
 	preloadAllStale(runIds: string[]): Promise<void>;
 	/** Task 17 (perf/review-2026-08-24): watcher-facing coalesced async refresh. */
 	scheduleRefresh(runId: string): void;
+	/**
+	 * L5 (real-test 2026-10-07): paint-path read — cached snapshot only.
+	 * NEVER sync-rebuilds: a lapsed TTL schedules the coalesced async refresh
+	 * (scheduleRefresh pipeline) instead of rebuilding on the paint path, and a
+	 * missing entry returns undefined without building. See the method doc on
+	 * the implementation for the staleness/Tier-11a contract.
+	 */
+	readForRender(runId: string): RunUiSnapshot | undefined;
 	/**
 	 * F13 (RR-018): true once dispose() has run. Callers that retain the cache
 	 * (RegistrationContext.getManifestCache/getRunSnapshotCache) use this to
@@ -1149,6 +1157,30 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		scheduleRefresh(runId: string): void {
 			scheduleCoalescedRefresh(runId);
 		},
+		/**
+		 * L5 (real-test 2026-10-07): read for the paint path. Returns the
+		 * CACHED snapshot (touching LRU/access) and NEVER sync-rebuilds — no
+		 * manifest/tasks parse, no agents.json read, no sha256 between paints.
+		 * When the entry's TTL has lapsed (the read-time proxy for "stamps may
+		 * look stale"), it schedules the EXISTING coalesced async refresh
+		 * (scheduleRefresh → 80ms coalesce → preloadStale); the actual stamp
+		 * comparison happens inside preloadStale, where a stamp-equal hit just
+		 * re-stamps the entry (no rebuild), so a quiet run costs one async stat
+		 * round per TTL window, off the paint path. A missing entry returns
+		 * undefined without building and without scheduling — callers render
+		 * their loading state and may call scheduleRefresh()/preloadStale()
+		 * themselves when they want the entry filled.
+		 * Tier 11a (read-your-writes) is preserved: refresh()/refreshIfStale()
+		 * below keep their sync build paths untouched for callers with a sync
+		 * reader immediately after write.
+		 */
+		readForRender(runId: string): RunUiSnapshot | undefined {
+			const entry = entries.get(runId);
+			if (!entry) return undefined;
+			const snapshot = touch(runId, entry);
+			if (Date.now() - entry.loadedAtMs >= ttlMs) scheduleCoalescedRefresh(runId);
+			return snapshot;
+		},
 		preloadStale,
 		preloadAllStale,
 		invalidate(runId?: string): void {