pi-crew 0.1.41 → 0.1.43

package/src/ui/mascot.ts

@@ -136,9 +136,9 @@ export class AnimatedMascot {
 		this.currentArminGrid = this.style === "armin" ? this.initialArminGrid() : emptyArminGrid();
 		this.initEffect();
 		this.interval = setInterval(() => this.tick(), this.frameIntervalMs);
-		this.interval.unref?.();
+		this.interval.unref();
 		this.timeout = this.autoCloseMs > 0 ? setTimeout(() => this.close(), this.autoCloseMs) : undefined;
-		this.timeout?.unref?.();
+		this.timeout?.unref();
 	}
 
 	private resolveEffect(requested: MascotEffect | undefined): MascotEffect {
@@ -435,6 +435,7 @@ export class AnimatedMascot {
 	}
 
 	dispose(): void {
+		this.doneGuard.called = true;
 		if (this.interval) clearInterval(this.interval);
 		if (this.timeout) clearTimeout(this.timeout);
 	}

package/src/ui/powerbar-publisher.ts

@@ -92,12 +92,13 @@ export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: Cre
 	const agents = active.flatMap((item) => item.agents);
 	const tasks = active.flatMap((item) => item.tasks);
 	const running = agents.filter((agent) => agent.status === "running").length;
-	const waiting = active.reduce((sum, item) => sum + (item.snapshot?.progress.queued ?? item.tasks.filter((task) => task.status === "queued").length), 0);
-	const completed = active.reduce((sum, item) => sum + (item.snapshot?.progress.completed ?? item.tasks.filter((task) => task.status === "completed").length), 0);
+	const waiting = active.reduce((sum, item) => sum + (item.snapshot?.progress.queued ?? item.tasks.reduce((s, t) => s + (t.status === "queued" ? 1 : 0), 0)), 0);
+	const completed = active.reduce((sum, item) => sum + (item.snapshot?.progress.completed ?? item.tasks.reduce((s, t) => s + (t.status === "completed" ? 1 : 0), 0)), 0);
 	const total = Math.max(1, active.reduce((sum, item) => sum + (item.snapshot?.progress.total ?? item.tasks.length), 0) || agents.length);
 	const usage = aggregateUsage(tasks);
 	const snapshotTokens = active.reduce((sum, item) => sum + (item.snapshot ? item.snapshot.usage.tokensIn + item.snapshot.usage.tokensOut : 0), 0);
-	const tokenTotal = usage ? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0) : snapshotTokens;
+	const hasUsage = usage && ((usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0)) > 0;
+	const tokenTotal = hasUsage ? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0) : snapshotTokens;
 	const model = config?.showModel === false ? undefined : agents.find((agent) => agent.model)?.model?.split("/").at(-1);
 	const tokenText = config?.showTokens === false || !tokenTotal ? undefined : compactTokens(tokenTotal);
 	const activeText = `crew ${running}a/${waiting}w${notificationBadge(notificationCount)}`;

package/src/ui/render-diff.ts

