pi-crew 0.1.34 → 0.1.36

package/src/schema/config-schema.ts

@@ -81,6 +81,32 @@ export const PiTeamsNotificationsConfigSchema = Type.Object({
 	sinkRetentionDays: Type.Optional(Type.Integer({ minimum: 1, maximum: 90 })),
 });
 
+export const PiTeamsObservabilityConfigSchema = Type.Object({
+	enabled: Type.Optional(Type.Boolean()),
+	pollIntervalMs: Type.Optional(Type.Integer({ minimum: 1000, maximum: 60000 })),
+	metricRetentionDays: Type.Optional(Type.Integer({ minimum: 1, maximum: 365 })),
+});
+
+export const PiTeamsReliabilityConfigSchema = Type.Object({
+	autoRetry: Type.Optional(Type.Boolean()),
+	retryPolicy: Type.Optional(Type.Object({
+		maxAttempts: Type.Optional(Type.Integer({ minimum: 1, maximum: 10 })),
+		backoffMs: Type.Optional(Type.Integer({ minimum: 100, maximum: 60000 })),
+		jitterRatio: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+		exponentialFactor: Type.Optional(Type.Number({ minimum: 1, maximum: 5 })),
+		retryableErrors: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+	})),
+	autoRecover: Type.Optional(Type.Boolean()),
+	deadletterThreshold: Type.Optional(Type.Integer({ minimum: 1 })),
+});
+
+export const PiTeamsOtlpConfigSchema = Type.Object({
+	enabled: Type.Optional(Type.Boolean()),
+	endpoint: Type.Optional(Type.String({ minLength: 1 })),
+	headers: Type.Optional(Type.Record(Type.String({ minLength: 1 }), Type.String())),
+	intervalMs: Type.Optional(Type.Integer({ minimum: 5000 })),
+});
+
 export const PiTeamsUiConfigSchema = Type.Object({
 	widgetPlacement: Type.Optional(Type.Union([Type.Literal("aboveEditor"), Type.Literal("belowEditor")])),
 	widgetMaxLines: Type.Optional(Type.Integer({ minimum: 1 })),
@@ -112,5 +138,8 @@ export const PiTeamsConfigSchema = Type.Object({
 	tools: Type.Optional(PiTeamsToolsConfigSchema),
 	telemetry: Type.Optional(PiTeamsTelemetryConfigSchema),
 	notifications: Type.Optional(PiTeamsNotificationsConfigSchema),
+	observability: Type.Optional(PiTeamsObservabilityConfigSchema),
+	reliability: Type.Optional(PiTeamsReliabilityConfigSchema),
+	otlp: Type.Optional(PiTeamsOtlpConfigSchema),
 	ui: Type.Optional(PiTeamsUiConfigSchema),
 });

package/src/state/event-log.ts

@@ -48,7 +48,7 @@ const MAX_EVENTS_BYTES = 50 * 1024 * 1024;
 
 const sequenceCache = new Map<string, { size: number; mtimeMs: number; seq: number }>();
 
-function sequencePath(eventsPath: string): string {
+export function sequencePath(eventsPath: string): string {
 	return `${eventsPath}.seq`;
 }
 
@@ -57,7 +57,8 @@ function parseSequence(raw: string): number | undefined {
 	return Number.isInteger(value) && value >= 0 ? value : undefined;
 }
 
-function scanSequence(eventsPath: string): number {
+export function scanSequence(eventsPath: string): number {
+	if (!fs.existsSync(eventsPath)) return 0;
 	let max = 0;
 	for (const line of fs.readFileSync(eventsPath, "utf-8").split("\n")) {
 		if (!line.trim()) continue;

package/src/state/types.ts

@@ -138,6 +138,12 @@ export interface TaskCheckpointState {
 	childPid?: number;
 }
 
+export interface TaskAttemptState {
+	startedAt: string;
+	endedAt?: string;
+	error?: string;
+}
+
 export interface TeamTaskState {
 	id: string;
 	runId: string;
@@ -166,6 +172,7 @@ export interface TeamTaskState {
 	claim?: TaskClaimState;
 	heartbeat?: WorkerHeartbeatState;
 	checkpoint?: TaskCheckpointState;
+	attempts?: TaskAttemptState[];
 	taskPacket?: TaskPacket;
 	verification?: VerificationEvidence;
 	graph?: TaskGraphNode;

package/src/ui/dashboard-panes/agents-pane.ts

@@ -1,5 +1,7 @@
 import type { RunDashboardOptions } from "../run-dashboard.ts";
+import { iconForStatus } from "../status-colors.ts";
 import type { RunUiSnapshot } from "../snapshot-types.ts";
+import { spinnerFrame } from "../spinner.ts";
 
 function tokens(agent: RunUiSnapshot["agents"][number]): string {
 	const total = (agent.usage?.input ?? 0) + (agent.usage?.output ?? agent.progress?.tokens ?? 0) + (agent.usage?.cacheRead ?? 0) + (agent.usage?.cacheWrite ?? 0);
@@ -19,7 +21,8 @@ export function renderAgentsPane(snapshot: RunUiSnapshot | undefined, options: R
 				options.showTokens !== false ? tokens(agent) : undefined,
 				options.showModel !== false ? (agent.model ? `model=${agent.model}` : undefined) : undefined,
 			].filter((part): part is string => Boolean(part));
-			return `${agent.taskId} ${agent.role}->${agent.agent} · ${parts.join(" · ")}`;
+			const icon = iconForStatus(agent.status, { runningGlyph: spinnerFrame(agent.taskId) });
+			return `${icon} ${agent.taskId} ${agent.role}->${agent.agent} · ${parts.join(" · ")}`;
 		}),
 	];
 }

package/src/ui/dashboard-panes/metrics-pane.ts

@@ -0,0 +1,34 @@
+import type { MetricRegistry } from "../../observability/metric-registry.ts";
+import type { HistogramPoint, MetricLabels, MetricPoint } from "../../observability/metrics-primitives.ts";
+import type { RunUiSnapshot } from "../snapshot-types.ts";
+
+export interface MetricsPaneOptions {
+	registry?: MetricRegistry;
+	maxCounters?: number;
+}
+
+function labelsText(labels: MetricLabels): string {
+	const entries = Object.entries(labels);
+	return entries.length ? `{${entries.map(([key, value]) => `${key}=${value}`).join(",")}}` : "";
+}
+
+function isHistogramPoint(point: MetricPoint | HistogramPoint): point is HistogramPoint {
+	return "quantiles" in point;
+}
+
+export function renderMetricsPane(_snapshot: RunUiSnapshot | undefined, opts: MetricsPaneOptions = {}): string[] {
+	if (!opts.registry) return ["Metrics pane: registry unavailable"];
+	const snapshots = opts.registry.snapshot();
+	if (!snapshots.length) return ["Metrics pane: no metrics recorded"];
+	const lines = ["Metrics pane: top metrics"];
+	for (const snapshot of snapshots.slice(0, opts.maxCounters ?? 10)) {
+		const first = snapshot.values[0];
+		if (!first) {
+			lines.push(`${snapshot.name}: empty`);
+			continue;
+		}
+		if (isHistogramPoint(first)) lines.push(`${snapshot.name}${labelsText(first.labels)} count=${first.count} p95=${Number.isFinite(first.quantiles.p95) ? Math.round(first.quantiles.p95) : "n/a"}`);
+		else lines.push(`${snapshot.name}${labelsText(first.labels)} ${first.value}`);
+	}
+	return lines;
+}

package/src/ui/heartbeat-aggregator.ts

@@ -1,4 +1,6 @@
 import type { TeamTaskState } from "../state/types.ts";
+import { classifyHeartbeat, heartbeatAgeMs } from "../runtime/heartbeat-gradient.ts";
+import type { MetricRegistry } from "../observability/metric-registry.ts";
 import type { RunUiSnapshot } from "./snapshot-types.ts";
 
 export interface HeartbeatSummary {
@@ -9,12 +11,14 @@ export interface HeartbeatSummary {
 	dead: number;
 	missing: number;
 	worstStaleMs: number;
+	gradient: { healthy: number; warn: number; stale: number; dead: number };
 }
 
 export interface HeartbeatSummaryOptions {
 	staleMs?: number;
 	deadMs?: number;
 	now?: number | Date;
+	registry?: MetricRegistry;
 }
 
 function nowMs(now: number | Date | undefined): number {
@@ -31,22 +35,28 @@ export function summarizeHeartbeats(snapshot: RunUiSnapshot, opts: HeartbeatSumm
 	const staleMs = opts.staleMs ?? 60_000;
 	const deadMs = opts.deadMs ?? 5 * 60_000;
 	const current = nowMs(opts.now);
-	const summary: HeartbeatSummary = { runId: snapshot.runId, totalTasks: snapshot.tasks.length, healthy: 0, stale: 0, dead: 0, missing: 0, worstStaleMs: 0 };
+	const summary: HeartbeatSummary = { runId: snapshot.runId, totalTasks: snapshot.tasks.length, healthy: 0, stale: 0, dead: 0, missing: 0, worstStaleMs: 0, gradient: { healthy: 0, warn: 0, stale: 0, dead: 0 } };
 	for (const task of snapshot.tasks) {
 		if (!isActiveTask(task)) continue;
 		const heartbeat = task.heartbeat;
 		if (!heartbeat) {
 			summary.missing += 1;
+			summary.gradient.dead += 1;
 			continue;
 		}
-		const age = Math.max(0, current - Date.parse(heartbeat.lastSeenAt));
+		const age = heartbeatAgeMs(heartbeat, current);
 		if (!Number.isFinite(age)) {
 			summary.missing += 1;
+			summary.gradient.dead += 1;
 			continue;
 		}
 		summary.worstStaleMs = Math.max(summary.worstStaleMs, age);
-		if (heartbeat.alive === false || age > deadMs) summary.dead += 1;
-		else if (age > staleMs) summary.stale += 1;
+		const level = classifyHeartbeat(heartbeat, { warnMs: Math.max(1, Math.floor(staleMs / 2)), staleMs, deadMs }, current);
+		summary.gradient[level] += 1;
+		opts.registry?.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds").set({ runId: snapshot.runId, taskId: task.id }, age);
+		opts.registry?.counter("crew.heartbeat.level_total", "Heartbeat classifications by level").inc({ runId: snapshot.runId, level });
+		if (level === "dead") summary.dead += 1;
+		else if (level === "stale") summary.stale += 1;
 		else summary.healthy += 1;
 	}
 	return summary;

package/src/ui/keybinding-map.ts

@@ -13,7 +13,7 @@ export const DASHBOARD_KEYS = {
 		reload: ["r"],
 		progressToggle: ["p"],
 	},
-	pane: { agents: ["1"], progress: ["2"], mailbox: ["3"], output: ["4"], health: ["5"] },
+	pane: { agents: ["1"], progress: ["2"], mailbox: ["3"], output: ["4"], health: ["5"], metrics: ["6"] },
 	navigation: { up: ["k", "\u001b[A"], down: ["j", "\u001b[B"] },
 	mailbox: { ack: ["A"], nudge: ["N"], compose: ["C"], preview: ["P"], ackAll: ["X"], openDetail: ["\r", "\n"] },
 	health: { recovery: ["R"], killStale: ["K"], diagnosticExport: ["D"] },
@@ -53,6 +53,7 @@ export type DashboardKeyAction =
 	| "pane-mailbox"
 	| "pane-output"
 	| "pane-health"
+	| "pane-metrics"
 	| "up"
 	| "down"
 	| "mailbox-detail"
@@ -61,7 +62,7 @@ export type DashboardKeyAction =
 	| "health-diagnostic-export"
 	| "notifications-dismiss";
 
-export function dashboardActionForKey(data: string, activePane?: "agents" | "progress" | "mailbox" | "output" | "health"): DashboardKeyAction | undefined {
+export function dashboardActionForKey(data: string, activePane?: "agents" | "progress" | "mailbox" | "output" | "health" | "metrics"): DashboardKeyAction | undefined {
 	if (includes(DASHBOARD_KEYS.close, data)) return "close";
 	if (activePane === "mailbox" && includes(DASHBOARD_KEYS.mailbox.openDetail, data)) return "mailbox-detail";
 	if (activePane === "health") {
@@ -86,6 +87,7 @@ export function dashboardActionForKey(data: string, activePane?: "agents" | "pro
 	if (includes(DASHBOARD_KEYS.pane.mailbox, data)) return "pane-mailbox";
 	if (includes(DASHBOARD_KEYS.pane.output, data)) return "pane-output";
 	if (includes(DASHBOARD_KEYS.pane.health, data)) return "pane-health";
+	if (includes(DASHBOARD_KEYS.pane.metrics, data)) return "pane-metrics";
 	if (includes(DASHBOARD_KEYS.navigation.up, data)) return "up";
 	if (includes(DASHBOARD_KEYS.navigation.down, data)) return "down";
 	return undefined;

package/src/ui/live-run-sidebar.ts

@@ -13,9 +13,9 @@ import type { CrewTheme } from "./theme-adapter.ts";
 import { asCrewTheme, subscribeThemeChange } from "./theme-adapter.ts";
 import { Box, Text } from "./layout-primitives.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
+import { spinnerBucket, spinnerFrame } from "./spinner.ts";
 
 const TASK_READ_TTL_MS = 200;
-const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
 function renderLines(lines: string[], width: number): string[] {
 	const box = new Box(0, 0);
@@ -75,10 +75,11 @@ export class LiveRunSidebar {
 	}
 
 	private buildSignature(manifestStatus: string, tasks: TeamTaskState[], agents: ReturnType<typeof readCrewAgents>, waitingCount: number, snapshot?: RunUiSnapshot): string {
-		if (snapshot) return `${snapshot.signature}:${waitingCount}`;
+		const animation = agents.some((agent) => agent.status === "running") ? `:spin=${spinnerBucket()}` : "";
+		if (snapshot) return `${snapshot.signature}:${waitingCount}${animation}`;
 		const taskSig = tasks.map((task) => `${task.id}:${task.status}:${task.startedAt ?? ""}:${task.finishedAt ?? ""}:${task.agentProgress?.currentTool ?? ""}:${task.agentProgress?.toolCount ?? 0}:${task.agentProgress?.tokens ?? 0}:${task.usage ? JSON.stringify(task.usage) : ""}`).join("|");
 		const agentSig = agents.map((agent) => [agent.id, agent.status, agent.startedAt, agent.completedAt ?? "", agent.progress?.currentTool ?? "", agent.progress?.toolCount ?? 0, agent.progress?.tokens ?? 0, agent.progress?.turns ?? 0, agent.progress?.lastActivityAt ?? "", agent.progress?.recentOutput.at(-1) ?? "", agent.toolUses ?? 0].join(":")).join("|");
-		return `${manifestStatus}|${agents.length}|${waitingCount}|${taskSig}|${agentSig}`;
+		return `${manifestStatus}|${agents.length}|${waitingCount}|${taskSig}|${agentSig}${animation}`;
 	}
 
 	private colorLine(line: string): string {
@@ -140,7 +141,7 @@ export class LiveRunSidebar {
 				line(`Active agents (${active.length})`, w),
 			];
 			for (const agent of active.slice(0, 8)) {
-				const status = iconForStatus(agent.status, { runningGlyph: SPINNER[0] });
+				const status = iconForStatus(agent.status, { runningGlyph: spinnerFrame(agent.taskId) });
 				const usage = agent.usage ? formatUsage(agent.usage) : agent.progress?.tokens ? `tokens=${agent.progress.tokens}` : "usage=pending";
 				lines.push(line(`${status} ${agent.taskId} ${agent.role}->${agent.agent}`, w));
 				lines.push(line(`  ${agent.routing ? `model ${agent.routing.requested ? `${agent.routing.requested} → ` : ""}${agent.routing.resolved}` : agent.model ? `model ${agent.model}` : "model pending"}`, w));

package/src/ui/run-action-dispatcher.ts

@@ -1,4 +1,5 @@
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { handleTeamTool } from "../extension/team-tool.ts";
 import { isToolError, textFromToolResult } from "../extension/tool-result.ts";
 import { loadRunManifestById, saveRunTasks } from "../state/state-store.ts";
@@ -91,9 +92,9 @@ export async function dispatchKillStaleWorkers(ctx: ExtensionContext, runId: str
 	}
 }
 
-export async function dispatchDiagnosticExport(ctx: ExtensionContext, runId: string): Promise<RunActionResult> {
+export async function dispatchDiagnosticExport(ctx: ExtensionContext, runId: string, options: { registry?: MetricRegistry } = {}): Promise<RunActionResult> {
 	try {
-		const exported = await exportDiagnostic(ctx, runId);
+		const exported = await exportDiagnostic(ctx, runId, options);
 		return { ok: true, message: `Diagnostic exported to ${exported.path}`, data: exported.path };
 	} catch (error) {
 		return err(error);

package/src/ui/run-dashboard.ts

@@ -17,8 +17,11 @@ import { renderMailboxPane } from "./dashboard-panes/mailbox-pane.ts";
 import { renderProgressPane } from "./dashboard-panes/progress-pane.ts";
 import { renderTranscriptPane } from "./dashboard-panes/transcript-pane.ts";
 import { renderHealthPane } from "./dashboard-panes/health-pane.ts";
+import { renderMetricsPane } from "./dashboard-panes/metrics-pane.ts";
 import { dashboardActionForKey } from "./keybinding-map.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
+import { spinnerBucket, spinnerFrame } from "./spinner.ts";
+import type { MetricRegistry } from "../observability/metric-registry.ts";
 
 interface DashboardComponent {
 	invalidate(): void;
@@ -33,6 +36,7 @@ export interface RunDashboardOptions {
 	showTools?: boolean;
 	snapshotCache?: RunSnapshotCache;
 	runProvider?: () => TeamRunManifest[];
+	registry?: MetricRegistry;
 }
 
 export type RunDashboardAction = "status" | "summary" | "artifacts" | "api" | "events" | "agents" | "agent-events" | "agent-output" | "agent-transcript" | "mailbox" | "reload" | "mailbox-detail" | "health-recovery" | "health-kill-stale" | "health-diagnostic-export" | "notifications-dismiss";
@@ -140,7 +144,8 @@ function agentPreviewLine(agent: CrewAgentRecord, task: TeamTaskState | undefine
 		agent.startedAt ? `age=${formatAge(agent.completedAt ?? agent.startedAt)}` : undefined,
 	].filter((part): part is string => Boolean(part));
 	const recent = agent.progress?.recentOutput?.at(-1);
-	return `Agent: ${iconForStatus(agent.status)} ${agent.taskId} ${agent.role}->${agent.agent}${stats.length ? ` · ${stats.join(" · ")}` : ""}${recent ? ` ⎿ ${recent}` : ""}`;
+	const icon = iconForStatus(agent.status, { runningGlyph: spinnerFrame(agent.taskId) });
+	return `Agent: ${icon} ${agent.taskId} ${agent.role}->${agent.agent}${stats.length ? ` · ${stats.join(" · ")}` : ""}${recent ? ` ⎿ ${recent}` : ""}`;
 }
 
 function readAgentPreview(run: TeamRunManifest, maxLines = 5, options: RunDashboardOptions = {}): string[] {
@@ -189,7 +194,7 @@ function runLabel(run: TeamRunManifest, selected: boolean, snapshotCache?: RunSn
 	const step = stale ? "orphaned queued run" : running ? `step ${running.taskId}` : queued ? `queued ${queued.taskId}` : `agents ${agents.length}`;
 	const status: RunStatus = stale ? "stale" : (run.status as RunStatus);
 	const marker = selected ? "›" : " ";
-	return `${marker} ${iconForStatus(status)} ${run.runId.slice(-8)} ${status} | ${run.team}/${run.workflow ?? "none"} | ${step} | ${run.goal}`;
+	return `${marker} ${iconForStatus(status, { runningGlyph: spinnerFrame(run.runId) })} ${run.runId.slice(-8)} ${status} | ${run.team}/${run.workflow ?? "none"} | ${step} | ${run.goal}`;
 }
 
 function groupedRuns(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache): Array<{ label: string; run?: TeamRunManifest }> {
@@ -219,7 +224,7 @@ function countByStatus(runs: TeamRunManifest[], snapshotCache?: RunSnapshotCache
 export class RunDashboard implements DashboardComponent {
 	private selected = 0;
 	private showFullProgress = false;
-	private activePane: "agents" | "progress" | "mailbox" | "output" | "health" = "agents";
+	private activePane: "agents" | "progress" | "mailbox" | "output" | "health" | "metrics" = "agents";
 	private runs: TeamRunManifest[];
 	private readonly done: (selection: RunDashboardSelection | undefined) => void;
 	private readonly theme: CrewTheme;
@@ -253,15 +258,18 @@ export class RunDashboard implements DashboardComponent {
 	}
 
 	private buildSignature(): string {
+		let hasRunning = false;
 		const statuses = this.runs.map((run) => {
 			const snapshot = snapshotFor(run, this.options.snapshotCache);
 			const displayRun = snapshot?.manifest ?? run;
 			const agents = snapshot?.agents ?? agentsFor(run, this.options.snapshotCache);
 			const stale = isLikelyOrphanedActiveRun(displayRun, agents);
 			const status: RunStatus = stale ? "stale" : (displayRun.status as RunStatus);
+			if (status === "running" || agents.some((agent) => agent.status === "running")) hasRunning = true;
 			return snapshot?.signature ?? `${displayRun.runId}:${displayRun.status}:${displayRun.updatedAt}:${status}`;
 		}).join("|");
-		return `${this.selected}:${this.showFullProgress ? 1 : 0}:${this.activePane}:${statuses}`;
+		const metricsSig = this.activePane === "metrics" ? `:metrics=${this.options.registry?.snapshot().length ?? 0}:${spinnerBucket()}` : "";
+		return `${this.selected}:${this.showFullProgress ? 1 : 0}:${this.activePane}:${statuses}${hasRunning ? `:spin=${spinnerBucket()}` : ""}${metricsSig}`;
 	}
 
 	invalidate(): void {
@@ -291,7 +299,7 @@ export class RunDashboard implements DashboardComponent {
 				border("╭", "╮"),
 				`│ ${pad(truncate(`${fg("accent", "▐")} ${this.theme.bold(this.options.placement === "right" ? "pi-crew right sidebar (anchored top-right)" : "pi-crew dashboard")}`, innerWidth - 1), innerWidth - 1)}│`,
 				`│ ${pad(truncate(`Runs: ${this.runs.length} • ${countByStatus(this.runs, this.options.snapshotCache)}`, innerWidth - 1), innerWidth - 1)}│`,
-				`│ ${pad(truncate(`↑/↓ select • 1 agents 2 progress 3 mailbox 4 output 5 health • s/u/a/i actions • R/K/D health • H hush`, innerWidth - 1), innerWidth - 1)}│`,
+				`│ ${pad(truncate(`↑/↓ select • 1 agents 2 progress 3 mailbox 4 output 5 health 6 metrics • s/u/a/i actions • R/K/D health • H hush`, innerWidth - 1), innerWidth - 1)}│`,
 				border("├", "┤"),
 			];
 			if (this.runs.length === 0) {
@@ -336,7 +344,9 @@ export class RunDashboard implements DashboardComponent {
 									? renderMailboxPane(selectedSnapshot)
 									: this.activePane === "health"
 										? renderHealthPane(selectedSnapshot, { isForeground: selectedDisplayRun.async ? false : true })
-										: renderTranscriptPane(selectedSnapshot)
+										: this.activePane === "metrics"
+											? renderMetricsPane(selectedSnapshot, { registry: this.options.registry })
+											: renderTranscriptPane(selectedSnapshot)
 						: [
 							...readAgentPreview(selectedDisplayRun, this.showFullProgress ? 20 : 8, this.options),
 							...readProgressPreview(selectedDisplayRun, this.showFullProgress ? 20 : 5),
@@ -408,6 +418,7 @@ export class RunDashboard implements DashboardComponent {
 		else if (action === "pane-mailbox") this.activePane = "mailbox";
 		else if (action === "pane-output") this.activePane = "output";
 		else if (action === "pane-health") this.activePane = "health";
+		else if (action === "pane-metrics") this.activePane = "metrics";
 		else if (action === "up") this.selected = Math.max(0, this.selected - 1);
 		else if (action === "down") {
 			const selectableCount = groupedRuns(this.runs, this.options.snapshotCache).filter((row) => row.run).length;

package/src/ui/spinner.ts

@@ -0,0 +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];
+}