pi-crew 0.1.41 → 0.1.44

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

@@ -4,17 +4,24 @@ 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";
+import type { RunSnapshotCache as RunSnapshotCacheBase, RunUiGroupJoin, RunUiMailbox, RunUiProgress, RunUiSnapshot, RunUiUsage } from "./snapshot-types.ts";
 
-const DEFAULT_TTL_MS = 250;
+export interface RunSnapshotCache extends RunSnapshotCacheBase {
+	preloadStale(runId: string): Promise<RunUiSnapshot | undefined>;
+	preloadAllStale(runIds: string[]): Promise<void>;
+}
+
+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;
@@ -58,6 +65,16 @@ function stampFile(filePath: string | undefined): FileStamp {
 	}
 }
 
+async function stampFileAsync(filePath: string | undefined): Promise<FileStamp> {
+	if (!filePath) return zeroStamp();
+	try {
+		const stat = await fs.promises.stat(filePath);
+		return { mtimeMs: stat.mtimeMs, size: stat.size };
+	} catch {
+		return zeroStamp();
+	}
+}
+
 function combineStamps(stamps: FileStamp[]): FileStamp {
 	return stamps.reduce((acc, stamp) => ({ mtimeMs: Math.max(acc.mtimeMs, stamp.mtimeMs), size: acc.size + stamp.size }), zeroStamp());
 }
@@ -82,6 +99,26 @@ function mailboxStamp(manifest: TeamRunManifest): FileStamp {
 	return combineStamps(stamps);
 }
 
