pi-crew 0.1.41 → 0.1.44

package/src/ui/render-scheduler.ts

@@ -22,15 +22,26 @@ const DEFAULT_EVENTS = [
 	"crew.mailbox.message",
 ];
 
+/**
+ * Coordinates UI renders with debounce + fallback polling.
+ *
+ * Critical: uses recursive setTimeout instead of setInterval + a rendering
+ * guard (`rendering` / `pendingRender`) so that when render() takes longer
+ * than the fallback interval, callbacks do NOT pile up and storm the event
+ * loop.  Instead, overlapping schedules are collapsed into a single deferred
+ * re-render.
+ */
 export class RenderScheduler {
 	private readonly render: () => void;
 	private readonly onInvalidate?: (payload: unknown) => void;
 	private readonly debounceMs: number;
 	private readonly fallbackMs: number;
 	private debounceTimer: ReturnType<typeof setTimeout> | undefined;
-	private fallbackTimer: ReturnType<typeof setInterval> | undefined;
+	private fallbackTimer: ReturnType<typeof setTimeout> | undefined;
 	private disposed = false;
 	private lastEventAt = 0;
+	private rendering = false;
+	private pendingRender = false;
 	private readonly unsubs: Array<() => void> = [];
 
 	constructor(events: RenderSchedulerEventBus | undefined, render: () => void, options: RenderSchedulerOptions = {}) {
@@ -39,8 +50,8 @@ export class RenderScheduler {
 		this.debounceMs = options.debounceMs ?? 75;
 		this.fallbackMs = options.fallbackMs ?? 750;
 		for (const event of options.events ?? DEFAULT_EVENTS) this.subscribe(events, event);
-		this.fallbackTimer = setInterval(() => this.fallback(), this.fallbackMs);
-		this.fallbackTimer.unref?.();
+		this.fallbackTimer = setTimeout(() => this.fallbackLoop(), this.fallbackMs);
+		this.fallbackTimer.unref();
 	}
 
 	private subscribe(events: RenderSchedulerEventBus | undefined, event: string): void {
@@ -54,10 +65,19 @@ export class RenderScheduler {
 		}
 	}
 
-	private fallback(): void {
+	/** Recursive setTimeout — avoids setInterval timer storms. */
+	private fallbackLoop(): void {
 		if (this.disposed) return;
-		if (Date.now() - this.lastEventAt < this.fallbackMs) return;
-		this.flush();
+		if (Date.now() - this.lastEventAt < this.fallbackMs) {
+			if (this.disposed) return;
+			this.fallbackTimer = setTimeout(() => this.fallbackLoop(), this.fallbackMs);
+			this.fallbackTimer.unref();
+			return;
+		}
+		this.schedule();
+		if (this.disposed) return;
+		this.fallbackTimer = setTimeout(() => this.fallbackLoop(), this.fallbackMs);
+		this.fallbackTimer.unref();
 	}
 
 	schedule(payload?: unknown): void {
@@ -73,15 +93,39 @@ export class RenderScheduler {
 			this.debounceTimer = undefined;
 			this.flush();
 		}, this.debounceMs);
-		this.debounceTimer.unref?.();
+		this.debounceTimer.unref();
 	}
 
+	/**
+	 * Flush a render.  If a render is already in progress the request is
+	 * collapsed: `pendingRender` is set and the caller that holds
+	 * `rendering==true` will loop one more time after finishing.
+	 */
 	flush(): void {
 		if (this.disposed) return;
+		if (this.rendering) {
+			this.pendingRender = true;
+			return;
+		}
+		this.rendering = true;
+		this.pendingRender = false;
+		let iterations = 0;
 		try {
-			this.render();
+			do {
+				this.pendingRender = false;
+				this.render();
+				iterations += 1;
+				// Safety valve: 5 re-renders max per flush to prevent infinite loops
+				// if render() itself calls flush() synchronously.
+			} while (this.pendingRender && !this.disposed && iterations < 5);
 		} catch (error) {
 			logInternalError("render-scheduler.render", error);
+		} finally {
+			this.rendering = false;
+			// If we hit the iteration cap, schedule one more render to drain.
+			if (iterations >= 5 && this.pendingRender && !this.disposed) {
+				this.schedule();
+			}
 		}
 	}
 
@@ -89,15 +133,11 @@ export class RenderScheduler {
 		if (this.disposed) return;
 		this.disposed = true;
 		if (this.debounceTimer) clearTimeout(this.debounceTimer);
-		if (this.fallbackTimer) clearInterval(this.fallbackTimer);
+		if (this.fallbackTimer) clearTimeout(this.fallbackTimer);
 		this.debounceTimer = undefined;
 		this.fallbackTimer = undefined;
 		for (const unsub of this.unsubs.splice(0)) {
-			try {
-				unsub();
-			} catch (error) {
-				logInternalError("render-scheduler.unsubscribe", error);
-			}
+			try { unsub(); } catch (error) { logInternalError("render-scheduler.unsubscribe", error); }
 		}
 	}
 }

package/src/ui/run-dashboard.ts

@@ -12,6 +12,7 @@ import { Box, Text } from "./layout-primitives.ts";
 import { DynamicCrewBorder } from "./dynamic-border.ts";
 import { CrewFooter } from "./crew-footer.ts";
 import { aggregateUsage } from "../state/usage.ts";
+import { logInternalError } from "../utils/internal-error.ts";
 import { renderAgentsPane } from "./dashboard-panes/agents-pane.ts";
 import { renderMailboxPane } from "./dashboard-panes/mailbox-pane.ts";
 import { renderProgressPane } from "./dashboard-panes/progress-pane.ts";
@@ -194,18 +195,38 @@ function runLabel(run: TeamRunManifest, selected: boolean, snapshotCache?: RunSn
 	const stale = isLikelyOrphanedActiveRun(run, agents);
 	const running = agents.find((agent) => agent.status === "running");
 	const queued = agents.find((agent) => agent.status === "queued");
-	const step = stale ? "orphaned queued run" : running ? `step ${running.taskId}` : queued ? `queued ${queued.taskId}` : `agents ${agents.length}`;
+	const step = stale ? "orphaned queued run" : running ? `step ${running.taskId.replace(/[\x00-\x1f\x7f-\x9f]/g, "")}` : queued ? `queued ${queued.taskId.replace(/[\x00-\x1f\x7f-\x9f]/g, "")}` : `agents ${agents.length}`;
 	const status: RunStatus = stale ? "stale" : (run.status as RunStatus);
 	const marker = selected ? "›" : " ";
 	return `${marker} ${iconForStatus(status, { runningGlyph: spinnerFrame(run.runId) })} ${run.runId.slice(-8)} ${status} | ${run.team}/${run.workflow ?? "none"} | ${step} | ${run.goal}`;
 }
 
+interface ResolvedRun {
+	manifest: TeamRunManifest;
+	snapshot: RunUiSnapshot | undefined;
+	agents: CrewAgentRecord[];
+	status: RunStatus;
+}
+
+function resolveRuns(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache): Map<string, ResolvedRun> {
+	const map = new Map<string, ResolvedRun>();
+	for (const run of runs) {
+		const snapshot = snapshotFor(run, snapshotCache);
+		const agents = snapshot?.agents ?? agentsFor(run, snapshotCache);
+		const displayRun = snapshot?.manifest ?? run;
+		const status: RunStatus = isLikelyOrphanedActiveRun(displayRun, agents) ? "stale" : (displayRun.status as RunStatus);
+		map.set(run.runId, { manifest: run, snapshot, agents, status });
+	}
+	return map;
+}
+
 function groupedRuns(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache): Array<{ label: string; run?: TeamRunManifest }> {
-	const active = runs.filter((run) => isDisplayActiveRun(snapshotFor(run, snapshotCache)?.manifest ?? run, agentsFor(run, snapshotCache)));
-	const recent = runs.filter((run) => !isDisplayActiveRun(snapshotFor(run, snapshotCache)?.manifest ?? run, agentsFor(run, snapshotCache)));
+	const resolved = resolveRuns(runs, snapshotCache);
 	const rows: Array<{ label: string; run?: TeamRunManifest }> = [];
+	const active = runs.filter((run) => isDisplayActiveRun(resolved.get(run.runId)?.snapshot?.manifest ?? run, resolved.get(run.runId)?.agents ?? []));
+	const rest = runs.filter((run) => !isDisplayActiveRun(resolved.get(run.runId)?.snapshot?.manifest ?? run, resolved.get(run.runId)?.agents ?? []));
 	if (active.length) rows.push({ label: "Active" }, ...active.map((run) => ({ label: run.runId, run })));
-	if (recent.length) rows.push({ label: "Recent" }, ...recent.map((run) => ({ label: run.runId, run })));
+	if (rest.length) rows.push({ label: "Recent" }, ...rest.map((run) => ({ label: run.runId, run })));
 	return rows;
 }
 
@@ -214,13 +235,9 @@ function selectedRunFromGrouped(runs: TeamRunManifest[], selected: number, snaps
 }
 
 function countByStatus(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache): string {
+	const resolved = resolveRuns(runs, snapshotCache);
 	const counts = new Map<RunStatus, number>();
-	for (const run of runs) {
-		const snapshot = snapshotFor(run, snapshotCache);
-		const displayRun = snapshot?.manifest ?? run;
-		const status: RunStatus = isLikelyOrphanedActiveRun(displayRun, snapshot?.agents ?? agentsFor(run, snapshotCache)) ? "stale" : (displayRun.status as RunStatus);
-		counts.set(status, (counts.get(status) ?? 0) + 1);
-	}
+	for (const r of resolved.values()) counts.set(r.status, (counts.get(r.status) ?? 0) + 1);
 	return [...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none";
 }
 
@@ -253,10 +270,12 @@ export class RunDashboard implements DashboardComponent {
 	private refreshRuns(): void {
 		if (!this.options.runProvider) return;
 		const selectedRunId = this.selectedRunId();
-		this.runs = this.options.runProvider();
+		const next = this.options.runProvider();
+		this.runs = Array.isArray(next) ? next : this.runs;
 		if (selectedRunId) {
 			const nextIndex = groupedRuns(this.runs, this.options.snapshotCache).filter((row) => row.run).findIndex((row) => row.run?.runId === selectedRunId);
 			if (nextIndex >= 0) this.selected = nextIndex;
+			else this.selected = 0;
 		}
 	}
 
@@ -289,6 +308,15 @@ export class RunDashboard implements DashboardComponent {
 	}
 
 	render(width: number): string[] {
+		try {
+			return this.renderUnsafe(width);
+		} catch (error) {
+			logInternalError("run-dashboard.render", error);
+			return renderLines(["Dashboard error — see logs for details."], width);
+		}
+	}
+
+	private renderUnsafe(width: number): string[] {
 		this.refreshRuns();
 		const signature = this.buildSignature();
 		if (signature !== this.cachedVersion || this.cachedWidth !== width) {