pi-crew 0.9.49 → 0.9.51

package/src/ui/run-dashboard.ts

@@ -20,8 +20,8 @@ import { renderTranscriptPane } from "./dashboard-panes/transcript-pane.ts";
 import { DynamicCrewBorder } from "./dynamic-border.ts";
 import { dashboardActionForKey } from "./keybinding-map.ts";
 import { HelpOverlay } from "./overlays/help-overlay.ts";
-import { RenderScheduler } from "./render-scheduler.ts";
-import { runEventBusAsRenderScheduler } from "./run-event-bus.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 { spinnerBucket, spinnerFrame } from "./spinner.ts";
 import { applyStatusColor, colorizeStatusGlyphs, iconForStatus, type RunStatus } from "./status-colors.ts";
@@ -423,7 +423,7 @@ export class RunDashboard implements DashboardComponent {
 	private cachedSignatureAt = 0;
 	private cachedSignature = "";
 	private readonly unsubscribeTheme: () => void;
-	private readonly renderScheduler: RenderScheduler | undefined;
+	private readonly schedulerHandle: OverlaySchedulerHandle | undefined;
 
 	constructor(
 		runs: TeamRunManifest[],
@@ -466,21 +466,12 @@ export class RunDashboard implements DashboardComponent {
 		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;
-				},
-			},
-		);
+		this.schedulerHandle = registerOverlayScheduler(renderTick, () => {
+			// 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.
@@ -498,8 +489,8 @@ export class RunDashboard implements DashboardComponent {
 	 * (defensive — currently always created in the constructor).
 	 */
 	private scheduleRender(): void {
-		if (this.renderScheduler) {
-			this.renderScheduler.schedule();
+		if (this.schedulerHandle) {
+			this.schedulerHandle.schedule();
 			return;
 		}
 		this.invalidateAndRender();
@@ -619,7 +610,7 @@ export class RunDashboard implements DashboardComponent {
 
 	dispose(): void {
 		this.unsubscribeTheme();
-		this.renderScheduler?.dispose();
+		this.schedulerHandle?.dispose();
 	}
 
 	private selectedRunId(): string | undefined {

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

@@ -1005,17 +1005,16 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 	const scheduleRefresh = (runId: string): void => {
 		const existing = pendingRefreshes.get(runId);
 		if (existing) clearTimeout(existing);
-		pendingRefreshes.set(
-			runId,
-			setTimeout(() => {
-				pendingRefreshes.delete(runId);
-				try {
-					localRefreshIfStale(runId);
-				} catch {
-					/* best-effort; widget falls back gracefully */
-				}
-			}, INVAL_COALESCE_MS),
-		);
+		const timer = setTimeout(() => {
+			pendingRefreshes.delete(runId);
+			try {
+				localRefreshIfStale(runId);
+			} catch {
+				/* best-effort; widget falls back gracefully */
+			}
+		}, INVAL_COALESCE_MS);
+		timer.unref();
+		pendingRefreshes.set(runId, timer);
 	};
 	const unsubState = runEventBus.onChannel("run:state", (event) => {
 		if (entries.has(event.runId)) scheduleRefresh(event.runId);

package/src/ui/shared-overlay-scheduler.ts

@@ -0,0 +1,96 @@
+import { logInternalError } from "../utils/internal-error.ts";
+import { RenderScheduler } from "./render-scheduler.ts";
+import { runEventBusAsRenderScheduler } from "./run-event-bus.ts";
+
+export interface OverlaySchedulerHandle {
+	/** Force a debounced re-render fan-out (e.g. theme change, dashboard interaction). */
+	schedule(): void;
+	/** Unregister this overlay. Disposes the shared scheduler when the last overlay leaves (ref-count). */
+	dispose(): void;
+}
+
+/**
+ * C3 (Option G): the 3 overlays (widget + sidebar + dashboard) each used to
+ * instantiate an identical RenderScheduler (same run-event-bus channels,
+ * debounce 75ms, fallback 750ms) → 9 subscriptions + 9 live timers + 3×
+ * per-event schedule() CPU during active runs. This module owns ONE shared
+ * RenderScheduler (module singleton) whose `render` and `onInvalidate`
+ * fan out to all registered overlays, with per-callback try/catch isolation
+ * + ref-counted disposal (the underlying scheduler is disposed when the last
+ * overlay leaves, and a future register recreates it).
+ */
+
+const CHANNELS = ["run:state", "worker:lifecycle", "ui:invalidate"] as const;
+
+interface SharedOverlayState {
+	readonly scheduler: RenderScheduler;
+	readonly renderers: Set<() => void>;
+	readonly invalidators: Set<(payload: unknown) => void>;
+}
+
+let shared: SharedOverlayState | undefined;
+
+function ensureShared(): SharedOverlayState {
+	if (shared) return shared;
+	const renderers = new Set<() => void>();
+	const invalidators = new Set<(payload: unknown) => void>();
+	const scheduler = new RenderScheduler(
+		runEventBusAsRenderScheduler([...CHANNELS]),
+		() => {
+			// Fan-out: each registered overlay's render runs in its own
+			// try/catch so one failing component cannot break the others.
+			for (const render of renderers) {
+				try {
+					render();
+				} catch (error) {
+					logInternalError("shared-overlay-scheduler.render", error);
+				}
+			}
+		},
+		{
+			debounceMs: 75,
+			fallbackMs: 750,
+			events: [...CHANNELS],
+			onInvalidate: (payload) => {
+				for (const invalidate of invalidators) {
+					try {
+						invalidate(payload);
+					} catch (error) {
+						logInternalError("shared-overlay-scheduler.invalidate", error);
+					}
+				}
+			},
+		},
+	);
+	shared = { scheduler, renderers, invalidators };
+	return shared;
+}
+
+/**
+ * Register an overlay's render (+ optional onInvalidate) with the shared
+ * scheduler. Returns a handle that lets the overlay force a debounced
+ * fan-out (schedule) and unregister itself (dispose). The underlying shared
+ * scheduler is created lazily on first register and disposed when the last
+ * overlay disposes.
+ */
+export function registerOverlayScheduler(render: () => void, onInvalidate?: (payload: unknown) => void): OverlaySchedulerHandle {
+	const state = ensureShared();
+	state.renderers.add(render);
+	if (onInvalidate) state.invalidators.add(onInvalidate);
+	return {
+		schedule: () => {
+			state.scheduler.schedule();
+		},
+		dispose: () => {
+			state.renderers.delete(render);
+			if (onInvalidate) state.invalidators.delete(onInvalidate);
+			// Ref-count: when the last overlay leaves, dispose the underlying
+			// scheduler (clears subscriptions + timers) and reset the module
+			// variable so a future register recreates a fresh instance.
+			if (state.renderers.size === 0) {
+				state.scheduler.dispose();
+				if (shared === state) shared = undefined;
+			}
+		},
+	};
+}

package/src/ui/terminal-status.ts

@@ -213,6 +213,9 @@ export function createTerminalStatusController(ctx: TerminalStatusUi): TerminalS
 			setTerminalTitle(ctx, buildIdleTitle());
 			scheduleIdleReassert(Math.min(delay * 2, IDLE_REASSERT_MAX_MS));
 		}, delay);
+		// Unref so this recursive backoff timer never keeps the event loop alive
+		// (critical on SIGTERM where dispose() is not reached → process hang).
+		state.idleTimer.unref?.();
 	};
 
 	return {
@@ -240,6 +243,8 @@ export function createTerminalStatusController(ctx: TerminalStatusUi): TerminalS
 					ghosttyClear();
 				}
 			}, COMPLETE_FLASH_MS);
+			// Unref so the one-shot flash clear never blocks process exit.
+			state.flashTimer.unref?.();
 		},
 		onIdle(): void {
 			if (state.destroyed) return;

package/src/ui/widget/index.ts

@@ -12,8 +12,8 @@ import type { ManifestCache } from "../../runtime/manifest-cache.ts";
 import type { TeamRunManifest } from "../../state/types.ts";
 import { truncate } from "../../utils/visual.ts";
 import { requestRender, requestRenderTarget, setExtensionWidget } from "../pi-ui-compat.ts";
-import { RenderScheduler } from "../render-scheduler.ts";
-import { runEventBusAsRenderScheduler } from "../run-event-bus.ts";
+import type { OverlaySchedulerHandle } from "../shared-overlay-scheduler.ts";
+import { registerOverlayScheduler } from "../shared-overlay-scheduler.ts";
 import type { RunSnapshotCache } from "../snapshot-types.ts";
 import { spinnerBucket, spinnerFrame } from "../spinner.ts";
 import type { CrewTheme } from "../theme-adapter.ts";
@@ -64,6 +64,15 @@ const LEGACY_WIDGET_KEY = "pi-crew";
 const WIDGET_KEY = "pi-crew-active";
 const STATUS_KEY = "pi-crew";
 
+/**
+ * C4 — short-TTL safety net for the buildSignature() result cache. Combined
+ * with invalidate-on-write (onInvalidate clears the cache on every real
+ * event), this prevents redundant O(runs×agents) signature recomputation
+ * during a burst of host-driven renders within one state snapshot while
+ * ensuring the signature is always recomputed after genuine data changes.
+ */
+const SIGNATURE_CACHE_TTL_MS = 100;
+
 // ── Terminal resize handling (T-2) ────────────────────────────────────
 // On a terminal resize the widget's cached render width goes stale until the
 // next invalidate; a mid-run resize could briefly paint a frame at the old
@@ -104,13 +113,16 @@ class CrewWidgetComponent implements WidgetComponent {
 	private readonly model: CrewWidgetModel;
 	private theme: CrewTheme;
 	private cacheSignature = "";
+	/** C4 — invalidate-on-write cache for the buildSignature() result. */
+	private cachedBuildSignature = "";
+	private cachedBuildSignatureAt = 0;
 	private cachedWidth = 0;
 	private cachedLines: string[] = [];
 	private cachedBaseLines: string[] = [];
 	private cachedTheme: CrewTheme;
 	private readonly tui: unknown;
 	private readonly unsubscribeTheme: () => void;
-	private readonly renderScheduler: RenderScheduler;
+	private readonly schedulerHandle: OverlaySchedulerHandle;
 
 	constructor(model: CrewWidgetModel, themeLike: unknown, tui?: unknown) {
 		this.model = model;
@@ -130,13 +142,18 @@ class CrewWidgetComponent implements WidgetComponent {
 		// subscribing independently a single event triggered up to 9 callbacks
 		// and ~150 invalidates/sec under load. The scheduler collapses bursts
 		// into one debounced invalidate.
-		this.renderScheduler = new RenderScheduler(
-			runEventBusAsRenderScheduler(["run:state", "worker:lifecycle", "ui:invalidate"]),
+		this.schedulerHandle = registerOverlayScheduler(
 			() => this.invalidate(),
-			{
-				debounceMs: 75,
-				fallbackMs: 750,
-				events: ["run:state", "worker:lifecycle", "ui:invalidate"],
+			() => {
+				// C4 invalidate-on-write: drop the cached buildSignature()
+				// result immediately when a real event arrives (run:state /
+				// worker:lifecycle / ui:invalidate). The prior blind-TTL
+				// attempt (reverted in 619a0cd) held a stale signature
+				// within the window and skipped re-render on genuine state
+				// changes. Clearing here + in invalidate() guarantees the
+				// next render tick always recomputes from fresh data.
+				this.cachedBuildSignature = "";
+				this.cachedBuildSignatureAt = 0;
 			},
 		);
 	}
@@ -154,7 +171,7 @@ class CrewWidgetComponent implements WidgetComponent {
 			[...listLiveAgents()].some((h) => h.status === "running");
 		const animation = hasRunning ? `:spin=${spinnerBucket()}` : "";
 
-		return (
+		const sig =
 			runs
 				.map(
 					(entry) =>
@@ -175,8 +192,8 @@ class CrewWidgetComponent implements WidgetComponent {
 								})
 								.join(","),
 				)
-				.join("|") + `|live:${liveSig}${animation}`
-		);
+				.join("|") + `|live:${liveSig}${animation}`;
+		return sig;
 	}
 
 	private colorize(lines: string[], width: number): string[] {
@@ -190,6 +207,8 @@ class CrewWidgetComponent implements WidgetComponent {
 		this.cacheSignature = "";
 		this.cachedBaseLines = [];
 		this.cachedLines = [];
+		this.cachedBuildSignature = "";
+		this.cachedBuildSignatureAt = 0;
 	}
 
 	/** Poke the host TUI to repaint immediately (defensive: no-op if unavailable). */
@@ -199,13 +218,28 @@ class CrewWidgetComponent implements WidgetComponent {
 
 	dispose(): void {
 		this.unsubscribeTheme();
-		this.renderScheduler.dispose();
+		this.schedulerHandle.dispose();
 		if (activeResizeTarget === this) activeResizeTarget = undefined;
 	}
 
 	render(width: number): string[] {
 		const runs = activeWidgetRuns(this.model.cwd, this.model.manifestCache, this.model.snapshotCache, this.model.preloadManifests);
-		const signature = `${this.buildSignature(runs)}:${this.model.notificationCount ?? 0}`;
+		// C4: invalidate-on-write signature cache. buildSignature() is
+		// O(runs×agents) string work called on every ~160ms host-driven render
+		// tick. Within one state snapshot (no event arrived → cache not cleared
+		// by onInvalidate) the result is identical, so we reuse the cached value
+		// to skip redundant recomputation. A short TTL acts as a safety net for
+		// the unlikely case where a real event is missed.
+		const now = Date.now();
+		let sigBase: string;
+		if (this.cachedBuildSignature !== "" && now - this.cachedBuildSignatureAt < SIGNATURE_CACHE_TTL_MS) {
+			sigBase = this.cachedBuildSignature;
+		} else {
+			sigBase = this.buildSignature(runs);
+			this.cachedBuildSignature = sigBase;
+			this.cachedBuildSignatureAt = now;
+		}
+		const signature = `${sigBase}:${this.model.notificationCount ?? 0}`;
 		const runningGlyph = spinnerFrame("widget-header");
 
 		if (this.cacheSignature !== signature || width !== this.cachedWidth || this.cachedTheme !== this.theme) {
@@ -342,8 +376,6 @@ export function stopCrewWidget(
 	state: CrewWidgetState,
 	config?: CrewUiConfig,
 ): void {
-	if (state.interval) clearInterval(state.interval);
-	state.interval = undefined;
 	if (ctx?.hasUI) {
 		const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
 		ctx.ui.setStatus(STATUS_KEY, undefined);

package/src/ui/widget/widget-types.ts

@@ -25,7 +25,6 @@ export interface CrewWidgetModel {
 
 export interface CrewWidgetState {
 	frame: number;
-	interval?: ReturnType<typeof setInterval>;
 	lastPlacement?: string;
 	lastVisibility?: "hidden" | "visible";
 	lastKey?: string;