@@ -1,119 +1,119 @@
-import * as Diff from "diff";
-import type { CrewTheme } from "./theme-adapter.ts";
-import { asCrewTheme } from "./theme-adapter.ts";
-
-interface ParsedDiffLine {
-	prefix: string;
-	lineNum: string;	content: string;
-}
-
-interface DiffLineContent {
-	lineNum: string;
-	content: string;
-}
-
-function parseDiffLine(line: string): ParsedDiffLine | null {
-	const match = line.match(/^([+-\s])(\s*\d*)\s(.*)$/);
-	if (!match) return null;
-	return { prefix: match[1], lineNum: match[2], content: match[3] };
-}
-
-function replaceTabs(text: string): string {
-	return text.replace(/\t/g, "   ");
-}
-
-function renderIntraLineDiff(theme: CrewTheme, oldContent: string, newContent: string): { removedLine: string; addedLine: string } {
-	const wordDiff = Diff.diffWords(oldContent, newContent);
-	let removedLine = "";
-	let addedLine = "";
-	let isFirstRemoved = true;
-	let isFirstAdded = true;
-
-	for (const part of wordDiff) {
-		if (part.removed) {
-			let value = part.value;
-			if (isFirstRemoved) {
-				const leadingWs = value.match(/^(\s*)/)?.[1] ?? "";
-				value = value.slice(leadingWs.length);
-				removedLine += leadingWs;
-				isFirstRemoved = false;
-			}
-			if (value) removedLine += theme.inverse?.(value) ?? value;
-		} else if (part.added) {
-			let value = part.value;
-			if (isFirstAdded) {
-				const leadingWs = value.match(/^(\s*)/)?.[1] ?? "";
-				value = value.slice(leadingWs.length);
-				addedLine += leadingWs;
-				isFirstAdded = false;
-			}
-			if (value) addedLine += theme.inverse?.(value) ?? value;
-		} else {
-			removedLine += part.value;
-			addedLine += part.value;
-		}
-	}
-
-	return { removedLine, addedLine };
-}
-
-export interface RenderDiffOptions {
-	filePath?: string;
-	theme?: unknown;
-}
-
-export function renderDiff(diffText: string, options: RenderDiffOptions = {}): string {
-	const theme = asCrewTheme(options.theme);
-	const lines = diffText.split("\n");
-	const result: string[] = [];
-	let i = 0;
-
-	while (i < lines.length) {
-		const line = lines[i] ?? "";
-		const parsed = parseDiffLine(line);
-		if (!parsed) {
-			result.push(theme.fg("toolDiffContext", line));
-			i++;
-			continue;
-		}
-
-		if (parsed.prefix === "-") {
-			const removedLines: DiffLineContent[] = [];
-			while (i < lines.length) {
-				const nextParsed = parseDiffLine(lines[i] ?? "");
-				if (!nextParsed || nextParsed.prefix !== "-") break;
-				removedLines.push({ lineNum: nextParsed.lineNum, content: nextParsed.content });
-				i++;
-			}
-
-			const addedLines: DiffLineContent[] = [];
-			while (i < lines.length) {
-				const nextParsed = parseDiffLine(lines[i] ?? "");
-				if (!nextParsed || nextParsed.prefix !== "+") break;
-				addedLines.push({ lineNum: nextParsed.lineNum, content: nextParsed.content });
-				i++;
-			}
-
-			if (removedLines.length === 1 && addedLines.length === 1) {
-				const { removedLine, addedLine } = renderIntraLineDiff(theme, replaceTabs(removedLines[0]!.content), replaceTabs(addedLines[0]!.content));
-				result.push(theme.fg("toolDiffRemoved", `-${removedLines[0]!.lineNum} ${removedLine}`));
-				result.push(theme.fg("toolDiffAdded", `+${addedLines[0]!.lineNum} ${addedLine}`));
-			} else {
-				for (const removed of removedLines) {
-					result.push(theme.fg("toolDiffRemoved", `-${removed.lineNum} ${replaceTabs(removed.content)}`));
-				}
-				for (const added of addedLines) {
-					result.push(theme.fg("toolDiffAdded", `+${added.lineNum} ${replaceTabs(added.content)}`));
-				}
-			}
-		} else if (parsed.prefix === "+") {
-			result.push(theme.fg("toolDiffAdded", `+${parsed.lineNum} ${replaceTabs(parsed.content)}`));
-			i++;
-		} else {
-			result.push(theme.fg("toolDiffContext", ` ${parsed.lineNum} ${replaceTabs(parsed.content)}`));
-			i++;
-		}
-	}
-
-	return result.join("\n");
-}
+import * as Diff from "diff";
+import type { CrewTheme } from "./theme-adapter.ts";
+import { asCrewTheme } from "./theme-adapter.ts";
+
+interface ParsedDiffLine {
+	prefix: string;
+	lineNum: string;	content: string;
+}
+
+interface DiffLineContent {
+	lineNum: string;
+	content: string;
+}
+
+function parseDiffLine(line: string): ParsedDiffLine | null {
+	const match = line.match(/^([+-\s])(\s*\d*)\s(.*)$/);
+	if (!match) return null;
+	return { prefix: match[1], lineNum: match[2], content: match[3] };
+}
+
+function replaceTabs(text: string): string {
+	return text.replace(/\t/g, "   ");
+}
+
+function renderIntraLineDiff(theme: CrewTheme, oldContent: string, newContent: string): { removedLine: string; addedLine: string } {
+	const wordDiff = Diff.diffWords(oldContent, newContent);
+	let removedLine = "";
+	let addedLine = "";
+	let isFirstRemoved = true;
+	let isFirstAdded = true;
+
+	for (const part of wordDiff) {
+		if (part.removed) {
+			let value = part.value;
+			if (isFirstRemoved) {
+				const leadingWs = value.match(/^(\s*)/)?.[1] ?? "";
+				value = value.slice(leadingWs.length);
+				removedLine += leadingWs;
+				isFirstRemoved = false;
+			}
+			if (value) removedLine += theme.inverse?.(value) ?? value;
+		} else if (part.added) {
+			let value = part.value;
+			if (isFirstAdded) {
+				const leadingWs = value.match(/^(\s*)/)?.[1] ?? "";
+				value = value.slice(leadingWs.length);
+				addedLine += leadingWs;
+				isFirstAdded = false;
+			}
+			if (value) addedLine += theme.inverse?.(value) ?? value;
+		} else {
+			removedLine += part.value;
+			addedLine += part.value;
+		}
+	}
+
+	return { removedLine, addedLine };
+}
+
+export interface RenderDiffOptions {
+	filePath?: string;
+	theme?: unknown;
+}
+
+export function renderDiff(diffText: string, options: RenderDiffOptions = {}): string {
+	const theme = asCrewTheme(options.theme);
+	const lines = diffText.split("\n");
+	const result: string[] = [];
+	let i = 0;
+
+	while (i < lines.length) {
+		const line = lines[i] ?? "";
+		const parsed = parseDiffLine(line);
+		if (!parsed) {
+			result.push(theme.fg("toolDiffContext", line));
+			i++;
+			continue;
+		}
+
+		if (parsed.prefix === "-") {
+			const removedLines: DiffLineContent[] = [];
+			while (i < lines.length) {
+				const nextParsed = parseDiffLine(lines[i] ?? "");
+				if (!nextParsed || nextParsed.prefix !== "-") break;
+				removedLines.push({ lineNum: nextParsed.lineNum, content: nextParsed.content });
+				i++;
+			}
+
+			const addedLines: DiffLineContent[] = [];
+			while (i < lines.length) {
+				const nextParsed = parseDiffLine(lines[i] ?? "");
+				if (!nextParsed || nextParsed.prefix !== "+") break;
+				addedLines.push({ lineNum: nextParsed.lineNum, content: nextParsed.content });
+				i++;
+			}
+
+			if (removedLines.length === 1 && addedLines.length === 1) {
+				const { removedLine, addedLine } = renderIntraLineDiff(theme, replaceTabs(removedLines[0]!.content), replaceTabs(addedLines[0]!.content));
+				result.push(theme.fg("toolDiffRemoved", `-${removedLines[0]!.lineNum} ${removedLine}`));
+				result.push(theme.fg("toolDiffAdded", `+${addedLines[0]!.lineNum} ${addedLine}`));
+			} else {
+				for (const removed of removedLines) {
+					result.push(theme.fg("toolDiffRemoved", `-${removed.lineNum} ${replaceTabs(removed.content)}`));
+				}
+				for (const added of addedLines) {
+					result.push(theme.fg("toolDiffAdded", `+${added.lineNum} ${replaceTabs(added.content)}`));
+				}
+			}
+		} else if (parsed.prefix === "+") {
+			result.push(theme.fg("toolDiffAdded", `+${parsed.lineNum} ${replaceTabs(parsed.content)}`));
+			i++;
+		} else {
+			result.push(theme.fg("toolDiffContext", ` ${parsed.lineNum} ${replaceTabs(parsed.content)}`));
+			i++;
+		}
+	}
+
+	return result.join("\n");
+}

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) {

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

@@ -4,17 +4,19 @@ import * as path from "node:path";
 import { readCrewAgents, agentsPath, agentOutputPath } from "../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { isActiveRunStatus } from "../runtime/process-status.ts";
-import { readEvents, type TeamEvent } from "../state/event-log.ts";
+import type { TeamEvent } from "../state/event-log.ts";
 import type { MailboxMessageStatus } from "../state/mailbox.ts";
 import { loadRunManifestById } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import type { RunSnapshotCache, RunUiGroupJoin, RunUiMailbox, RunUiProgress, RunUiSnapshot, RunUiUsage } from "./snapshot-types.ts";
 
-const DEFAULT_TTL_MS = 250;
+const DEFAULT_TTL_MS = 500;
 const DEFAULT_MAX_ENTRIES = 24;
 const DEFAULT_RECENT_EVENTS = 20;
 const DEFAULT_RECENT_OUTPUT_LINES = 20;
 const MAX_TAIL_BYTES = 32 * 1024;
+/** Max JSONL lines to tail when reading growing files (events, mailbox). */
+const MAX_TAIL_LINES = 500;
 
 interface FileStamp {
 	mtimeMs: number;
@@ -116,14 +118,40 @@ function readTasks(tasksPath: string): TeamTaskState[] {
 	}
 }
 
-function safeRecentEvents(eventsPath: string, limit: number): TeamEvent[] {
+/** Tail-read JSONL lines from a file, returning parsed objects (limited). */
+function tailJsonlLines<T>(filePath: string, limit: number, parse: (line: string) => T | undefined): T[] {
+	if (limit <= 0) return [];
 	try {
-		return readEvents(eventsPath).slice(-limit);
+		const stat = fs.statSync(filePath);
+		const bytesToRead = Math.min(stat.size, MAX_TAIL_BYTES);
+		const fd = fs.openSync(filePath, "r");
+		try {
+			const buffer = Buffer.alloc(bytesToRead);
+			fs.readSync(fd, buffer, 0, bytesToRead, stat.size - bytesToRead);
+			const lines = buffer.toString("utf-8").split(/\r?\n/).filter(Boolean);
+			return lines.flatMap((line) => {
+				const item = parse(line);
+				return item ? [item] : [];
+			}).slice(-limit);
+		} finally {
+			fs.closeSync(fd);
+		}
 	} catch {
 		return [];
 	}
 }
 
+function safeRecentEvents(eventsPath: string, limit: number): TeamEvent[] {
+	return tailJsonlLines(eventsPath, limit, (line) => {
+		try {
+			const parsed = JSON.parse(line) as unknown;
+			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? (parsed as TeamEvent) : undefined;
+		} catch {
+			return undefined;
+		}
+	});
+}
+
 function tailLines(filePath: string, limit: number): string[] {
 	if (limit <= 0) return [];
 	try {
@@ -196,40 +224,33 @@ function readDeliveryMessages(filePath: string): Record<string, MailboxMessageSt
 }
 
 function readGroupJoinMailbox(filePath: string, delivery: Record<string, MailboxMessageStatus>): RunUiGroupJoin[] {
-	try {
-		return fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter(Boolean).flatMap((line) => {
-			try {
-				const parsed = JSON.parse(line) as unknown;
-				if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
-				const message = parsed as { id?: unknown; data?: unknown };
-				const data = message.data && typeof message.data === "object" && !Array.isArray(message.data) ? message.data as Record<string, unknown> : undefined;
-				if (typeof message.id !== "string" || data?.kind !== "group_join" || typeof data.requestId !== "string") return [];
-				return [{ requestId: data.requestId, messageId: message.id, partial: data.partial === true, ack: delivery[message.id] === "acknowledged" ? "acknowledged" as const : "pending" as const }];
-			} catch {
-				return [];
-			}
-		});
-	} catch {
-		return [];
-	}
+	return tailJsonlLines(filePath, MAX_TAIL_LINES, (line) => {
+		try {
+			const parsed = JSON.parse(line) as unknown;
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+			const message = parsed as { id?: unknown; data?: unknown };
+			const data = message.data && typeof message.data === "object" && !Array.isArray(message.data) ? message.data as Record<string, unknown> : undefined;
+			if (typeof message.id !== "string" || data?.kind !== "group_join" || typeof data.requestId !== "string") return undefined;
+			return { requestId: data.requestId, messageId: message.id, partial: data.partial === true, ack: delivery[message.id] === "acknowledged" ? "acknowledged" as const : "pending" as const };
+		} catch {
+			return undefined;
+		}
+	});
 }
 
 function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMessageStatus>): number {
-	try {
-		return fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter(Boolean).reduce((count, line) => {
-			try {
-				const parsed = JSON.parse(line) as unknown;
-				if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return count;
-				const message = parsed as { id?: unknown; status?: unknown };
-				if (typeof message.id !== "string" || !isMailboxStatus(message.status)) return count;
-				return message.status !== "acknowledged" && delivery[message.id] !== "acknowledged" ? count + 1 : count;
-			} catch {
-				return count;
-			}
-		}, 0);
-	} catch {
-		return 0;
-	}
+	const items = tailJsonlLines(filePath, MAX_TAIL_LINES, (line) => {
+		try {
+			const parsed = JSON.parse(line) as unknown;
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return 0;
+			const message = parsed as { id?: unknown; status?: unknown };
+			if (typeof message.id !== "string" || !isMailboxStatus(message.status)) return 0;
+			return message.status !== "acknowledged" && delivery[message.id] !== "acknowledged" ? 1 : 0;
+		} catch {
+			return 0;
+		}
+	}) as number[];
+	return items.reduce((sum, val) => sum + val, 0);
 }
 
 function groupJoinsFrom(manifest: TeamRunManifest): RunUiGroupJoin[] {
@@ -258,8 +279,9 @@ function mailboxFrom(manifest: TeamRunManifest, agents: CrewAgentRecord[]): RunU
 }
 
 function signatureFor(input: Omit<RunUiSnapshot, "signature" | "fetchedAt">, stamps: SnapshotStamps): string {
-	const digest = createHash("sha256");
-	digest.update(JSON.stringify({
+	try {
+		const digest = createHash("sha256");
+		digest.update(JSON.stringify({
 		run: [input.manifest.runId, input.manifest.status, input.manifest.updatedAt, input.manifest.artifacts.length],
 		tasks: input.tasks.map((task) => [task.id, task.status, task.startedAt, task.finishedAt, task.agentProgress, task.usage]),
 		agents: input.agents.map((agent) => [agent.id, agent.status, agent.startedAt, agent.completedAt, agent.toolUses, agent.progress, agent.usage, agent.model]),
@@ -272,6 +294,10 @@ function signatureFor(input: Omit<RunUiSnapshot, "signature" | "fetchedAt">, sta
 		stamps,
 	}));
 	return digest.digest("hex").slice(0, 16);
+	} catch {
+		// Circular reference or non-serializable data — fall back to timestamp.
+		return String(Date.now());
+	}
 }
 
 function stampsFor(manifest: TeamRunManifest, agents: CrewAgentRecord[]): SnapshotStamps {