pi-crew 0.9.50 → 0.9.51

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/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;
 			},
 		);
 	}
@@ -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) {