pi-crew 0.1.44 → 0.1.45

package/src/ui/render-scheduler.ts

@@ -1,143 +1,143 @@
-import { logInternalError } from "../utils/internal-error.ts";
-
-export interface RenderSchedulerEventBus {
-	on?: (event: string, handler: (payload: unknown) => void) => (() => void) | void;
-}
-
-export interface RenderSchedulerOptions {
-	debounceMs?: number;
-	fallbackMs?: number;
-	events?: string[];
-	onInvalidate?: (payload: unknown) => void;
-}
-
-const DEFAULT_EVENTS = [
-	"crew.run.created",
-	"crew.run.completed",
-	"crew.run.failed",
-	"crew.run.cancelled",
-	"crew.subagent.completed",
-	"crew.subagent.failed",
-	"crew.mailbox.updated",
-	"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 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 = {}) {
-		this.render = render;
-		this.onInvalidate = options.onInvalidate;
-		this.debounceMs = options.debounceMs ?? 75;
-		this.fallbackMs = options.fallbackMs ?? 750;
-		for (const event of options.events ?? DEFAULT_EVENTS) this.subscribe(events, event);
-		this.fallbackTimer = setTimeout(() => this.fallbackLoop(), this.fallbackMs);
-		this.fallbackTimer.unref();
-	}
-
-	private subscribe(events: RenderSchedulerEventBus | undefined, event: string): void {
-		if (!events?.on) return;
-		const handler = (payload: unknown): void => this.schedule(payload);
-		try {
-			const unsub = events.on(event, handler);
-			if (typeof unsub === "function") this.unsubs.push(unsub);
-		} catch (error) {
-			logInternalError("render-scheduler.subscribe", error, event);
-		}
-	}
-
-	/** Recursive setTimeout — avoids setInterval timer storms. */
-	private fallbackLoop(): void {
-		if (this.disposed) return;
-		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 {
-		if (this.disposed) return;
-		this.lastEventAt = Date.now();
-		try {
-			this.onInvalidate?.(payload);
-		} catch (error) {
-			logInternalError("render-scheduler.invalidate", error);
-		}
-		if (this.debounceTimer) clearTimeout(this.debounceTimer);
-		this.debounceTimer = setTimeout(() => {
-			this.debounceTimer = undefined;
-			this.flush();
-		}, this.debounceMs);
-		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 {
-			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();
-			}
-		}
-	}
-
-	dispose(): void {
-		if (this.disposed) return;
-		this.disposed = true;
-		if (this.debounceTimer) clearTimeout(this.debounceTimer);
-		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); }
-		}
-	}
-}
+import { logInternalError } from "../utils/internal-error.ts";
+
+export interface RenderSchedulerEventBus {
+	on?: (event: string, handler: (payload: unknown) => void) => (() => void) | void;
+}
+
+export interface RenderSchedulerOptions {
+	debounceMs?: number;
+	fallbackMs?: number;
+	events?: string[];
+	onInvalidate?: (payload: unknown) => void;
+}
+
+const DEFAULT_EVENTS = [
+	"crew.run.created",
+	"crew.run.completed",
+	"crew.run.failed",
+	"crew.run.cancelled",
+	"crew.subagent.completed",
+	"crew.subagent.failed",
+	"crew.mailbox.updated",
+	"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 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 = {}) {
+		this.render = render;
+		this.onInvalidate = options.onInvalidate;
+		this.debounceMs = options.debounceMs ?? 75;
+		this.fallbackMs = options.fallbackMs ?? 750;
+		for (const event of options.events ?? DEFAULT_EVENTS) this.subscribe(events, event);
+		this.fallbackTimer = setTimeout(() => this.fallbackLoop(), this.fallbackMs);
+		this.fallbackTimer.unref();
+	}
+
+	private subscribe(events: RenderSchedulerEventBus | undefined, event: string): void {
+		if (!events?.on) return;
+		const handler = (payload: unknown): void => this.schedule(payload);
+		try {
+			const unsub = events.on(event, handler);
+			if (typeof unsub === "function") this.unsubs.push(unsub);
+		} catch (error) {
+			logInternalError("render-scheduler.subscribe", error, event);
+		}
+	}
+
+	/** Recursive setTimeout — avoids setInterval timer storms. */
+	private fallbackLoop(): void {
+		if (this.disposed) return;
+		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 {
+		if (this.disposed) return;
+		this.lastEventAt = Date.now();
+		try {
+			this.onInvalidate?.(payload);
+		} catch (error) {
+			logInternalError("render-scheduler.invalidate", error);
+		}
+		if (this.debounceTimer) clearTimeout(this.debounceTimer);
+		this.debounceTimer = setTimeout(() => {
+			this.debounceTimer = undefined;
+			this.flush();
+		}, this.debounceMs);
+		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 {
+			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();
+			}
+		}
+	}
+
+	dispose(): void {
+		if (this.disposed) return;
+		this.disposed = true;
+		if (this.debounceTimer) clearTimeout(this.debounceTimer);
+		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); }
+		}
+	}
+}

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

