pi-crew 0.9.16 → 0.9.18

package/src/extension/registration/team-tool.ts

@@ -1,17 +1,10 @@
 import { statSync } from "node:fs";
-import type {
-	ExtensionAPI,
-	ExtensionContext,
-	ToolDefinition,
-} from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { loadConfig } from "../../config/config.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
 import type { createManifestCache } from "../../runtime/manifest-cache.ts";
-import {
-	TeamToolParams,
-	type TeamToolParamsValue,
-} from "../../schema/team-tool-schema.ts";
+import { TeamToolParams, type TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { updatePiCrewPowerbar } from "../../ui/powerbar-publisher.ts";
 import type { createRunSnapshotCache } from "../../ui/run-snapshot-cache.ts";
 import { statusIcon, teamToolRenderer } from "../../ui/tool-renderers/index.ts";
@@ -47,17 +40,11 @@ type OnUpdate = (chunk: { content: { type: "text"; text: string }[] }) => void;
 
 export interface RegisterTeamToolDeps {
 	foregroundControllers: Map<string | symbol, AbortController>;
-	startForegroundRun: (
-		ctx: ExtensionContext,
-		runner: (signal?: AbortSignal) => Promise<void>,
-		runId?: string,
-	) => void;
+	startForegroundRun: (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
 	abortForegroundRun: (runId: string) => boolean;
 	openLiveSidebar: (ctx: ExtensionContext, runId: string) => void;
 	getManifestCache: (cwd: string) => ReturnType<typeof createManifestCache>;
-	getRunSnapshotCache?: (
-		cwd: string,
-	) => ReturnType<typeof createRunSnapshotCache>;
+	getRunSnapshotCache?: (cwd: string) => ReturnType<typeof createRunSnapshotCache>;
 	getMetricRegistry?: () => MetricRegistry | undefined;
 	widgetState: CrewWidgetState;
 	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
@@ -83,10 +70,7 @@ export function resolveCwdOverride(
 	}
 }
 
-export function registerTeamTool(
-	pi: ExtensionAPI,
-	deps: RegisterTeamToolDeps,
-): void {
+export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps): void {
 	const tool: ToolDefinition = {
 		name: "team",
 		label: "Team",
@@ -112,37 +96,22 @@ export function registerTeamTool(
 			deps.foregroundControllers.set(toolKey, controller);
 			const abort = (): void => controller.abort();
 			signal?.addEventListener("abort", abort, { once: true });
-			const stopProgress = startTeamToolProgressBinder(
-				onUpdate as OnUpdate | undefined,
-			);
+			const stopProgress = startTeamToolProgressBinder(onUpdate as OnUpdate | undefined);
 			try {
 				const resolved = params as TeamToolParamsValue;
 				const cwdOverride = resolveCwdOverride(ctx.cwd, resolved.cwd);
-				if (!cwdOverride.ok)
-					return toolResult(
-						cwdOverride.error,
-						{ action: resolved.action ?? "list", status: "error" },
-						true,
-					);
+				if (!cwdOverride.ok) return toolResult(cwdOverride.error, { action: resolved.action ?? "list", status: "error" }, true);
 				const toolCtx = withSessionId({ ...ctx, cwd: cwdOverride.cwd });
 				// Phase 1.5: Auto-set session name from team run context
-				if (
-					resolved.action === "run" &&
-					resolved.goal &&
-					!pi.getSessionName()
-				) {
-					const runLabel =
-						resolved.team ?? resolved.agent ?? "direct";
-					pi.setSessionName(
-						`pi-crew: ${runLabel}/${resolved.workflow ?? "default"} — ${resolved.goal.slice(0, 60)}`,
-					);
+				if (resolved.action === "run" && resolved.goal && !pi.getSessionName()) {
+					const runLabel = resolved.team ?? resolved.agent ?? "direct";
+					pi.setSessionName(`pi-crew: ${runLabel}/${resolved.workflow ?? "default"} — ${resolved.goal.slice(0, 60)}`);
 				}
 				const output = await handleTeamTool(resolved, {
 					...toolCtx,
 					signal: controller.signal,
 					metricRegistry: deps.getMetricRegistry?.(),
-					startForegroundRun: (runner, runId) =>
-						deps.startForegroundRun(toolCtx, runner, runId),
+					startForegroundRun: (runner, runId) => deps.startForegroundRun(toolCtx, runner, runId),
 					abortForegroundRun: deps.abortForegroundRun,
 					onRunStarted: (runId) => {
 						stopProgress.attach(toolCtx.cwd, runId);
@@ -151,11 +120,7 @@ export function registerTeamTool(
 					onJsonEvent: deps.onJsonEvent,
 					getRunSnapshotCache: deps.getRunSnapshotCache,
 				});
-				if (
-					resolved.action === "run" &&
-					!output.isError &&
-					typeof output.details?.runId === "string"
-				) {
+				if (resolved.action === "run" && !output.isError && typeof output.details?.runId === "string") {
 					pi.appendEntry("crew:run-started", {
 						runId: output.details.runId,
 						team: resolved.team,
@@ -169,21 +134,8 @@ export function registerTeamTool(
 				const config = loadConfig(toolCtx.cwd).config.ui;
 				const cache = deps.getManifestCache(toolCtx.cwd);
 				const snapshotCache = deps.getRunSnapshotCache?.(toolCtx.cwd);
-				updateCrewWidget(
-					toolCtx,
-					deps.widgetState,
-					config,
-					cache,
-					snapshotCache,
-				);
-				updatePiCrewPowerbar(
-					pi.events,
-					toolCtx.cwd,
-					config,
-					cache,
-					snapshotCache,
-					toolCtx,
-				);
+				updateCrewWidget(toolCtx, deps.widgetState, config, cache, snapshotCache);
+				updatePiCrewPowerbar(pi.events, toolCtx.cwd, config, cache, snapshotCache, toolCtx);
 				return output;
 			} finally {
 				signal?.removeEventListener("abort", abort);
@@ -198,12 +150,7 @@ export function registerTeamTool(
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		renderResult(result: any, options: any, theme: any, context: any): any {
 			try {
-				return teamToolRenderer.renderResult(
-					result,
-					options,
-					theme,
-					context,
-				);
+				return teamToolRenderer.renderResult(result, options, theme, context);
 			} catch {
 				return new Text(statusIcon("completed", theme) + " done", 0, 0);
 			}
@@ -217,9 +164,7 @@ interface TeamToolProgressBinder {
 	stop: () => void;
 }
 
-function startTeamToolProgressBinder(
-	onUpdate: OnUpdate | undefined,
-): TeamToolProgressBinder {
+function startTeamToolProgressBinder(onUpdate: OnUpdate | undefined): TeamToolProgressBinder {
 	if (!onUpdate) {
 		return { attach: () => {}, stop: () => {} };
 	}
@@ -229,20 +174,14 @@ function startTeamToolProgressBinder(
 	const tick = (): void => {
 		try {
 			if (!cwd || !runId) {
-				const elapsed = Math.max(
-					0,
-					Math.round((Date.now() - startedAt) / 1000),
-				);
+				const elapsed = Math.max(0, Math.round((Date.now() - startedAt) / 1000));
 				const msg = `team status=starting elapsed=${elapsed}s`;
 				onUpdate({ content: [{ type: "text", text: msg }] });
 				return;
 			}
 			const loaded = loadRunManifestById(cwd, runId);
 			if (!loaded) {
-				const elapsed = Math.max(
-					0,
-					Math.round((Date.now() - startedAt) / 1000),
-				);
+				const elapsed = Math.max(0, Math.round((Date.now() - startedAt) / 1000));
 				const msg = `team run=${runId} elapsed=${elapsed}s (manifest pending)`;
 				onUpdate({ content: [{ type: "text", text: msg }] });
 				return;
@@ -264,11 +203,7 @@ function startTeamToolProgressBinder(
 			});
 			onUpdate({ content: [{ type: "text", text }] });
 		} catch (error) {
-			logInternalError(
-				"team-tool.progress",
-				error,
-				`runId=${runId ?? ""}`,
-			);
+			logInternalError("team-tool.progress", error, `runId=${runId ?? ""}`);
 		}
 	};
 	tick();

package/src/extension/registration/ui.ts

@@ -0,0 +1,168 @@
+/**
+ * UI installer (H3 + L2 — Phase 4 of cleanup plan).
+ *
+ * Owns the dashboard / sidebar / powerbar overlay logic that is gated on
+ * the user actually opening the dashboard (autoOpenDashboard flag) or a
+ * foreground run starting.
+ *
+ * Extracted from src/extension/register.ts. State holder is `UiState`;
+ * installer is `installLiveSidebar(ctx, runId, state, deps)`.
+ *
+ * Lazy by construction: the LiveRunSidebar class (and its transcript-viewer
+ * dependency tree) is only loaded when the user opens a sidebar overlay.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "../../config/config.ts";
+import { DEFAULT_UI } from "../../config/defaults.ts";
+import type { LiveRunSidebar as LiveRunSidebarType } from "../../ui/live-run-sidebar.ts";
+import { requestRender, setExtensionWidget, showCustom } from "../../ui/pi-ui-compat.ts";
+import {
+	clearPiCrewPowerbar,
+	registerPiCrewPowerbarSegments,
+	requestPowerbarUpdate,
+	resetPowerbarDedupState,
+	updatePiCrewPowerbar,
+} from "../../ui/powerbar-publisher.ts";
+import type { CrewWidgetState } from "../../ui/widget/index.ts";
+import { stopCrewWidget, updateCrewWidget } from "../../ui/widget/index.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+
+/** Cached live-run-sidebar constructor (lazy-loaded on first overlay open). */
+let _cachedLiveRunSidebar: typeof LiveRunSidebarType | undefined;
+async function importLiveRunSidebar(): Promise<typeof LiveRunSidebarType> {
+	if (!_cachedLiveRunSidebar) {
+		// LAZY: defer LiveRunSidebar import until the user opens a sidebar overlay.
+		const mod = await import("../../ui/live-run-sidebar.ts");
+		_cachedLiveRunSidebar = mod.LiveRunSidebar;
+	}
+	return _cachedLiveRunSidebar;
+}
+
+/** Mutable state owned by register.ts. */
+export interface UiState {
+	liveSidebarRunId: string | undefined;
+	dashboardOpened: boolean;
+}
+
+/** Dependencies passed in by register.ts. */
+export interface UiDeps {
+	pi: ExtensionAPI;
+	widgetState: CrewWidgetState;
+	getManifestCache: (cwd: string) => ReturnType<typeof import("../../runtime/manifest-cache.ts").createManifestCache>;
+	getRunSnapshotCache: (cwd: string) => ReturnType<typeof import("../../ui/run-snapshot-cache.ts").createRunSnapshotCache>;
+	isCleanedUp: () => boolean;
+	getCurrentCtx: () => ExtensionContext | undefined;
+}
+
+/**
+ * Open the live-run sidebar overlay if autoOpenDashboard is enabled. Gated by
+ * ui.autoOpenDashboard / autoOpenDashboardForForegroundRuns / placement.
+ *
+ * Returns true if the sidebar was opened (or was already open for this runId),
+ * false if gated off.
+ */
+export async function installLiveSidebar(ctx: ExtensionContext, runId: string, state: UiState, deps: UiDeps): Promise<boolean> {
+	const uiConfig = loadConfig(ctx.cwd).config.ui;
+	const autoOpen = uiConfig?.autoOpenDashboard === true;
+	const foregroundAutoOpen = uiConfig?.autoOpenDashboardForForegroundRuns ?? DEFAULT_UI.autoOpenDashboardForForegroundRuns;
+	if (!ctx.hasUI || !autoOpen || !foregroundAutoOpen || (uiConfig?.dashboardPlacement ?? DEFAULT_UI.dashboardPlacement) !== "right") {
+		return false;
+	}
+	if (state.liveSidebarRunId === runId) return true;
+	state.liveSidebarRunId = runId;
+	state.dashboardOpened = true;
+	const widgetPlacement = uiConfig?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
+	setExtensionWidget(ctx, "pi-crew", undefined, { placement: widgetPlacement });
+	setExtensionWidget(ctx, "pi-crew-active", undefined, { placement: widgetPlacement });
+	deps.widgetState.lastVisibility = "hidden";
+	deps.widgetState.lastPlacement = widgetPlacement;
+	deps.widgetState.lastKey = "pi-crew-active";
+	deps.widgetState.model = undefined;
+	const width = Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? DEFAULT_UI.dashboardWidth));
+
+	try {
+		const LiveRunSidebar = await importLiveRunSidebar();
+		if (deps.isCleanedUp() || !deps.getCurrentCtx()) return false;
+		void showCustom<undefined>(
+			ctx,
+			(_tui, theme, _keybindings, done) =>
+				new LiveRunSidebar({
+					cwd: ctx.cwd,
+					runId,
+					done,
+					theme,
+					config: uiConfig,
+					snapshotCache: deps.getRunSnapshotCache(ctx.cwd),
+				}),
+			{
+				overlay: true,
+				overlayOptions: {
+					width,
+					minWidth: 40,
+					maxHeight: "100%",
+					anchor: "top-right",
+					offsetX: 0,
+					offsetY: 0,
+					margin: { top: 0, right: 0, bottom: 0, left: 0 },
+					visible: (termWidth: number) => termWidth >= 100,
+				},
+			},
+		).finally(() => {
+			if (state.liveSidebarRunId === runId) state.liveSidebarRunId = undefined;
+			const c = deps.getCurrentCtx();
+			if (!c) return;
+			updateCrewWidget(
+				c,
+				deps.widgetState,
+				loadConfig(c.cwd).config.ui,
+				deps.getManifestCache(c.cwd),
+				deps.getRunSnapshotCache(c.cwd),
+			);
+		});
+		return true;
+	} catch (error) {
+		logInternalError("register.live-sidebar-lazy-import", error);
+		return false;
+	}
+}
+
+/** Clear the powerbar (called on session switch). */
+export function clearDashboardPowerbar(state: UiState, deps: UiDeps): void {
+	const c = deps.getCurrentCtx();
+	if (c) stopCrewWidget(c, deps.widgetState, loadConfig(c.cwd).config.ui);
+	clearPiCrewPowerbar(deps.pi.events);
+	resetPowerbarDedupState();
+	state.dashboardOpened = false;
+}
+
+/** Register powerbar segments for a session. Idempotent. */
+export function registerPowerbarSegments(deps: UiDeps, uiConfig: unknown): void {
+	registerPiCrewPowerbarSegments(deps.pi.events, uiConfig as Parameters<typeof registerPiCrewPowerbarSegments>[1]);
+}
+
+/** Push a powerbar update with current run state. */
+export function pushPowerbarUpdate(ctx: ExtensionContext, deps: UiDeps, notificationCount: number): void {
+	const config = loadConfig(ctx.cwd).config.ui;
+	requestPowerbarUpdate(
+		deps.pi.events,
+		ctx.cwd,
+		config,
+		deps.getManifestCache(ctx.cwd),
+		deps.getRunSnapshotCache(ctx.cwd),
+		ctx,
+		notificationCount,
+	);
+}
+
+/** Initial powerbar update after session_start. */
+export function primePowerbarAndWidget(ctx: ExtensionContext, deps: UiDeps, notificationCount: number): void {
+	const uiConfig = loadConfig(ctx.cwd).config.ui;
+	const cache = deps.getManifestCache(ctx.cwd);
+	updateCrewWidget(ctx, deps.widgetState, uiConfig, cache, deps.getRunSnapshotCache(ctx.cwd));
+	updatePiCrewPowerbar(deps.pi.events, ctx.cwd, uiConfig, cache, deps.getRunSnapshotCache(ctx.cwd), ctx, notificationCount);
+}
+
+/** Force-render the current context (used by sidebar open path). */
+export function requestUiRender(ctx: ExtensionContext): void {
+	requestRender(ctx);
+}

package/src/extension/registration/viewers.ts

@@ -1,12 +1,13 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { loadRunManifestById } from "../../state/state-store.ts";
-import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { loadConfig } from "../../config/config.ts";
+import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { listLiveAgents } from "../../runtime/live-agent-manager.ts";
+import { loadRunManifestById } from "../../state/state-store.ts";
 import { LiveConversationOverlay } from "../../ui/live-conversation-overlay.ts";
 import { asCrewTheme } from "../../ui/theme-adapter.ts";
 // Lazy-loaded: DurableTranscriptViewer is 658ms — only needed for /crew transcript command
 import type { DurableTranscriptViewer as DurableTranscriptViewerType } from "../../ui/transcript-viewer.ts";
+
 let _cachedViewer: typeof DurableTranscriptViewerType | undefined;
 let _viewerPromise: Promise<typeof DurableTranscriptViewerType> | undefined;
 async function getViewer(): Promise<typeof DurableTranscriptViewerType> {
@@ -20,20 +21,31 @@ async function getViewer(): Promise<typeof DurableTranscriptViewerType> {
 	return _viewerPromise;
 }
 
-export async function selectAgentTask(ctx: ExtensionCommandContext, runId: string | undefined, taskId?: string): Promise<{ runId: string; taskId?: string } | undefined> {
+export async function selectAgentTask(
+	ctx: ExtensionCommandContext,
+	runId: string | undefined,
+	taskId?: string,
+): Promise<{ runId: string; taskId?: string } | undefined> {
 	if (!runId) return undefined;
 	if (taskId) return { runId, taskId };
 	const loaded = loadRunManifestById(ctx.cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return { runId };
 	const agents = readCrewAgents(loaded.manifest);
 	if (ctx.hasUI && agents.length > 1) {
-		const choice = await ctx.ui.select("Select pi-crew agent", agents.map((agent) => `${agent.taskId} ${agent.role}→${agent.agent} [${agent.status}]`));
+		const choice = await ctx.ui.select(
+			"Select pi-crew agent",
+			agents.map((agent) => `${agent.taskId} ${agent.role}→${agent.agent} [${agent.status}]`),
+		);
 		return { runId, taskId: choice?.split(" ")[0] };
 	}
 	return { runId, taskId: agents[0]?.taskId };
 }
 
-export async function openTranscriptViewer(ctx: ExtensionCommandContext, initialRunId: string | undefined, initialTaskId?: string): Promise<boolean> {
+export async function openTranscriptViewer(
+	ctx: ExtensionCommandContext,
+	initialRunId: string | undefined,
+	initialTaskId?: string,
+): Promise<boolean> {
 	const selected = await selectAgentTask(ctx, initialRunId, initialTaskId);
 	if (!selected) return false;
 	const runId = selected.runId;
@@ -43,15 +55,29 @@ export async function openTranscriptViewer(ctx: ExtensionCommandContext, initial
 	if (!loaded) return false;
 	const uiConfig = loadConfig(ctx.cwd).config.ui;
 	const DurableTranscriptViewer = await getViewer();
-	await ctx.ui.custom<undefined>((_tui, theme, _keybindings, done) => new DurableTranscriptViewer(loaded.manifest, theme, done, taskId, { maxTailBytes: uiConfig?.transcriptTailBytes }), {
-		overlay: true,
-		overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" },
-	});
+	await ctx.ui.custom<undefined>(
+		(_tui, theme, _keybindings, done) =>
+			new DurableTranscriptViewer(loaded.manifest, theme, done, taskId, {
+				maxTailBytes: uiConfig?.transcriptTailBytes,
+			}),
+		{
+			overlay: true,
+			overlayOptions: {
+				width: "90%",
+				maxHeight: "85%",
+				anchor: "center",
+			},
+		},
+	);
 	return true;
 }
 
 /** R2: Open live conversation overlay for a running live-session agent. */
-export async function openLiveConversation(ctx: ExtensionCommandContext, initialRunId: string | undefined, initialTaskId?: string): Promise<boolean> {
+export async function openLiveConversation(
+	ctx: ExtensionCommandContext,
+	initialRunId: string | undefined,
+	initialTaskId?: string,
+): Promise<boolean> {
 	const selected = await selectAgentTask(ctx, initialRunId, initialTaskId);
 	if (!selected || !ctx.hasUI) return false;
 	const liveAgents = listLiveAgents();
@@ -59,20 +85,34 @@ export async function openLiveConversation(ctx: ExtensionCommandContext, initial
 	if (!handle) return false;
 	const theme = asCrewTheme({});
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	await ctx.ui.custom<undefined>((tui: any, _theme: any, _keybindings: any, done: (result: undefined) => void) => {
-		const columns = tui?.terminal?.columns ?? 80;
-		const rows = tui?.terminal?.rows ?? 24;
-		const overlay = new LiveConversationOverlay(handle, theme, columns, rows);
-		return {
-			render(width: number) { return overlay.render(width); },
-			handleInput(data: string) {
-				if (data === "\x1b" || data === "q") { overlay.close(); done(undefined); }
+	await ctx.ui.custom<undefined>(
+		(tui: any, _theme: any, _keybindings: any, done: (result: undefined) => void) => {
+			const columns = tui?.terminal?.columns ?? 80;
+			const rows = tui?.terminal?.rows ?? 24;
+			const overlay = new LiveConversationOverlay(handle, theme, columns, rows);
+			return {
+				render(width: number) {
+					return overlay.render(width);
+				},
+				handleInput(data: string) {
+					if (data === "\x1b" || data === "q") {
+						overlay.close();
+						done(undefined);
+					}
+				},
+				invalidate() {
+					/* overlay polls */
+				},
+			};
+		},
+		{
+			overlay: true,
+			overlayOptions: {
+				width: "90%",
+				maxHeight: "85%",
+				anchor: "center",
 			},
-			invalidate() { /* overlay polls */ },
-		};
-	}, {
-		overlay: true,
-		overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" },
-	});
+		},
+	);
 	return true;
 }

package/src/extension/result-watcher.ts

@@ -1,8 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "../utils/completion-dedupe.ts";
-import { closeWatcher, watchWithErrorHandler } from "../utils/fs-watch.ts";
 import { createFileCoalescer } from "../utils/file-coalescer.ts";
+import { closeWatcher, watchWithErrorHandler } from "../utils/fs-watch.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 
 export interface ResultWatcherEvents {
@@ -42,7 +42,11 @@ function readJson(filePath: string): unknown | undefined {
 	}
 }
 
-export function createResultWatcher(events: ResultWatcherEvents, resultsDir: string, eventNameOrOptions: string | ResultWatcherOptions = "pi-crew:run-result"): ResultWatcherHandle {
+export function createResultWatcher(
+	events: ResultWatcherEvents,
+	resultsDir: string,
+	eventNameOrOptions: string | ResultWatcherOptions = "pi-crew:run-result",
+): ResultWatcherHandle {
 	const options: ResultWatcherOptions = typeof eventNameOrOptions === "string" ? { eventName: eventNameOrOptions } : eventNameOrOptions;
 	const eventName = options.eventName ?? "pi-crew:run-result";
 	const completionTtlMs = options.completionTtlMs ?? 5 * 60_000;
@@ -61,7 +65,10 @@ export function createResultWatcher(events: ResultWatcherEvents, resultsDir: str
 			coalescer.schedule(file, RESULT_WATCHER_POLL_MS);
 			return;
 		}
-		const key = buildCompletionKey(payload && typeof payload === "object" && !Array.isArray(payload) ? payload as Record<string, unknown> : {}, `file:${file}`);
+		const key = buildCompletionKey(
+			payload && typeof payload === "object" && !Array.isArray(payload) ? (payload as Record<string, unknown>) : {},
+			`file:${file}`,
+		);
 		if (!markSeenWithTtl(seen, key, Date.now(), completionTtlMs)) {
 			events.emit(eventName, payload);
 		}
@@ -105,10 +112,14 @@ export function createResultWatcher(events: ResultWatcherEvents, resultsDir: str
 			if (!isCurrent()) return;
 			fs.mkdirSync(resultsDir, { recursive: true });
 			if (watcher) closeWatcher(watcher);
-			watcher = watch(resultsDir, (event, fileName) => {
-				if (event !== "rename" || !fileName) return;
-				coalescer.schedule(fileName.toString());
-			}, scheduleRestart);
+			watcher = watch(
+				resultsDir,
+				(event, fileName) => {
+					if (event !== "rename" || !fileName) return;
+					coalescer.schedule(fileName.toString());
+				},
+				scheduleRestart,
+			);
 			if (watcher) stopPolling();
 			watcher?.unref();
 		},

package/src/extension/run-bundle-schema.ts

@@ -1,6 +1,6 @@
 import { isTeamRunStatus, isTeamTaskStatus } from "../state/contracts.ts";
-import type { TeamRunManifest, TeamTaskState, ArtifactDescriptor } from "../state/types.ts";
 import type { TeamEvent } from "../state/event-log.ts";
+import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import type { ExportedRunBundle } from "./run-export.ts";
 
 export interface BundleValidationResult {
@@ -22,7 +22,8 @@ function validateArtifact(value: unknown, index: number, errors: string[]): valu
 	if (typeof value.path !== "string") errors.push(`manifest.artifacts[${index}].path must be a string.`);
 	if (typeof value.createdAt !== "string") errors.push(`manifest.artifacts[${index}].createdAt must be a string.`);
 	if (typeof value.producer !== "string") errors.push(`manifest.artifacts[${index}].producer must be a string.`);
-	if (value.retention !== "run" && value.retention !== "project" && value.retention !== "temporary") errors.push(`manifest.artifacts[${index}].retention is invalid.`);
+	if (value.retention !== "run" && value.retention !== "project" && value.retention !== "temporary")
+		errors.push(`manifest.artifacts[${index}].retention is invalid.`);
 	return errors.length === before;
 }
 
@@ -33,11 +34,23 @@ function validateManifest(value: unknown, errors: string[]): value is TeamRunMan
 	}
 	const before = errors.length;
 	if (value.schemaVersion !== 1) errors.push("manifest.schemaVersion must be 1.");
-	for (const field of ["runId", "team", "goal", "createdAt", "updatedAt", "cwd", "stateRoot", "artifactsRoot", "tasksPath", "eventsPath"] as const) {
+	for (const field of [
+		"runId",
+		"team",
+		"goal",
+		"createdAt",
+		"updatedAt",
+		"cwd",
+		"stateRoot",
+		"artifactsRoot",
+		"tasksPath",
+		"eventsPath",
+	] as const) {
 		if (typeof value[field] !== "string") errors.push(`manifest.${field} must be a string.`);
 	}
 	if (!isTeamRunStatus(value.status)) errors.push("manifest.status is invalid.");
-	if (value.workspaceMode !== "single" && value.workspaceMode !== "worktree") errors.push("manifest.workspaceMode must be single or worktree.");
+	if (value.workspaceMode !== "single" && value.workspaceMode !== "worktree")
+		errors.push("manifest.workspaceMode must be single or worktree.");
 	if (!Array.isArray(value.artifacts)) errors.push("manifest.artifacts must be an array.");
 	else value.artifacts.forEach((artifact, index) => validateArtifact(artifact, index, errors));
 	return errors.length === before;
@@ -79,11 +92,13 @@ export function validateRunBundle(value: unknown): BundleValidationResult {
 	else value.tasks.forEach((task, index) => validateTask(task, index, errors));
 	if (!Array.isArray(value.events)) errors.push("events must be an array.");
 	else value.events.forEach((event, index) => validateEvent(event, index, errors));
-	if (!Array.isArray(value.artifactPaths) || !value.artifactPaths.every((item) => typeof item === "string")) errors.push("artifactPaths must be an array of strings.");
+	if (!Array.isArray(value.artifactPaths) || !value.artifactPaths.every((item) => typeof item === "string"))
+		errors.push("artifactPaths must be an array of strings.");
 	return { ok: errors.length === 0, errors };
 }
 
 export function assertRunBundle(value: unknown): asserts value is ExportedRunBundle {
 	const validation = validateRunBundle(value);
-	if (!validation.ok) throw new Error(`File is not a valid pi-crew exported run bundle:\n${validation.errors.map((error) => `- ${error}`).join("\n")}`);
+	if (!validation.ok)
+		throw new Error(`File is not a valid pi-crew exported run bundle:\n${validation.errors.map((error) => `- ${error}`).join("\n")}`);
 }

package/src/extension/run-export.ts

@@ -1,10 +1,10 @@
+import * as crypto from "node:crypto";
 import * as fs from "node:fs";
-import * as path from "node:path";
 import * as os from "node:os";
-import * as crypto from "node:crypto";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import * as path from "node:path";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { readEvents, type TeamEvent } from "../state/event-log.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { redactSecrets } from "../utils/redaction.ts";
 
 /** Replace absolute paths containing home directory with ~/ */
@@ -72,13 +72,22 @@ export function exportRunBundle(manifest: TeamRunManifest, tasks: TeamTaskState[
 			`Goal: ${safeManifest.goal}`,
 			"",
 			"## Tasks",
-			...safeTasks.map((task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`),
+			...safeTasks.map(
+				(task) => `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.error ? ` - ${task.error}` : ""}`,
+			),
 			"",
 			"## Artifacts",
-			...(safeManifest.artifacts.length ? safeManifest.artifacts.map((artifact) => `- ${artifact.kind}: ${artifact.path}`) : ["- (none)"]),
+			...(safeManifest.artifacts.length
+				? safeManifest.artifacts.map((artifact) => `- ${artifact.kind}: ${artifact.path}`)
+				: ["- (none)"]),
 			"",
 			"## Recent Events",
-			...(safeEvents.slice(-20).map((event) => `- ${event.time} ${event.type}${event.taskId ? ` ${event.taskId}` : ""}${event.message ? `: ${event.message}` : ""}`)),
+			...safeEvents
+				.slice(-20)
+				.map(
+					(event) =>
+						`- ${event.time} ${event.type}${event.taskId ? ` ${event.taskId}` : ""}${event.message ? `: ${event.message}` : ""}`,
+				),
 			"",
 		].join("\n"),
 	});