pi-crew 0.1.46 → 0.1.49

package/src/ui/run-event-bus.ts

@@ -0,0 +1,209 @@
+import type { TeamEvent } from "../state/event-log.ts";
+
+export type RunEventType =
+	| "task_started"
+	| "task_completed"
+	| "task_failed"
+	| "task_cancelled"
+	| "worker_status"
+	| "mailbox_updated"
+	| "effectiveness_changed"
+	| "run_started"
+	| "run_completed"
+	| "run_blocked"
+	| "run_cancelled";
+
+/** Typed channel names for category-based event subscription. */
+export type EventChannel =
+	| "worker:progress"
+	| "worker:lifecycle"
+	| "worker:stream"
+	| "run:state"
+	| "ui:invalidate";
+
+/** Sets used by classifyEventChannel for O(1) lookup. */
+const WORKER_PROGRESS_TYPES = new Set([
+	"tool_execution_start", "tool_result", "agent_progress", "worker_status",
+]);
+const WORKER_LIFECYCLE_TYPES = new Set([
+	"task.started", "task.completed", "task.failed",
+	"task_started", "task_completed", "task_failed", "task_cancelled",
+	"run.started", "run.completed", "run.cancelled", "run.failed",
+	"run_started", "run_completed", "run_cancelled", "run_blocked",
+]);
+const WORKER_STREAM_TYPES = new Set([
+	"stdout_chunk", "stderr_chunk", "stream",
+]);
+const RUN_STATE_TYPES = new Set([
+	"manifest.saved", "task.claimed", "task.unclaimed", "mailbox_updated",
+]);
+const UI_INVALIDATE_TYPES = new Set([
+	"effectiveness_changed", "snapshot_stale",
+]);
+
+/** Classify an event type string into a typed channel. */
+export function classifyEventChannel(type: string): EventChannel {
+	if (WORKER_PROGRESS_TYPES.has(type)) return "worker:progress";
+	if (WORKER_LIFECYCLE_TYPES.has(type)) return "worker:lifecycle";
+	if (WORKER_STREAM_TYPES.has(type)) return "worker:stream";
+	if (RUN_STATE_TYPES.has(type)) return "run:state";
+	if (UI_INVALIDATE_TYPES.has(type)) return "ui:invalidate";
+	return "worker:progress"; // default fallback
+}
+
+export interface RunEventPayload {
+	type: RunEventType;
+	runId: string;
+	taskId?: string;
+	timestamp?: string;
+	data?: unknown;
+	channel?: EventChannel;
+}
+
+export type RunEventCallback = (event: RunEventPayload) => void;
+
+class RunEventBus {
+	#listeners = new Map<string, Set<RunEventCallback>>();
+	#globalListeners = new Set<RunEventCallback>();
+	#channelListeners = new Map<EventChannel, Set<RunEventCallback>>();
+	#channelRunListeners = new Map<string, Map<EventChannel, Set<RunEventCallback>>>();
+
+	on(runId: string, callback: RunEventCallback): () => void {
+		const listeners = this.#listeners.get(runId) ?? new Set();
+		listeners.add(callback);
+		this.#listeners.set(runId, listeners);
+		return () => { listeners.delete(callback); if (listeners.size === 0) this.#listeners.delete(runId); };
+	}
+
+	onAny(callback: RunEventCallback): () => void {
+		this.#globalListeners.add(callback);
+		return () => { this.#globalListeners.delete(callback); };
+	}
+
+	off(runId: string, callback: RunEventCallback): void {
+		const listeners = this.#listeners.get(runId);
+		if (listeners) {
+			listeners.delete(callback);
+			if (listeners.size === 0) this.#listeners.delete(runId);
+		}
+	}
+
+	/** Subscribe to all events on a specific channel. */
+	onChannel(channel: EventChannel, callback: RunEventCallback): () => void {
+		const listeners = this.#channelListeners.get(channel) ?? new Set();
+		listeners.add(callback);
+		this.#channelListeners.set(channel, listeners);
+		return () => {
+			listeners.delete(callback);
+			if (listeners.size === 0) this.#channelListeners.delete(channel);
+		};
+	}
+
+	/** Subscribe to events on a specific channel for a given runId. */
+	onChannelForRun(channel: EventChannel, runId: string, callback: RunEventCallback): () => void {
+		const runKey = `${channel}::${runId}`;
+		const runMap = this.#channelRunListeners.get(runKey) ?? new Map();
+		const listeners = runMap.get(channel) ?? new Set();
+		listeners.add(callback);
+		runMap.set(channel, listeners);
+		this.#channelRunListeners.set(runKey, runMap);
+		return () => {
+			listeners.delete(callback);
+			if (listeners.size === 0) runMap.delete(channel);
+			if (runMap.size === 0) this.#channelRunListeners.delete(runKey);
+		};
+	}
+
+	emit(event: RunEventPayload): void {
+		// Auto-classify channel if not already set.
+		// M2: Use local variable for routing, but also set on event
+		// for subscriber API contract (listeners read event.channel).
+		if (!event.channel) {
+			(event as { channel?: EventChannel }).channel = classifyEventChannel(event.type);
+		}
+		const channel = event.channel!;
+
+		// Existing: runId-specific listeners
+		const listeners = this.#listeners.get(event.runId);
+		if (listeners) {
+			for (const cb of listeners) {
+				try { cb(event); } catch { /* subscriber errors are non-fatal */ }
+			}
+		}
+
+		// Existing: global listeners
+		for (const cb of this.#globalListeners) {
+			try { cb(event); } catch { /* subscriber errors are non-fatal */ }
+		}
+
+		// New: channel listeners
+		const channelListeners = this.#channelListeners.get(channel);
+		if (channelListeners) {
+			for (const cb of channelListeners) {
+				try { cb(event); } catch { /* subscriber errors are non-fatal */ }
+			}
+		}
+
+		// New: channel+runId listeners
+		const runKey = `${channel}::${event.runId}`;
+		const runMap = this.#channelRunListeners.get(runKey);
+		if (runMap) {
+			const runChannelListeners = runMap.get(channel);
+			if (runChannelListeners) {
+				for (const cb of runChannelListeners) {
+					try { cb(event); } catch { /* subscriber errors are non-fatal */ }
+				}
+			}
+		}
+	}
+
+	/** Dispose all subscriptions including channel-based ones. */
+	dispose(): void {
+		this.#listeners.clear();
+		this.#globalListeners.clear();
+		this.#channelListeners.clear();
+		this.#channelRunListeners.clear();
+	}
+
+	listenerCount(runId?: string): number {
+		if (runId) return this.#listeners.get(runId)?.size ?? 0;
+		let total = this.#globalListeners.size;
+		for (const set of this.#listeners.values()) total += set.size;
+		for (const set of this.#channelListeners.values()) total += set.size;
+		for (const runMap of this.#channelRunListeners.values()) {
+			for (const set of runMap.values()) total += set.size;
+		}
+		return total;
+	}
+}
+
+/** Global singleton run event bus for UI-first event delivery. */
+export const runEventBus = new RunEventBus();
+
+/** Derive a RunEventType from a TeamEvent. */
+export function teamEventToRunEventType(event: TeamEvent): RunEventType | undefined {
+	const type = event.type;
+	if (type === "task.started") return "task_started";
+	if (type === "task.completed") return "task_completed";
+	if (type === "task.failed") return "task_failed";
+	if (type === "run.completed") return "run_completed";
+	if (type === "run.blocked") return "run_blocked";
+	if (type === "run.running") return "run_started";
+	if (type === "run.cancelled") return "run_cancelled";
+	if (type === "task.progress" || type === "mailbox.message_queued" || type === "mailbox.message_delivered") return "mailbox_updated";
+	if (type === "run.effectiveness" || type === "task.attention") return "effectiveness_changed";
+	return undefined;
+}
+
+/** Emit a run event from a TeamEvent. */
+export function emitFromTeamEvent(event: TeamEvent): void {
+	const type = teamEventToRunEventType(event);
+	if (!type) return;
+	runEventBus.emit({
+		type,
+		runId: event.runId,
+		taskId: event.taskId,
+		timestamp: event.time,
+		data: event.data,
+	});
+}

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

@@ -9,6 +9,7 @@ import type { MailboxMessageStatus } from "../state/mailbox.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";
+import { runEventBus } from "./run-event-bus.ts";
 
 export interface RunSnapshotCache extends RunSnapshotCacheBase {
 	preloadStale(runId: string): Promise<RunUiSnapshot | undefined>;
@@ -378,6 +379,13 @@ interface MailboxCount {
 	approximate: boolean;
 }
 
+interface MailboxKindCount extends MailboxCount {
+	steer: number;
+	followUp: number;
+	response: number;
+	message: number;
+}
+
 function tailApproximate(filePath: string): boolean {
 	try {
 		return fs.statSync(filePath).size > MAX_TAIL_BYTES;
@@ -394,34 +402,54 @@ async function tailApproximateAsync(filePath: string): Promise<boolean> {
 	}
 }
 
-function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMessageStatus>): MailboxCount {
+function readMailboxCounts(filePath: string, delivery: Record<string, MailboxMessageStatus>): MailboxKindCount {
+	const kindCounts = { steer: 0, followUp: 0, response: 0, message: 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;
+			const msg = parsed as { id?: unknown; status?: unknown; kind?: unknown; data?: unknown };
+			if (typeof msg.id !== "string" || !isMailboxStatus(msg.status)) return 0;
+			if (msg.status !== "acknowledged" && delivery[msg.id] !== "acknowledged") {
+				const kind = typeof msg.kind === "string" ? msg.kind : typeof (msg.data as Record<string, unknown>)?.kind === "string" ? (msg.data as Record<string, unknown>).kind as string : undefined;
+				if (kind === "steer") kindCounts.steer++;
+				else if (kind === "follow-up") kindCounts.followUp++;
+				else if (kind === "response") kindCounts.response++;
+				else kindCounts.message++;
+				return 1;
+			}
+			return 0;
 		} catch {
 			return 0;
 		}
 	}) as number[];
-	return { count: items.reduce((sum, val) => sum + val, 0), approximate: tailApproximate(filePath) };
+	const count = items.reduce((sum, val) => sum + val, 0);
+	return { count, approximate: tailApproximate(filePath), steer: kindCounts.steer, followUp: kindCounts.followUp, response: kindCounts.response, message: kindCounts.message };
 }
 
-async function readMailboxCountsAsync(filePath: string, delivery: Record<string, MailboxMessageStatus>): Promise<MailboxCount> {
+async function readMailboxCountsAsync(filePath: string, delivery: Record<string, MailboxMessageStatus>): Promise<MailboxKindCount> {
+	const kindCounts = { steer: 0, followUp: 0, response: 0, message: 0 };
 	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;
+			const msg = parsed as { id?: unknown; status?: unknown; kind?: unknown; data?: unknown };
+			if (typeof msg.id !== "string" || !isMailboxStatus(msg.status)) return 0;
+			if (msg.status !== "acknowledged" && delivery[msg.id] !== "acknowledged") {
+				const kind = typeof msg.kind === "string" ? msg.kind : typeof (msg.data as Record<string, unknown>)?.kind === "string" ? (msg.data as Record<string, unknown>).kind as string : undefined;
+				if (kind === "steer") kindCounts.steer++;
+				else if (kind === "follow-up") kindCounts.followUp++;
+				else if (kind === "response") kindCounts.response++;
+				else kindCounts.message++;
+				return 1;
+			}
+			return 0;
 		} catch {
 			return 0;
 		}
 	}) as number[];
-	return { count: items.reduce((sum, val) => sum + val, 0), approximate: await tailApproximateAsync(filePath) };
+	const count = items.reduce((sum, val) => sum + val, 0);
+	return { count, approximate: await tailApproximateAsync(filePath), steer: kindCounts.steer, followUp: kindCounts.followUp, response: kindCounts.response, message: kindCounts.message };
 }
 
 function groupJoinsFrom(manifest: TeamRunManifest): RunUiGroupJoin[] {
@@ -436,6 +464,17 @@ async function groupJoinsFromAsync(manifest: TeamRunManifest): Promise<RunUiGrou
 	return (await readGroupJoinMailboxAsync(path.join(root, "outbox.jsonl"), delivery)).slice(-5);
 }
 
+function mergeKindCounts(a: MailboxKindCount, b: MailboxKindCount): MailboxKindCount {
+	return {
+		count: a.count + b.count,
+		approximate: a.approximate || b.approximate,
+		steer: a.steer + b.steer,
+		followUp: a.followUp + b.followUp,
+		response: a.response + b.response,
+		message: a.message + b.message,
+	};
+}
+
 function mailboxFrom(manifest: TeamRunManifest, agents: CrewAgentRecord[]): RunUiMailbox {
 	const root = path.join(manifest.stateRoot, "mailbox");
 	const delivery = readDeliveryMessages(path.join(root, "delivery.json"));
@@ -447,14 +486,17 @@ function mailboxFrom(manifest: TeamRunManifest, agents: CrewAgentRecord[]): RunU
 			if (!entry.isDirectory()) continue;
 			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 };
+			inbox = mergeKindCounts(inbox, taskInbox);
+			outbox = mergeKindCounts(outbox, taskOutbox);
 		}
 	} 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 };
