pi-crew 0.9.16 → 0.9.18

package/src/ui/pi-ui-compat.ts

@@ -13,12 +13,7 @@ type WidgetOptionsWithPersist = WidgetOptions & { persist?: boolean };
 
 type CustomOptions = Parameters<ExtensionUi["custom"]>[1];
 
-type CustomFactory<T> = (
-	tui: unknown,
-	theme: unknown,
-	keybindings: unknown,
-	done: (result: T) => void,
-) => unknown;
+type CustomFactory<T> = (tui: unknown, theme: unknown, keybindings: unknown, done: (result: T) => void) => unknown;
 type GenericCustom = <T>(factory: CustomFactory<T>, options?: CustomOptions) => Promise<T>;
 
 function maybeRecord(value: unknown): Record<string, unknown> | undefined {
@@ -41,7 +36,12 @@ export function setWorkingIndicator(ctx: UiContext, options?: WorkingIndicatorOp
 	if (typeof fn === "function") fn.call(ctx.ui, options);
 }
 
-export function setExtensionWidget(ctx: UiContext, key: string, content: WidgetContent | undefined, options?: WidgetOptionsWithPersist): void {
+export function setExtensionWidget(
+	ctx: UiContext,
+	key: string,
+	content: WidgetContent | undefined,
+	options?: WidgetOptionsWithPersist,
+): void {
 	const { persist: _persist, ...widgetOptions } = options ?? {};
 	ctx.ui.setWidget(key, content as never, widgetOptions as WidgetOptions);
 }

package/src/ui/powerbar-publisher.ts

@@ -1,22 +1,34 @@
 import * as fs from "node:fs";
-import { listRecentRuns } from "../extension/run-index.ts";
 import type { CrewUiConfig } from "../config/config.ts";
+import { listRecentRuns } from "../extension/run-index.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
-import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
-import type { TeamTaskState, TeamRunManifest } from "../state/types.ts";
-import { aggregateUsage } from "../state/usage.ts";
-import { isDisplayActiveRun } from "../runtime/process-status.ts";
 import { listLiveAgents } from "../runtime/live-agent-manager.ts";
-import { logInternalError } from "../utils/internal-error.ts";
 import type { ManifestCache } from "../runtime/manifest-cache.ts";
-import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
-import { notificationBadge } from "./widget/widget-formatters.ts";
-import { RenderCoalescer } from "./render-coalescer.ts";
+import { isDisplayActiveRun } from "../runtime/process-status.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { aggregateUsage } from "../state/usage.ts";
+import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
+import { logInternalError } from "../utils/internal-error.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
 import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
+import { RenderCoalescer } from "./render-coalescer.ts";
+import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
+import { notificationBadge } from "./widget/widget-formatters.ts";
 
-type EventBus = { emit?: (event: string, data: unknown) => void; listenerCount?: (event: string) => number } | undefined;
-type StatusContext = { hasUI?: boolean; ui?: { setStatus?: (key: string, text: string | undefined) => void } } | undefined;
+type EventBus =
+	| {
+			emit?: (event: string, data: unknown) => void;
+			listenerCount?: (event: string) => number;
+	  }
+	| undefined;
+type StatusContext =
+	| {
+			hasUI?: boolean;
+			ui?: {
+				setStatus?: (key: string, text: string | undefined) => void;
+			};
+	  }
+	| undefined;
 
 const TASK_READ_TTL_MS = 200;
 
@@ -63,33 +75,59 @@ export function compactTokens(total: number): string {
 
 export function registerPiCrewPowerbarSegments(events: EventBus, config?: CrewUiConfig): void {
 	if (config?.powerbar === false) return;
-	safeEmit(events, "powerbar:register-segment", { id: "pi-crew-active", label: "pi-crew active agents" });
-	safeEmit(events, "powerbar:register-segment", { id: "pi-crew-progress", label: "pi-crew run progress" });
-	safeEmit(events, "powerbar:register-segment", { id: "pi-crew-steps", label: "pi-crew workflow steps" });
+	safeEmit(events, "powerbar:register-segment", {
+		id: "pi-crew-active",
+		label: "pi-crew active agents",
+	});
+	safeEmit(events, "powerbar:register-segment", {
+		id: "pi-crew-progress",
+		label: "pi-crew run progress",
+	});
+	safeEmit(events, "powerbar:register-segment", {
+		id: "pi-crew-steps",
+		label: "pi-crew workflow steps",
+	});
 }
 
-export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: CrewUiConfig, manifestCache?: ManifestCache, snapshotCache?: RunSnapshotCache, ctx?: StatusContext, notificationCount = 0, preloadedManifests?: TeamRunManifest[]): void {
+export function updatePiCrewPowerbar(
+	events: EventBus,
+	cwd: string,
+	config?: CrewUiConfig,
+	manifestCache?: ManifestCache,
+	snapshotCache?: RunSnapshotCache,
+	ctx?: StatusContext,
+	notificationCount = 0,
+	preloadedManifests?: TeamRunManifest[],
+): void {
 	if (config?.powerbar === false) return;
 	const useStatusFallback = !hasPowerbarConsumer(events);
 	const runs = preloadedManifests ?? (manifestCache ? manifestCache.list(20) : listRecentRuns(cwd, 20));
-	const active = runs.map((run) => {
-		let snapshot: RunUiSnapshot | undefined;
-		try {
-			// 1.2: render path is read-only. Use cache.get() only; the background
-			// preload loop in register.ts populates entries on its own cadence.
-			snapshot = snapshotCache?.get(run.runId);
-		} catch (error) {
-			logInternalError("powerbar.snapshot", error, run.runId);
-		}
-		if (snapshot) return { run: snapshot.manifest, agents: snapshot.agents, tasks: snapshot.tasks, snapshot };
-		let agents: ReturnType<typeof readCrewAgents> = [];
-		try {
-			agents = readCrewAgents(run);
-		} catch (error) {
-			logInternalError("powerbar.readCrewAgents", error, run.runId);
-		}
-		return { run, agents, tasks: readTasks(run.tasksPath), snapshot };
-	}).filter((item) => isDisplayActiveRun(item.run, item.agents));
+	const active = runs
+		.map((run) => {
+			let snapshot: RunUiSnapshot | undefined;
+			try {
+				// 1.2: render path is read-only. Use cache.get() only; the background
+				// preload loop in register.ts populates entries on its own cadence.
+				snapshot = snapshotCache?.get(run.runId);
+			} catch (error) {
+				logInternalError("powerbar.snapshot", error, run.runId);
+			}
+			if (snapshot)
+				return {
+					run: snapshot.manifest,
+					agents: snapshot.agents,
+					tasks: snapshot.tasks,
+					snapshot,
+				};
+			let agents: ReturnType<typeof readCrewAgents> = [];
+			try {
+				agents = readCrewAgents(run);
+			} catch (error) {
+				logInternalError("powerbar.readCrewAgents", error, run.runId);
+			}
+			return { run, agents, tasks: readTasks(run.tasksPath), snapshot };
+		})
+		.filter((item) => isDisplayActiveRun(item.run, item.agents));
 	if (!active.length) {
 		lastActiveKey = undefined;
 		lastProgressKey = undefined;
@@ -102,25 +140,56 @@ export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: Cre
 	const agents = active.flatMap((item) => item.agents);
 	const tasks = active.flatMap((item) => item.tasks);
 	const running = agents.filter((agent) => agent.status === "running").length;
-	const waiting = active.reduce((sum, item) => sum + (item.snapshot ? item.snapshot.progress.queued + (item.snapshot.progress.waiting ?? 0) : item.tasks.reduce((s, t) => s + (t.status === "queued" || t.status === "waiting" ? 1 : 0), 0)), 0);
-	const completed = active.reduce((sum, item) => sum + (item.snapshot?.progress.completed ?? item.tasks.reduce((s, t) => s + (t.status === "completed" ? 1 : 0), 0)), 0);
+	const waiting = active.reduce(
+		(sum, item) =>
+			sum +
+			(item.snapshot
+				? item.snapshot.progress.queued + (item.snapshot.progress.waiting ?? 0)
+				: item.tasks.reduce((s, t) => s + (t.status === "queued" || t.status === "waiting" ? 1 : 0), 0)),
+		0,
+	);
+	const completed = active.reduce(
+		(sum, item) => sum + (item.snapshot?.progress.completed ?? item.tasks.reduce((s, t) => s + (t.status === "completed" ? 1 : 0), 0)),
+		0,
+	);
 	const total = Math.max(1, active.reduce((sum, item) => sum + (item.snapshot?.progress.total ?? item.tasks.length), 0) || agents.length);
 	const usage = aggregateUsage(tasks);
-	const snapshotTokens = active.reduce((sum, item) => sum + (item.snapshot ? item.snapshot.usage.tokensIn + item.snapshot.usage.tokensOut : 0), 0);
-	const hasUsage = usage && ((usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0)) > 0;
-	const tokenTotal = hasUsage ? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0) : snapshotTokens;
-	const model = config?.showModel === false ? undefined : agents.find((agent) => agent.model)?.model?.split("/").at(-1);
+	const snapshotTokens = active.reduce(
+		(sum, item) => sum + (item.snapshot ? item.snapshot.usage.tokensIn + item.snapshot.usage.tokensOut : 0),
+		0,
+	);
+	const hasUsage = usage && (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0) > 0;
+	const tokenTotal = hasUsage
+		? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0)
+		: snapshotTokens;
+	const model =
+		config?.showModel === false
+			? undefined
+			: agents
+					.find((agent) => agent.model)
+					?.model?.split("/")
+					.at(-1);
 	const tokenText = config?.showTokens === false || !tokenTotal ? undefined : compactTokens(tokenTotal);
 	const liveRunning = listLiveAgents().filter((a) => a.status === "running").length;
 	// Always show consistent status: running count + queued count from live tasks only
 	// Avoid snapshot cache for counts to prevent UI jumping
 	const runningCount = agents.filter((a) => a.status === "running").length;
 	// Count queued/waiting tasks directly from tasks array (not snapshot) for consistency
-	const queuedCount = active.reduce((sum, item) => sum + item.tasks.reduce((s, t) => s + (t.status === "queued" || t.status === "waiting" ? 1 : 0), 0), 0);
+	const queuedCount = active.reduce(
+		(sum, item) => sum + item.tasks.reduce((s, t) => s + (t.status === "queued" || t.status === "waiting" ? 1 : 0), 0),
+		0,
+	);
 	// Format: "1 running", "2 running · 1 queued", "3 queued", "idle"
 	const runningLabel = runningCount === 1 ? "1 running" : `${runningCount} running`;
 	const queuedLabel = queuedCount === 1 ? "1 queued" : `${queuedCount} queued`;
-	const crewStatus = runningCount > 0 && queuedCount > 0 ? `${runningLabel} · ${queuedLabel}` : runningCount > 0 ? runningLabel : queuedCount > 0 ? queuedLabel : "idle";
+	const crewStatus =
+		runningCount > 0 && queuedCount > 0
+			? `${runningLabel} · ${queuedLabel}`
+			: runningCount > 0
+				? runningLabel
+				: queuedCount > 0
+					? queuedLabel
+					: "idle";
 	const liveSuffix = liveRunning > 0 ? ` (${liveRunning} live)` : "";
 	const notificationText = notificationBadge(notificationCount);
 	// Always show model + tokens as suffix when available (for activePayload consistency)
@@ -288,7 +357,16 @@ export function requestPowerbarUpdate(
 	preloadedManifests?: TeamRunManifest[],
 ): void {
 	if (config?.powerbar === false) return;
-	latestArgs = { events, cwd, config, manifestCache, snapshotCache, ctx, notificationCount, preloadedManifests };
+	latestArgs = {
+		events,
+		cwd,
+		config,
+		manifestCache,
+		snapshotCache,
+		ctx,
+		notificationCount,
+		preloadedManifests,
+	};
 	powerbarCoalescer.request();
 }
 

package/src/ui/render-diff.ts

@@ -4,7 +4,8 @@ import { asCrewTheme } from "./theme-adapter.ts";
 
 interface ParsedDiffLine {
 	prefix: string;
-	lineNum: string;	content: string;
+	lineNum: string;
+	content: string;
 }
 
 interface DiffLineContent {
@@ -108,7 +109,10 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 			while (i < lines.length) {
 				const nextParsed = parseDiffLine(lines[i] ?? "");
 				if (!nextParsed || nextParsed.prefix !== "-") break;
-				removedLines.push({ lineNum: nextParsed.lineNum, content: nextParsed.content });
+				removedLines.push({
+					lineNum: nextParsed.lineNum,
+					content: nextParsed.content,
+				});
 				i++;
 			}
 
@@ -116,7 +120,10 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 			while (i < lines.length) {
 				const nextParsed = parseDiffLine(lines[i] ?? "");
 				if (!nextParsed || nextParsed.prefix !== "+") break;
-				addedLines.push({ lineNum: nextParsed.lineNum, content: nextParsed.content });
+				addedLines.push({
+					lineNum: nextParsed.lineNum,
+					content: nextParsed.content,
+				});
 				i++;
 			}
 

package/src/ui/render-scheduler.ts

@@ -132,9 +132,13 @@ export class RenderScheduler {
 	 */
 	private invalidate(payload: unknown): void {
 		try {
-			const runId = typeof payload === "object" && payload !== null && "runId" in payload && typeof (payload as { runId: unknown }).runId === "string"
-				? (payload as { runId: string }).runId
-				: undefined;
+			const runId =
+				typeof payload === "object" &&
+				payload !== null &&
+				"runId" in payload &&
+				typeof (payload as { runId: unknown }).runId === "string"
+					? (payload as { runId: string }).runId
+					: undefined;
 			if (runId === undefined || this.invalidateCoalesceMs <= 0) {
 				this.onInvalidate?.(payload);
 				return;
@@ -210,7 +214,11 @@ export class RenderScheduler {
 		this.invalidateTimer = undefined;
 		this.invalidateBuffer.clear();
 		for (const unsub of this.unsubs.splice(0)) {
-			try { unsub(); } catch (error) { logInternalError("render-scheduler.unsubscribe", error); }
+			try {
+				unsub();
+			} catch (error) {
+				logInternalError("render-scheduler.unsubscribe", error);
+			}
 		}
 	}
 }

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

@@ -1,9 +1,13 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { MetricRegistry } from "../observability/metric-registry.ts";
 // Lazy-loaded: team-tool.ts pulls in entire runtime chain.
 import type { handleTeamTool as HandleTeamToolFn } from "../extension/team-tool.ts";
+import type { MetricRegistry } from "../observability/metric-registry.ts";
+
 let _cachedHandleTeamTool: typeof HandleTeamToolFn | undefined;
-async function handleTeamTool(params: Parameters<typeof HandleTeamToolFn>[0], ctx: Parameters<typeof HandleTeamToolFn>[1]): Promise<Awaited<ReturnType<typeof HandleTeamToolFn>>> {
+async function handleTeamTool(
+	params: Parameters<typeof HandleTeamToolFn>[0],
+	ctx: Parameters<typeof HandleTeamToolFn>[1],
+): Promise<Awaited<ReturnType<typeof HandleTeamToolFn>>> {
 	if (!_cachedHandleTeamTool) {
 		// LAZY: avoid pulling team-tool.ts (and its entire runtime chain) into module load.
 		const mod = await import("../extension/team-tool.ts");
@@ -11,12 +15,13 @@ async function handleTeamTool(params: Parameters<typeof HandleTeamToolFn>[0], ct
 	}
 	return _cachedHandleTeamTool(params, ctx);
 }
+
 import { isToolError, textFromToolResult } from "../extension/tool-result.ts";
-import { loadRunManifestById, saveRunTasks } from "../state/state-store.ts";
-import { appendEvent } from "../state/event-log.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { exportDiagnostic } from "../runtime/diagnostic-export.ts";
+import { appendEvent } from "../state/event-log.ts";
 import type { MailboxDirection, MailboxMessage } from "../state/mailbox.ts";
+import { loadRunManifestById, saveRunTasks } from "../state/state-store.ts";
 
 export interface RunActionResult {
 	ok: boolean;
@@ -25,11 +30,18 @@ export interface RunActionResult {
 }
 
 function okFromTool(result: Awaited<ReturnType<typeof handleTeamTool>>): RunActionResult {
-	return { ok: !isToolError(result), message: textFromToolResult(result), data: result };
+	return {
+		ok: !isToolError(result),
+		message: textFromToolResult(result),
+		data: result,
+	};
 }
 
 function err(error: unknown): RunActionResult {
-	return { ok: false, message: error instanceof Error ? error.message : String(error) };
+	return {
+		ok: false,
+		message: error instanceof Error ? error.message : String(error),
+	};
 }
 
 async function dispatchApi(ctx: ExtensionContext, runId: string, config: Record<string, unknown>): Promise<RunActionResult> {
@@ -44,7 +56,10 @@ function parseMailboxMessages(text: string): MailboxMessage[] {
 	try {
 		const parsed = JSON.parse(text) as unknown;
 		if (!Array.isArray(parsed)) return [];
-		return parsed.filter((item): item is MailboxMessage => Boolean(item) && typeof item === "object" && !Array.isArray(item) && typeof (item as { id?: unknown }).id === "string");
+		return parsed.filter(
+			(item): item is MailboxMessage =>
+				Boolean(item) && typeof item === "object" && !Array.isArray(item) && typeof (item as { id?: unknown }).id === "string",
+		);
 	} catch {
 		return [];
 	}
@@ -55,28 +70,56 @@ export function dispatchMailboxAck(ctx: ExtensionContext, runId: string, message
 }
 
 export function dispatchMailboxNudge(ctx: ExtensionContext, runId: string, agentId: string, message: string): Promise<RunActionResult> {
-	return dispatchApi(ctx, runId, { operation: "nudge-agent", agentId, message });
+	return dispatchApi(ctx, runId, {
+		operation: "nudge-agent",
+		agentId,
+		message,
+	});
 }
 
-export function dispatchMailboxCompose(ctx: ExtensionContext, runId: string, payload: { from: string; to: string; body: string; taskId?: string; direction: MailboxDirection }): Promise<RunActionResult> {
+export function dispatchMailboxCompose(
+	ctx: ExtensionContext,
+	runId: string,
+	payload: {
+		from: string;
+		to: string;
+		body: string;
+		taskId?: string;
+		direction: MailboxDirection;
+	},
+): Promise<RunActionResult> {
 	return dispatchApi(ctx, runId, { operation: "send-message", ...payload });
 }
 
 export async function dispatchMailboxAckAll(ctx: ExtensionContext, runId: string): Promise<RunActionResult> {
-	const listed = await dispatchApi(ctx, runId, { operation: "read-mailbox", direction: "inbox" });
+	const listed = await dispatchApi(ctx, runId, {
+		operation: "read-mailbox",
+		direction: "inbox",
+	});
 	if (!listed.ok) return listed;
 	const messages = parseMailboxMessages(listed.message).filter((message) => message.status !== "acknowledged");
 	let count = 0;
 	for (const message of messages) {
 		const acked = await dispatchMailboxAck(ctx, runId, message.id);
-		if (!acked.ok) return { ok: false, message: `Acknowledged ${count}/${messages.length}; failed ${message.id}: ${acked.message}` };
+		if (!acked.ok)
+			return {
+				ok: false,
+				message: `Acknowledged ${count}/${messages.length}; failed ${message.id}: ${acked.message}`,
+			};
 		count += 1;
 	}
-	return { ok: true, message: `Acknowledged ${count} messages.`, data: { count } };
+	return {
+		ok: true,
+		message: `Acknowledged ${count} messages.`,
+		data: { count },
+	};
 }
 
 export function dispatchHealthRecovery(ctx: ExtensionContext, runId: string): Promise<RunActionResult> {
-	return dispatchApi(ctx, runId, { operation: "foreground-interrupt", reason: "operator health recovery" });
+	return dispatchApi(ctx, runId, {
+		operation: "foreground-interrupt",
+		reason: "operator health recovery",
+	});
 }
 
 export async function dispatchKillStaleWorkers(ctx: ExtensionContext, runId: string): Promise<RunActionResult> {
@@ -92,20 +135,40 @@ export async function dispatchKillStaleWorkers(ctx: ExtensionContext, runId: str
 			const lastSeenMs = Date.parse(task.heartbeat.lastSeenAt);
 			if (!Number.isFinite(lastSeenMs) || currentMs - lastSeenMs <= staleMs) return task;
 			count += 1;
-			return { ...task, heartbeat: { ...task.heartbeat, alive: false, lastSeenAt: now } };
+			return {
+				...task,
+				heartbeat: { ...task.heartbeat, alive: false, lastSeenAt: now },
+			};
 		});
 		saveRunTasks(loaded.manifest, tasks);
-		appendEvent(loaded.manifest.eventsPath, { type: "worker.kill_stale", runId, message: `Marked ${count} stale worker heartbeat(s) dead.`, data: { count } });
-		return { ok: true, message: `Marked ${count} stale worker heartbeat(s) dead.`, data: { count } };
+		appendEvent(loaded.manifest.eventsPath, {
+			type: "worker.kill_stale",
+			runId,
+			message: `Marked ${count} stale worker heartbeat(s) dead.`,
+			data: { count },
+		});
+		return {
+			ok: true,
+			message: `Marked ${count} stale worker heartbeat(s) dead.`,
+			data: { count },
+		};
 	} catch (error) {
 		return err(error);
 	}
 }
 
-export async function dispatchDiagnosticExport(ctx: ExtensionContext, runId: string, options: { registry?: MetricRegistry } = {}): Promise<RunActionResult> {
+export async function dispatchDiagnosticExport(
+	ctx: ExtensionContext,
+	runId: string,
+	options: { registry?: MetricRegistry } = {},
+): Promise<RunActionResult> {
 	try {
 		const exported = await exportDiagnostic(ctx, runId, options);
-		return { ok: true, message: `Diagnostic exported to ${exported.path}`, data: exported.path };
+		return {
+			ok: true,
+			message: `Diagnostic exported to ${exported.path}`,
+			data: exported.path,
+		};
 	} catch (error) {
 		return err(error);
 	}