@@ -1,12 +1,12 @@
 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 as RunSnapshotCacheBase, RunUiGroupJoin, RunUiMailbox, RunUiProgress, RunUiSnapshot, RunUiUsage } from "./snapshot-types.ts";
 
@@ -157,16 +157,6 @@ function readTasks(tasksPath: string): TeamTaskState[] {
 	}
 }
 
-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 [];
@@ -291,13 +281,17 @@ async function recentOutputLinesAsync(manifest: TeamRunManifest, agents: CrewAge
 }
 
 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 {
@@ -379,7 +373,28 @@ async function readGroupJoinMailboxAsync(filePath: string, delivery: Record<stri
 	});
 }
 
-function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMessageStatus>): number {
+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;
@@ -391,10 +406,10 @@ 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<number> {
+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;
@@ -406,7 +421,7 @@ async function readMailboxCountsAsync(filePath: string, delivery: Record<string,
 			return 0;
 		}
 	}) as number[];
-	return items.reduce((sum, val) => sum + val, 0);
+	return { count: items.reduce((sum, val) => sum + val, 0), approximate: await tailApproximateAsync(filePath) };
 }
 
 function groupJoinsFrom(manifest: TeamRunManifest): RunUiGroupJoin[] {
@@ -424,39 +439,43 @@ async function groupJoinsFromAsync(manifest: TeamRunManifest): Promise<RunUiGrou
 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 inboxUnread = await readMailboxCountsAsync(path.join(root, "inbox.jsonl"), delivery);
-	let outboxPending = await readMailboxCountsAsync(path.join(root, "outbox.jsonl"), delivery);
+	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;
-			inboxUnread += await readMailboxCountsAsync(path.join(tasksRoot, entry.name, "inbox.jsonl"), delivery);
-			outboxPending += await readMailboxCountsAsync(path.join(tasksRoot, entry.name, "outbox.jsonl"), delivery);
+			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, outboxPending, needsAttention: inboxUnread + attentionAgents };
+	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 {
@@ -571,9 +590,9 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 	}
 
 	async function buildAsync(runId: string, previous?: CacheEntry): Promise<CacheEntry> {
-		let loaded: ReturnType<typeof loadRunManifestById>;
+		let loaded: Awaited<ReturnType<typeof loadRunManifestByIdAsync>>;
 		try {
-			loaded = loadRunManifestById(cwd, runId);
+			loaded = await loadRunManifestByIdAsync(cwd, runId);
 		} catch {
 			if (previous) return previous;
 			throw new Error(`Run '${runId}' could not be parsed.`);
@@ -585,8 +604,8 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		let tasks: TeamTaskState[];
 		let agents: CrewAgentRecord[];
 		try {
-			tasks = await readTasksAsync(loaded.manifest.tasksPath);
-			agents = readCrewAgents(loaded.manifest);
+			tasks = loaded.tasks;
+			agents = await readCrewAgentsAsync(loaded.manifest);
 		} catch {
 			if (previous) return previous;
 			throw new Error(`Run '${runId}' could not be parsed.`);

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