pi-crew 0.1.43 → 0.1.45

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

@@ -1,14 +1,19 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { readCrewAgents, agentsPath, agentOutputPath } from "../runtime/crew-agent-records.ts";
+import { readCrewAgents, readCrewAgentsAsync, 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 type { TeamEvent } from "../state/event-log.ts";
 import type { MailboxMessageStatus } from "../state/mailbox.ts";
-import { loadRunManifestById } from "../state/state-store.ts";
+import { loadRunManifestById, loadRunManifestByIdAsync } 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";
+
+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;
@@ -60,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());
 }
@@ -84,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);
@@ -96,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;
 }
@@ -141,6 +180,29 @@ function tailJsonlLines<T>(filePath: string, limit: number, parse: (line: string
 	}
 }
 
+/** 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 {
+		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 {
@@ -152,6 +214,17 @@ function safeRecentEvents(eventsPath: string, limit: number): TeamEvent[] {
 	});
 }
 
+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 {
@@ -170,6 +243,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) => {
@@ -179,14 +270,28 @@ 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,
-		completed: tasks.filter((task) => task.status === "completed").length,
-		running: tasks.filter((task) => task.status === "running").length,
-		failed: tasks.filter((task) => task.status === "failed").length,
-		queued: tasks.filter((task) => task.status === "queued").length,
-	};
+	const progress: RunUiProgress = { total: tasks.length, completed: 0, running: 0, failed: 0, queued: 0, waiting: 0, cancelled: 0, skipped: 0 };
+	for (const task of tasks) {
+		if (task.status === "completed") progress.completed += 1;
+		else if (task.status === "running") progress.running += 1;
+		else if (task.status === "failed") progress.failed += 1;
+		else if (task.status === "queued") progress.queued += 1;
+		else if (task.status === "waiting") progress.waiting = (progress.waiting ?? 0) + 1;
+		else if (task.status === "cancelled") progress.cancelled = (progress.cancelled ?? 0) + 1;
+		else if (task.status === "skipped") progress.skipped = (progress.skipped ?? 0) + 1;
+	}
+	return progress;
 }
 
 function usageFrom(tasks: TeamTaskState[], agents: CrewAgentRecord[]): RunUiUsage {
@@ -223,6 +328,21 @@ function readDeliveryMessages(filePath: string): Record<string, MailboxMessageSt
 	}
 }
 
+async function readDeliveryMessagesAsync(filePath: string): Promise<Record<string, MailboxMessageStatus>> {
+	try {
+		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 {};
+	}
+}
+
 function readGroupJoinMailbox(filePath: string, delivery: Record<string, MailboxMessageStatus>): RunUiGroupJoin[] {
 	return tailJsonlLines(filePath, MAX_TAIL_LINES, (line) => {
 		try {
@@ -238,7 +358,43 @@ function readGroupJoinMailbox(filePath: string, delivery: Record<string, Mailbox
 	});
 }
 
-function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMessageStatus>): number {
+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;
+		}
+	});
+}
+
+interface MailboxCount {
+	count: number;
+	approximate: boolean;
+}
+
+function tailApproximate(filePath: string): boolean {
+	try {
+		return fs.statSync(filePath).size > MAX_TAIL_BYTES;
+	} catch {
+		return false;
+	}
+}
+
+async function tailApproximateAsync(filePath: string): Promise<boolean> {
+	try {
+		return (await fs.promises.stat(filePath)).size > MAX_TAIL_BYTES;
+	} catch {
+		return false;
+	}
+}
+
+function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMessageStatus>): MailboxCount {
 	const items = tailJsonlLines(filePath, MAX_TAIL_LINES, (line) => {
 		try {
 			const parsed = JSON.parse(line) as unknown;
@@ -250,7 +406,22 @@ function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMes
 			return 0;
 		}
 	}) as number[];
-	return items.reduce((sum, val) => sum + val, 0);
+	return { count: items.reduce((sum, val) => sum + val, 0), approximate: tailApproximate(filePath) };
+}
+
+async function readMailboxCountsAsync(filePath: string, delivery: Record<string, MailboxMessageStatus>): Promise<MailboxCount> {
+	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 { count: items.reduce((sum, val) => sum + val, 0), approximate: await tailApproximateAsync(filePath) };
 }
 
 function groupJoinsFrom(manifest: TeamRunManifest): RunUiGroupJoin[] {
@@ -259,23 +430,52 @@ 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"));
-	let inboxUnread = readMailboxCounts(path.join(root, "inbox.jsonl"), delivery);
-	let outboxPending = readMailboxCounts(path.join(root, "outbox.jsonl"), delivery);
+	let inbox = readMailboxCounts(path.join(root, "inbox.jsonl"), delivery);
+	let outbox = readMailboxCounts(path.join(root, "outbox.jsonl"), delivery);
 	const tasksRoot = path.join(root, "tasks");
 	try {
 		for (const entry of fs.readdirSync(tasksRoot, { withFileTypes: true })) {
 			if (!entry.isDirectory()) continue;
-			inboxUnread += readMailboxCounts(path.join(tasksRoot, entry.name, "inbox.jsonl"), delivery);
-			outboxPending += readMailboxCounts(path.join(tasksRoot, entry.name, "outbox.jsonl"), delivery);
+			const taskInbox = readMailboxCounts(path.join(tasksRoot, entry.name, "inbox.jsonl"), delivery);
+			const taskOutbox = readMailboxCounts(path.join(tasksRoot, entry.name, "outbox.jsonl"), delivery);
+			inbox = { count: inbox.count + taskInbox.count, approximate: inbox.approximate || taskInbox.approximate };
+			outbox = { count: outbox.count + taskOutbox.count, approximate: outbox.approximate || taskOutbox.approximate };
 		}
 	} catch {
 		// No task mailboxes yet.
 	}
 	const attentionAgents = agents.filter((agent) => agent.progress?.activityState === "needs_attention").length;
-	return { inboxUnread, outboxPending, needsAttention: inboxUnread + attentionAgents };
+	return { inboxUnread: inbox.count, outboxPending: outbox.count, needsAttention: inbox.count + attentionAgents, approximate: inbox.approximate || outbox.approximate };
+}
+
+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 inbox = await readMailboxCountsAsync(path.join(root, "inbox.jsonl"), delivery);
+	let outbox = 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;
+			const taskInbox = await readMailboxCountsAsync(path.join(tasksRoot, entry.name, "inbox.jsonl"), delivery);
+			const taskOutbox = await readMailboxCountsAsync(path.join(tasksRoot, entry.name, "outbox.jsonl"), delivery);
+			inbox = { count: inbox.count + taskInbox.count, approximate: inbox.approximate || taskInbox.approximate };
+			outbox = { count: outbox.count + taskOutbox.count, approximate: outbox.approximate || taskOutbox.approximate };
+		}
+	} catch {
+		// No task mailboxes yet.
+	}
+	const attentionAgents = agents.filter((agent) => agent.progress?.activityState === "needs_attention").length;
+	return { inboxUnread: inbox.count, outboxPending: outbox.count, needsAttention: inbox.count + attentionAgents, approximate: inbox.approximate || outbox.approximate };
 }
 
 function signatureFor(input: Omit<RunUiSnapshot, "signature" | "fetchedAt">, stamps: SnapshotStamps): string {
@@ -311,6 +511,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;
@@ -377,6 +589,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: Awaited<ReturnType<typeof loadRunManifestByIdAsync>>;
+		try {
+			loaded = await loadRunManifestByIdAsync(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 = loaded.tasks;
+			agents = await readCrewAgentsAsync(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 {
@@ -389,6 +646,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);
@@ -410,6 +701,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/snapshot-types.ts

@@ -8,6 +8,9 @@ export interface RunUiProgress {
 	running: number;
 	failed: number;
 	queued: number;
+	waiting?: number;
+	cancelled?: number;
+	skipped?: number;
 }
 
 export interface RunUiUsage {
@@ -20,6 +23,8 @@ export interface RunUiMailbox {
 	inboxUnread: number;
 	outboxPending: number;
 	needsAttention: number;
+	/** True when counts come from bounded tail reads and older messages may be omitted. */
+	approximate?: boolean;
 }
 
 export interface RunUiGroupJoin {

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);
+}