+	return {
+		inboxUnread: inbox.count, outboxPending: outbox.count, needsAttention: inbox.count + attentionAgents, approximate: inbox.approximate || outbox.approximate,
+		steerUnread: inbox.steer + outbox.steer, followUpUnread: inbox.followUp + outbox.followUp, responseUnread: inbox.response + outbox.response, messageUnread: inbox.message + outbox.message,
+	};
 }
 
 async function mailboxFromAsync(manifest: TeamRunManifest, agents: CrewAgentRecord[]): Promise<RunUiMailbox> {
@@ -468,14 +510,17 @@ async function mailboxFromAsync(manifest: TeamRunManifest, agents: CrewAgentReco
 			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 };
+			inbox = mergeKindCounts(inbox, taskInbox);
+			outbox = mergeKindCounts(outbox, taskOutbox);
 		}
 	} 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 };
+	return {
+		inboxUnread: inbox.count, outboxPending: outbox.count, needsAttention: inbox.count + attentionAgents, approximate: inbox.approximate || outbox.approximate,
+		steerUnread: inbox.steer + outbox.steer, followUpUnread: inbox.followUp + outbox.followUp, responseUnread: inbox.response + outbox.response, messageUnread: inbox.message + outbox.message,
+	};
 }
 
 function cancellationReasonFromEvents(events: TeamEvent[]): string | undefined {
@@ -688,6 +733,12 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		}
 	}
 
+	const unsubscribe = runEventBus.onAny((event) => {
+		if (entries.has(event.runId)) {
+			entries.delete(event.runId);
+		}
+	});
+
 	return {
 		get(runId: string): RunUiSnapshot | undefined {
 			const entry = entries.get(runId);
@@ -719,6 +770,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			return new Map([...entries.entries()].map(([key, entry]) => [key, entry.snapshot]));
 		},
 		dispose(): void {
+			unsubscribe();
 			entries.clear();
 		},
 	};

package/src/ui/snapshot-types.ts

@@ -23,6 +23,14 @@ export interface RunUiMailbox {
 	inboxUnread: number;
 	outboxPending: number;
 	needsAttention: number;
+	/** Urgent steering messages count. Default 0. */
+	steerUnread?: number;
+	/** Follow-up / continuation messages count. Default 0. */
+	followUpUnread?: number;
+	/** Response / reply messages count. Default 0. */
+	responseUnread?: number;
+	/** Generic messages count. Default 0. */
+	messageUnread?: number;
 	/** True when counts come from bounded tail reads and older messages may be omitted. */
 	approximate?: boolean;
 }

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