+async function mailboxStampAsync(manifest: TeamRunManifest): Promise<FileStamp> {
+	const root = path.join(manifest.stateRoot, "mailbox");
+	const stamps: FileStamp[] = [
+		await stampFileAsync(path.join(root, "inbox.jsonl")),
+		await stampFileAsync(path.join(root, "outbox.jsonl")),
+		await stampFileAsync(path.join(root, "delivery.json")),
+	];
+	const tasksRoot = path.join(root, "tasks");
+	try {
+		for (const entry of await fs.promises.readdir(tasksRoot, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			stamps.push(await stampFileAsync(path.join(tasksRoot, entry.name, "inbox.jsonl")));
+			stamps.push(await stampFileAsync(path.join(tasksRoot, entry.name, "outbox.jsonl")));
+		}
+	} catch {
+		// No task mailbox yet.
+	}
+	return combineStamps(stamps);
+}
+
 function safeAgentOutputPath(manifest: TeamRunManifest, agent: CrewAgentRecord): string | undefined {
 	try {
 		return agentOutputPath(manifest, agent.taskId);
@@ -94,6 +131,10 @@ function outputStamp(manifest: TeamRunManifest, agents: CrewAgentRecord[]): File
 	return combineStamps(agents.map((agent) => stampFile(safeAgentOutputPath(manifest, agent))));
 }
 
+async function outputStampAsync(manifest: TeamRunManifest, agents: CrewAgentRecord[]): Promise<FileStamp> {
+	return combineStamps(await Promise.all(agents.map((agent) => stampFileAsync(safeAgentOutputPath(manifest, agent)))));
+}
+
 function sameStamp(a: FileStamp, b: FileStamp): boolean {
 	return a.mtimeMs === b.mtimeMs && a.size === b.size;
 }
@@ -116,14 +157,84 @@ function readTasks(tasksPath: string): TeamTaskState[] {
 	}
 }
 
-function safeRecentEvents(eventsPath: string, limit: number): TeamEvent[] {
+async function readTasksAsync(tasksPath: string): Promise<TeamTaskState[]> {
+	try {
+		const content = await fs.promises.readFile(tasksPath, "utf-8");
+		const parsed = JSON.parse(content) as unknown;
+		return Array.isArray(parsed) ? (parsed as TeamTaskState[]) : [];
+	} catch {
+		throw new Error(`Failed to parse tasks at ${tasksPath}`);
+	}
+}
+
+/** 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 {
+		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 [];
+	}
+}
+
+/** Async tail-read JSONL lines from a file, returning parsed objects (limited). */
+async function tailJsonlLinesAsync<T>(filePath: string, limit: number, parse: (line: string) => T | undefined): Promise<T[]> {
+	if (limit <= 0) return [];
 	try {
-		return readEvents(eventsPath).slice(-limit);
+		const stat = await fs.promises.stat(filePath);
+		const bytesToRead = Math.min(stat.size, MAX_TAIL_BYTES);
+		const handle = await fs.promises.open(filePath, "r");
+		try {
+			const buffer = Buffer.alloc(bytesToRead);
+			await handle.read(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 {
+			await handle.close();
+		}
 	} 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;
+		}
+	});
+}
+
+async function safeRecentEventsAsync(eventsPath: string, limit: number): Promise<TeamEvent[]> {
+	return tailJsonlLinesAsync(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 {
@@ -142,6 +253,24 @@ function tailLines(filePath: string, limit: number): string[] {
 	}
 }
 
+async function tailLinesAsync(filePath: string, limit: number): Promise<string[]> {
+	if (limit <= 0) return [];
+	try {
+		const stat = await fs.promises.stat(filePath);
+		const bytesToRead = Math.min(stat.size, MAX_TAIL_BYTES);
+		const handle = await fs.promises.open(filePath, "r");
+		try {
+			const buffer = Buffer.alloc(bytesToRead);
+			await handle.read(buffer, 0, bytesToRead, stat.size - bytesToRead);
+			return buffer.toString("utf-8").split(/\r?\n/).filter(Boolean).slice(-limit);
+		} finally {
+			await handle.close();
+		}
+	} catch {
+		return [];
+	}
+}
+
 function recentOutputLines(manifest: TeamRunManifest, agents: CrewAgentRecord[], limit: number): string[] {
 	const fromProgress = agents.flatMap((agent) => agent.progress?.recentOutput ?? []);
 	const fromFiles = agents.flatMap((agent) => {
@@ -151,6 +280,16 @@ function recentOutputLines(manifest: TeamRunManifest, agents: CrewAgentRecord[],
 	return [...fromProgress, ...fromFiles].map((line) => line.replace(/\s+/g, " ").trim()).filter(Boolean).slice(-limit);
 }
 
+async function recentOutputLinesAsync(manifest: TeamRunManifest, agents: CrewAgentRecord[], limit: number): Promise<string[]> {
+	const fromProgress = agents.flatMap((agent) => agent.progress?.recentOutput ?? []);
+	const fromFilesArrays = await Promise.all(agents.map((agent) => {
+		const outputPath = safeAgentOutputPath(manifest, agent);
+		return outputPath ? tailLinesAsync(outputPath, limit) : Promise.resolve([]);
+	}));
+	const fromFiles = fromFilesArrays.flat();
+	return [...fromProgress, ...fromFiles].map((line) => line.replace(/\s+/g, " ").trim()).filter(Boolean).slice(-limit);
+}
+
 function progressFromTasks(tasks: TeamTaskState[]): RunUiProgress {
 	return {
 		total: tasks.length,
@@ -195,41 +334,79 @@ function readDeliveryMessages(filePath: string): Record<string, MailboxMessageSt
 	}
 }
 
-function readGroupJoinMailbox(filePath: string, delivery: Record<string, MailboxMessageStatus>): RunUiGroupJoin[] {
+async function readDeliveryMessagesAsync(filePath: string): Promise<Record<string, MailboxMessageStatus>> {
 	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 [];
-			}
-		});
+		const content = await fs.promises.readFile(filePath, "utf-8");
+		const parsed = JSON.parse(content) as unknown;
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		const messages = (parsed as { messages?: unknown }).messages;
+		if (!messages || typeof messages !== "object" || Array.isArray(messages)) return {};
+		const output: Record<string, MailboxMessageStatus> = {};
+		for (const [id, status] of Object.entries(messages)) if (isMailboxStatus(status)) output[id] = status;
+		return output;
 	} catch {
-		return [];
+		return {};
 	}
 }
 
+function readGroupJoinMailbox(filePath: string, delivery: Record<string, MailboxMessageStatus>): RunUiGroupJoin[] {
+	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;
+		}
+	});
+}
+
+async function readGroupJoinMailboxAsync(filePath: string, delivery: Record<string, MailboxMessageStatus>): Promise<RunUiGroupJoin[]> {
+	return tailJsonlLinesAsync(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);
+}
+
+async function readMailboxCountsAsync(filePath: string, delivery: Record<string, MailboxMessageStatus>): Promise<number> {
+	const items = await tailJsonlLinesAsync(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[] {
@@ -238,6 +415,12 @@ function groupJoinsFrom(manifest: TeamRunManifest): RunUiGroupJoin[] {
 	return readGroupJoinMailbox(path.join(root, "outbox.jsonl"), delivery).slice(-5);
 }
 
+async function groupJoinsFromAsync(manifest: TeamRunManifest): Promise<RunUiGroupJoin[]> {
+	const root = path.join(manifest.stateRoot, "mailbox");
+	const delivery = await readDeliveryMessagesAsync(path.join(root, "delivery.json"));
+	return (await readGroupJoinMailboxAsync(path.join(root, "outbox.jsonl"), delivery)).slice(-5);
+}
+
 function mailboxFrom(manifest: TeamRunManifest, agents: CrewAgentRecord[]): RunUiMailbox {
 	const root = path.join(manifest.stateRoot, "mailbox");
 	const delivery = readDeliveryMessages(path.join(root, "delivery.json"));
@@ -257,9 +440,29 @@ function mailboxFrom(manifest: TeamRunManifest, agents: CrewAgentRecord[]): RunU
 	return { inboxUnread, outboxPending, needsAttention: inboxUnread + attentionAgents };
 }
 
+async function mailboxFromAsync(manifest: TeamRunManifest, agents: CrewAgentRecord[]): Promise<RunUiMailbox> {
+	const root = path.join(manifest.stateRoot, "mailbox");
+	const delivery = await readDeliveryMessagesAsync(path.join(root, "delivery.json"));
+	let inboxUnread = await readMailboxCountsAsync(path.join(root, "inbox.jsonl"), delivery);
+	let outboxPending = await readMailboxCountsAsync(path.join(root, "outbox.jsonl"), delivery);
+	const tasksRoot = path.join(root, "tasks");
+	try {
+		for (const entry of await fs.promises.readdir(tasksRoot, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			inboxUnread += await readMailboxCountsAsync(path.join(tasksRoot, entry.name, "inbox.jsonl"), delivery);
+			outboxPending += await readMailboxCountsAsync(path.join(tasksRoot, entry.name, "outbox.jsonl"), delivery);
+		}
+	} catch {
+		// No task mailboxes yet.
+	}
+	const attentionAgents = agents.filter((agent) => agent.progress?.activityState === "needs_attention").length;
+	return { inboxUnread, outboxPending, needsAttention: inboxUnread + attentionAgents };
+}
+
 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 +475,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 {
@@ -285,6 +492,18 @@ function stampsFor(manifest: TeamRunManifest, agents: CrewAgentRecord[]): Snapsh
 	};
 }
 
+async function stampsForAsync(manifest: TeamRunManifest, agents: CrewAgentRecord[]): Promise<SnapshotStamps> {
+	const [manifestStamp, tasksStamp, agentsStamp, eventsStamp, mailbox, output] = await Promise.all([
+		stampFileAsync(path.join(manifest.stateRoot, "manifest.json")),
+		stampFileAsync(manifest.tasksPath),
+		stampFileAsync(agentsPath(manifest)),
+		stampFileAsync(manifest.eventsPath),
+		mailboxStampAsync(manifest),
+		outputStampAsync(manifest, agents),
+	]);
+	return { manifest: manifestStamp, tasks: tasksStamp, agents: agentsStamp, events: eventsStamp, mailbox, output };
+}
+
 export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOptions = {}): RunSnapshotCache {
 	const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
 	const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
@@ -351,6 +570,51 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		return { snapshot, stamps, loadedAtMs: snapshot.fetchedAt, lastAccessMs: snapshot.fetchedAt };
 	}
 
+	async function buildAsync(runId: string, previous?: CacheEntry): Promise<CacheEntry> {
+		let loaded: ReturnType<typeof loadRunManifestById>;
+		try {
+			loaded = loadRunManifestById(cwd, runId);
+		} catch {
+			if (previous) return previous;
+			throw new Error(`Run '${runId}' could not be parsed.`);
+		}
+		if (!loaded) {
+			if (previous) return previous;
+			throw new Error(`Run '${runId}' not found.`);
+		}
+		let tasks: TeamTaskState[];
+		let agents: CrewAgentRecord[];
+		try {
+			tasks = await readTasksAsync(loaded.manifest.tasksPath);
+			agents = readCrewAgents(loaded.manifest);
+		} catch {
+			if (previous) return previous;
+			throw new Error(`Run '${runId}' could not be parsed.`);
+		}
+		const [mailbox, groupJoins, recentEvents, recentOutput] = await Promise.all([
+			mailboxFromAsync(loaded.manifest, agents),
+			groupJoinsFromAsync(loaded.manifest),
+			safeRecentEventsAsync(loaded.manifest.eventsPath, recentEventsLimit),
+			recentOutputLinesAsync(loaded.manifest, agents, recentOutputLimit),
+		]);
+		const base = {
+			runId: loaded.manifest.runId,
+			cwd: loaded.manifest.cwd,
+			manifest: loaded.manifest,
+			tasks,
+			agents,
+			progress: progressFromTasks(tasks),
+			usage: usageFrom(tasks, agents),
+			mailbox,
+			groupJoins,
+			recentEvents,
+			recentOutputLines: recentOutput,
+		};
+		const stamps = await stampsForAsync(loaded.manifest, agents);
+		const snapshot: RunUiSnapshot = { ...base, fetchedAt: Date.now(), signature: signatureFor(base, stamps) };
+		return { snapshot, stamps, loadedAtMs: snapshot.fetchedAt, lastAccessMs: snapshot.fetchedAt };
+	}
+
 	function currentStamps(previous: CacheEntry): SnapshotStamps {
 		const manifest = previous.snapshot.manifest;
 		return {
@@ -363,6 +627,40 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		};
 	}
 
+	async function currentStampsAsync(previous: CacheEntry): Promise<SnapshotStamps> {
+		return stampsForAsync(previous.snapshot.manifest, previous.snapshot.agents);
+	}
+
+	async function preloadStale(runId: string): Promise<RunUiSnapshot | undefined> {
+		const previous = entries.get(runId);
+		const now = Date.now();
+		// Fresh enough? Return immediately
+		if (previous && now - previous.loadedAtMs < ttlMs) {
+			return touch(runId, previous);
+		}
+		// Check stamps async
+		if (previous) {
+			const stamps = await currentStampsAsync(previous);
+			if (sameStamps(stamps, previous.stamps)) {
+				previous.loadedAtMs = now;
+				return touch(runId, previous);
+			}
+		}
+		// Full async build
+		const entry = await buildAsync(runId, previous);
+		entries.set(runId, entry);
+		evictIfNeeded();
+		return entry.snapshot;
+	}
+
+	async function preloadAllStale(runIds: string[]): Promise<void> {
+		const batchSize = 4;
+		for (let i = 0; i < runIds.length; i += batchSize) {
+			const batch = runIds.slice(i, i + batchSize);
+			await Promise.all(batch.map((id) => preloadStale(id)));
+		}
+	}
+
 	return {
 		get(runId: string): RunUiSnapshot | undefined {
 			const entry = entries.get(runId);
@@ -384,6 +682,8 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			if (sameStamps(stamps, previous.stamps)) return touch(runId, previous);
 			return this.refresh(runId);
 		},
+		preloadStale,
+		preloadAllStale,
 		invalidate(runId?: string): void {
 			if (runId) entries.delete(runId);
 			else entries.clear();

package/src/ui/spinner.ts

@@ -1,17 +1,17 @@
-export const SUBAGENT_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
-export const SUBAGENT_SPINNER_FRAME_MS = 160;
-
-export function spinnerBucket(now = Date.now(), frameMs = SUBAGENT_SPINNER_FRAME_MS): number {
-	return Math.floor(now / Math.max(1, frameMs));
-}
-
-function hashKey(key: string): number {
-	let hash = 0;
-	for (let index = 0; index < key.length; index += 1) hash = (hash * 31 + key.charCodeAt(index)) >>> 0;
-	return hash;
-}
-
-export function spinnerFrame(key = "", now = Date.now()): string {
-	const offset = key ? hashKey(key) % SUBAGENT_SPINNER_FRAMES.length : 0;
-	return SUBAGENT_SPINNER_FRAMES[(spinnerBucket(now) + offset) % SUBAGENT_SPINNER_FRAMES.length] ?? SUBAGENT_SPINNER_FRAMES[0];
-}
+export const SUBAGENT_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
+export const SUBAGENT_SPINNER_FRAME_MS = 160;
+
+export function spinnerBucket(now = Date.now(), frameMs = SUBAGENT_SPINNER_FRAME_MS): number {
+	return Math.floor(now / Math.max(1, frameMs));
+}
+
+function hashKey(key: string): number {
+	let hash = 0;
+	for (let index = 0; index < key.length; index += 1) hash = (hash * 31 + key.charCodeAt(index)) >>> 0;
+	return hash;
+}
+
+export function spinnerFrame(key = "", now = Date.now()): string {
+	const offset = key ? hashKey(key) % SUBAGENT_SPINNER_FRAMES.length : 0;
+	return SUBAGENT_SPINNER_FRAMES[(spinnerBucket(now) + offset) % SUBAGENT_SPINNER_FRAMES.length] ?? SUBAGENT_SPINNER_FRAMES[0];
+}

package/src/ui/status-colors.ts

@@ -1,54 +1,58 @@
-import type { CrewTheme, CrewThemeColor } from "./theme-adapter.ts";
-
-export type RunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "stopped" | "blocked" | (string & {});
-
-export function colorForStatus(status: RunStatus): CrewThemeColor {
-	switch (status) {
-		case "running":
-			return "accent";
-		case "completed":
-			return "success";
-		case "failed":
-		case "stale":
-			return "error";
-		case "cancelled":
-		case "blocked":
-		case "stopped":
-			return "warning";
-		case "queued":
-		default:
-			return "dim";
-	}
-}
-
-export function iconForStatus(status: RunStatus, options?: { runningGlyph?: string }): string {
-	const glyph = options?.runningGlyph ?? "▶";
-	switch (status) {
-		case "completed":
-			return "✓";
-		case "failed":
-		case "stale":
-			return "✗";
-		case "cancelled":
-		case "stopped":
-			return "■";
-		case "running":
-			return glyph;
-		case "queued":
-			return "◦";
-		case "blocked":
-			return "⏸";
-		default:
-			return "·";
-	}
-}
-
-export function colorForActivity(activityState: string | undefined): CrewThemeColor {
-	if (activityState === "needs_attention") return "warning";
-	if (activityState === "stale") return "error";
-	return "dim";
-}
-
-export function applyStatusColor(theme: CrewTheme, status: RunStatus, text: string): string {
-	return theme.fg(colorForStatus(status), text);
-}
+import type { CrewTheme, CrewThemeColor } from "./theme-adapter.ts";
+
+export type RunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "stopped" | "blocked" | (string & {});
+
+export function colorForStatus(status: RunStatus): CrewThemeColor {
+	switch (status) {
+		case "running":
+			return "accent";
+		case "waiting":
+			return "muted";
+		case "completed":
+			return "success";
+		case "failed":
+		case "stale":
+			return "error";
+		case "cancelled":
+		case "blocked":
+		case "stopped":
+			return "warning";
+		case "queued":
+		default:
+			return "dim";
+	}
+}
+
+export function iconForStatus(status: RunStatus, options?: { runningGlyph?: string }): string {
+	const glyph = options?.runningGlyph ?? "▶";
+	switch (status) {
+		case "completed":
+			return "✓";
+		case "failed":
+		case "stale":
+			return "✗";
+		case "cancelled":
+		case "stopped":
+			return "■";
+		case "running":
+			return glyph;
+		case "waiting":
+			return "⏳";
+		case "queued":
+			return "◦";
+		case "blocked":
+			return "⏸";
+		default:
+			return "·";
+	}
+}
+
+export function colorForActivity(activityState: string | undefined): CrewThemeColor {
+	if (activityState === "needs_attention") return "warning";
+	if (activityState === "stale") return "error";
+	return "dim";
+}
+
+export function applyStatusColor(theme: CrewTheme, status: RunStatus, text: string): string {
+	return theme.fg(colorForStatus(status), text);
+}