pi-crew 0.9.16 → 0.9.17

package/src/extension/validate-resources.ts

@@ -25,13 +25,23 @@ export function validateResources(cwd: string): ValidationReport {
 	const issues: ValidationIssue[] = [];
 
 	for (const agent of agents) {
-		const modelValues = [agent.model, ...(agent.fallbackModels ?? [])].filter((value): value is string => typeof value === "string" && value.length > 0);
+		const modelValues = [agent.model, ...(agent.fallbackModels ?? [])].filter(
+			(value): value is string => typeof value === "string" && value.length > 0,
+		);
 		for (const model of modelValues) {
 			if (/\s/.test(model)) {
-				issues.push({ level: "warning", resource: `agent:${agent.name}`, message: `Model reference '${model}' contains whitespace.` });
+				issues.push({
+					level: "warning",
+					resource: `agent:${agent.name}`,
+					message: `Model reference '${model}' contains whitespace.`,
+				});
 			}
 			if (model.includes("/") && model.split("/").some((part) => part.trim() === "")) {
-				issues.push({ level: "warning", resource: `agent:${agent.name}`, message: `Model reference '${model}' has an empty provider/model segment.` });
+				issues.push({
+					level: "warning",
+					resource: `agent:${agent.name}`,
+					message: `Model reference '${model}' has an empty provider/model segment.`,
+				});
 			}
 		}
 	}
@@ -39,27 +49,48 @@ export function validateResources(cwd: string): ValidationReport {
 	for (const team of teams) {
 		for (const role of team.roles) {
 			if (!agentNames.has(role.agent)) {
-				issues.push({ level: "error", resource: `team:${team.name}`, message: `Role '${role.name}' references unknown agent '${role.agent}'.` });
+				issues.push({
+					level: "error",
+					resource: `team:${team.name}`,
+					message: `Role '${role.name}' references unknown agent '${role.agent}'.`,
+				});
 			}
 		}
 		if (team.defaultWorkflow && !workflowNames.has(team.defaultWorkflow)) {
-			issues.push({ level: "error", resource: `team:${team.name}`, message: `defaultWorkflow references unknown workflow '${team.defaultWorkflow}'.` });
+			issues.push({
+				level: "error",
+				resource: `team:${team.name}`,
+				message: `defaultWorkflow references unknown workflow '${team.defaultWorkflow}'.`,
+			});
 		}
 		const workflow = workflows.find((candidate) => candidate.name === team.defaultWorkflow);
 		if (workflow) {
 			for (const error of validateWorkflowForTeam(workflow, team)) {
-				issues.push({ level: "error", resource: `workflow:${workflow.name}`, message: `Team '${team.name}': ${error}` });
+				issues.push({
+					level: "error",
+					resource: `workflow:${workflow.name}`,
+					message: `Team '${team.name}': ${error}`,
+				});
 			}
 		}
 	}
 
 	for (const workflow of workflows) {
 		if (workflow.steps.length === 0) {
-			issues.push({ level: "warning", resource: `workflow:${workflow.name}`, message: "Workflow has no steps." });
+			issues.push({
+				level: "warning",
+				resource: `workflow:${workflow.name}`,
+				message: "Workflow has no steps.",
+			});
 		}
 	}
 
-	return { issues, agents: agents.length, teams: teams.length, workflows: workflows.length };
+	return {
+		issues,
+		agents: agents.length,
+		teams: teams.length,
+		workflows: workflows.length,
+	};
 }
 
 export function formatValidationReport(report: ValidationReport): string {

package/src/hooks/registry.ts

@@ -1,7 +1,7 @@
-import type { HookDefinition, HookName, HookContext, HookResult, HookExecutionReport } from "./types.ts";
 import { appendEvent } from "../state/event-log.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { runEventBus } from "../ui/run-event-bus.ts";
+import type { HookContext, HookDefinition, HookExecutionReport, HookName, HookResult } from "./types.ts";
 
 const registry = new Map<HookName, HookDefinition[]>();
 
@@ -67,7 +67,22 @@ export async function executeHook(name: HookName, ctx: HookContext): Promise<Hoo
 		return ctx.includeGlobalHooks !== false;
 	});
 	if (scopedHooks.length === 0) return { hookName: name, outcome: "allow", durationMs: 0 };
-	const POLLUTED_KEYS = new Set(["__proto__", "constructor", "prototype", "hasOwnProperty", "toString", "valueOf", "isPrototypeOf", "propertyIsEnumerable", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__"].map((k) => k.toLowerCase().normalize("NFKC")));
+	const POLLUTED_KEYS = new Set(
+		[
+			"__proto__",
+			"constructor",
+			"prototype",
+			"hasOwnProperty",
+			"toString",
+			"valueOf",
+			"isPrototypeOf",
+			"propertyIsEnumerable",
+			"__defineGetter__",
+			"__defineSetter__",
+			"__lookupGetter__",
+			"__lookupSetter__",
+		].map((k) => k.toLowerCase().normalize("NFKC")),
+	);
 	function sanitizeMergeData(data: Record<string, unknown>): Record<string, unknown> {
 		const clean: Record<string, unknown> = {};
 		for (const [k, v] of Object.entries(data)) {
@@ -75,7 +90,11 @@ export async function executeHook(name: HookName, ctx: HookContext): Promise<Hoo
 				if (v !== null && typeof v === "object") {
 					if (Array.isArray(v)) {
 						// Sanitize array elements that are objects
-						clean[k] = v.map((item) => (item !== null && typeof item === "object" && !Array.isArray(item) ? sanitizeMergeData(item as Record<string, unknown>) : item));
+						clean[k] = v.map((item) =>
+							item !== null && typeof item === "object" && !Array.isArray(item)
+								? sanitizeMergeData(item as Record<string, unknown>)
+								: item,
+						);
 					} else {
 						clean[k] = sanitizeMergeData(v as Record<string, unknown>);
 					}
@@ -108,14 +127,19 @@ export async function executeHook(name: HookName, ctx: HookContext): Promise<Hoo
 	const diagnostics: string[] = [];
 	let capturedModifications: Record<string, unknown> | undefined;
 	for (const hook of scopedHooks) {
-			try {
-				const result: HookResult = await hook.handler(sanitizeContext(ctx));
-				// SECURITY: Sanitize any direct mutations the handler may have made to ctx.
-				// This prevents hooks from injecting dangerous properties via direct ctx assignment.
-				sanitizeContext(ctx);
-				if (hook.mode === "blocking" && result.outcome === "block") {
-					return { hookName: name, outcome: "block", durationMs: Date.now() - start, reason: result.reason };
-				}
+		try {
+			const result: HookResult = await hook.handler(sanitizeContext(ctx));
+			// SECURITY: Sanitize any direct mutations the handler may have made to ctx.
+			// This prevents hooks from injecting dangerous properties via direct ctx assignment.
+			sanitizeContext(ctx);
+			if (hook.mode === "blocking" && result.outcome === "block") {
+				return {
+					hookName: name,
+					outcome: "block",
+					durationMs: Date.now() - start,
+					reason: result.reason,
+				};
+			}
 			if (result.outcome === "modify" && result.data) {
 				Object.assign(ctx, sanitizeMergeData(result.data));
 				capturedModifications = { ...result.data };
@@ -123,16 +147,32 @@ export async function executeHook(name: HookName, ctx: HookContext): Promise<Hoo
 		} catch (error) {
 			const message = sanitizeErrorMessage(error instanceof Error ? error.message : String(error));
 			if (hook.mode === "blocking") {
-				return { hookName: name, outcome: "block", durationMs: Date.now() - start, reason: `Hook error: ${message}` };
+				return {
+					hookName: name,
+					outcome: "block",
+					durationMs: Date.now() - start,
+					reason: `Hook error: ${message}`,
+				};
 			}
 			// Non-blocking hook errors are accumulated as diagnostics; continue to next hook
 			diagnostics.push(message);
-			}
+		}
 	}
 	if (diagnostics.length > 0) {
-		return { hookName: name, outcome: "diagnostic", durationMs: Date.now() - start, reason: diagnostics.join("; "), modifiedData: capturedModifications };
+		return {
+			hookName: name,
+			outcome: "diagnostic",
+			durationMs: Date.now() - start,
+			reason: diagnostics.join("; "),
+			modifiedData: capturedModifications,
+		};
 	}
-	return { hookName: name, outcome: "allow", durationMs: Date.now() - start, modifiedData: capturedModifications };
+	return {
+		hookName: name,
+		outcome: "allow",
+		durationMs: Date.now() - start,
+		modifiedData: capturedModifications,
+	};
 }
 
 export function appendHookEvent(manifest: TeamRunManifest, report: HookExecutionReport): void {
@@ -140,7 +180,16 @@ export function appendHookEvent(manifest: TeamRunManifest, report: HookExecution
 		type: "hook.executed",
 		runId: manifest.runId,
 		message: `Hook ${report.hookName} completed with outcome=${report.outcome}${report.reason ? `: ${report.reason}` : ""}`,
-		data: { hookName: report.hookName, outcome: report.outcome, durationMs: report.durationMs, reason: report.reason },
+		data: {
+			hookName: report.hookName,
+			outcome: report.outcome,
+			durationMs: report.durationMs,
+			reason: report.reason,
+		},
+	});
+	runEventBus.emit({
+		type: "effectiveness_changed",
+		runId: manifest.runId,
+		data: { hookName: report.hookName, outcome: report.outcome },
 	});
-	runEventBus.emit({ type: "effectiveness_changed", runId: manifest.runId, data: { hookName: report.hookName, outcome: report.outcome } });
 }

package/src/hooks/types.ts

@@ -66,4 +66,4 @@ export interface HookExecutionReport {
 	durationMs: number;
 	reason?: string;
 	modifiedData?: Record<string, unknown>;
-}
+}

package/src/i18n.ts

@@ -41,12 +41,14 @@ const translations: Record<string, Partial<Record<Key, string>>> = {
 		"agent.noOutput": "Sin salida.",
 		"result.requiresAgentId": "get_subagent_result requiere agent_id.",
 		"result.notFound": "Agente no encontrado: {id}",
-		"result.unrecoverable": "El subagente fue interrumpido antes de registrar su ID de ejecución duradero; no se puede recuperar tras reiniciar.",
+		"result.unrecoverable":
+			"El subagente fue interrumpido antes de registrar su ID de ejecución duradero; no se puede recuperar tras reiniciar.",
 		"result.waitAborted": "Se canceló la espera del resultado del subagente.",
 		"result.waitTimeout": "Se agotó el tiempo de espera del resultado del subagente.",
 		"result.stillRunning": "El agente sigue ejecutándose. Usa wait=true o vuelve a comprobar más tarde.",
 		"steer.noted": "Solicitud de dirección registrada para {id}.",
-		"steer.unavailable": "El backend predeterminado actual de pi-crew es child-process, así que session.steer a mitad de turno aún no está disponible.",
+		"steer.unavailable":
+			"El backend predeterminado actual de pi-crew es child-process, así que session.steer a mitad de turno aún no está disponible.",
 		"steer.cancelHint": "Usa team cancel runId={runId} si hay que interrumpir el agente.",
 	},
 	fr: {
@@ -60,12 +62,14 @@ const translations: Record<string, Partial<Record<Key, string>>> = {
 		"agent.noOutput": "Aucune sortie.",
 		"result.requiresAgentId": "get_subagent_result nécessite agent_id.",
 		"result.notFound": "Agent introuvable : {id}",
-		"result.unrecoverable": "Le sous-agent a été interrompu avant l'enregistrement de son ID d'exécution durable ; il ne peut pas être récupéré après redémarrage.",
+		"result.unrecoverable":
+			"Le sous-agent a été interrompu avant l'enregistrement de son ID d'exécution durable ; il ne peut pas être récupéré après redémarrage.",
 		"result.waitAborted": "L'attente du résultat du sous-agent a été annulée.",
 		"result.waitTimeout": "Délai d'attente du résultat du sous-agent dépassé.",
 		"result.stillRunning": "L'agent est toujours en cours d'exécution. Utilisez wait=true ou réessayez plus tard.",
 		"steer.noted": "Demande de pilotage enregistrée pour {id}.",
-		"steer.unavailable": "Le backend pi-crew par défaut actuel est child-process, donc session.steer en milieu de tour n'est pas encore disponible.",
+		"steer.unavailable":
+			"Le backend pi-crew par défaut actuel est child-process, donc session.steer en milieu de tour n'est pas encore disponible.",
 		"steer.cancelHint": "Utilisez team cancel runId={runId} si l'agent doit être interrompu.",
 	},
 	"pt-BR": {
@@ -79,12 +83,14 @@ const translations: Record<string, Partial<Record<Key, string>>> = {
 		"agent.noOutput": "Sem saída.",
 		"result.requiresAgentId": "get_subagent_result requer agent_id.",
 		"result.notFound": "Agente não encontrado: {id}",
-		"result.unrecoverable": "O subagente foi interrompido antes que seu ID de execução durável fosse registrado; ele não pode ser recuperado após reiniciar.",
+		"result.unrecoverable":
+			"O subagente foi interrompido antes que seu ID de execução durável fosse registrado; ele não pode ser recuperado após reiniciar.",
 		"result.waitAborted": "A espera pelo resultado do subagente foi abortada.",
 		"result.waitTimeout": "Tempo limite de espera pelo resultado do subagente esgotado.",
 		"result.stillRunning": "O agente ainda está em execução. Use wait=true ou verifique novamente mais tarde.",
 		"steer.noted": "Solicitação de orientação registrada para {id}.",
-		"steer.unavailable": "O backend padrão atual do pi-crew é child-process, então session.steer no meio do turno ainda não está disponível.",
+		"steer.unavailable":
+			"O backend padrão atual do pi-crew é child-process, então session.steer no meio do turno ainda não está disponível.",
 		"steer.cancelHint": "Use team cancel runId={runId} se o agente precisar ser interrompido.",
 	},
 };
@@ -163,7 +169,12 @@ export function listLocales(): string[] {
 
 export function initI18n(pi: ExtensionAPI): () => void {
 	try {
-		pi.events?.emit?.("pi-core/i18n/registerBundle", { namespace, defaultLocale: "en", fallback, translations });
+		pi.events?.emit?.("pi-core/i18n/registerBundle", {
+			namespace,
+			defaultLocale: "en",
+			fallback,
+			translations,
+		});
 	} catch {
 		// Non-critical.
 	}
@@ -173,10 +184,13 @@ export function initI18n(pi: ExtensionAPI): () => void {
 		currentLocale = raw && translations[raw] ? raw : undefined;
 	});
 	try {
-		pi.events?.emit?.("pi-core/i18n/requestApi", { namespace, onApi(api: { getLocale?: () => string | undefined }) {
-			const raw = api.getLocale?.()?.trim();
-			if (raw && translations[raw]) currentLocale = raw;
-		} });
+		pi.events?.emit?.("pi-core/i18n/requestApi", {
+			namespace,
+			onApi(api: { getLocale?: () => string | undefined }) {
+				const raw = api.getLocale?.()?.trim();
+				if (raw && translations[raw]) currentLocale = raw;
+			},
+		});
 	} catch {
 		// Non-critical.
 	}

package/src/observability/correlation.ts

@@ -25,11 +25,25 @@ export function newSpanId(runId: string, taskId = "main"): string {
 export function childCorrelation(runId: string, taskId: string): CorrelationContext {
 	const parent = getCurrentContext();
 	const spanId = newSpanId(runId, taskId);
-	return { traceId: parent?.traceId ?? spanId, parentSpanId: parent?.spanId, spanId };
+	return {
+		traceId: parent?.traceId ?? spanId,
+		parentSpanId: parent?.spanId,
+		spanId,
+	};
 }
 
-export function correlatedEvent<T extends { runId?: string; data?: Record<string, unknown> }>(event: T): T & { data: Record<string, unknown> } {
+export function correlatedEvent<T extends { runId?: string; data?: Record<string, unknown> }>(
+	event: T,
+): T & { data: Record<string, unknown> } {
 	const ctx = getCurrentContext();
 	if (!ctx) return event as T & { data: Record<string, unknown> };
-	return { ...event, data: { ...(event.data ?? {}), traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId } };
+	return {
+		...event,
+		data: {
+			...(event.data ?? {}),
+			traceId: ctx.traceId,
+			spanId: ctx.spanId,
+			parentSpanId: ctx.parentSpanId,
+		},
+	};
 }

package/src/observability/event-bus.ts

@@ -1,74 +1,69 @@
-import { logInternalError } from "../utils/internal-error.ts";
 import type { AgentProgress } from "../runtime/progress-tracker.ts";
+import { logInternalError } from "../utils/internal-error.ts";
 
-export type CrewEventType =
-  | "agent:progress"
-  | "agent:complete"
-  | "agent:error"
-  | "run:start"
-  | "run:complete";
+export type CrewEventType = "agent:progress" | "agent:complete" | "agent:error" | "run:start" | "run:complete";
 
 export interface CrewEvent {
-  type: CrewEventType;
-  runId: string;
-  agentId?: string;
-  payload?: AgentProgress | string;
-  timestamp: number;
+	type: CrewEventType;
+	runId: string;
+	agentId?: string;
+	payload?: AgentProgress | string;
+	timestamp: number;
 }
 
 type CrewEventListener = (event: CrewEvent) => void;
 
 class EventBus {
-  private listeners = new Map<CrewEventType, Set<CrewEventListener>>();
-  private static _instance?: EventBus;
+	private listeners = new Map<CrewEventType, Set<CrewEventListener>>();
+	private static _instance?: EventBus;
 
-  static getInstance(): EventBus {
-    if (!EventBus._instance) {
-      EventBus._instance = new EventBus();
-    }
-    return EventBus._instance;
-  }
+	static getInstance(): EventBus {
+		if (!EventBus._instance) {
+			EventBus._instance = new EventBus();
+		}
+		return EventBus._instance;
+	}
 
-  /**
-   * Dispose of the EventBus instance and clear all listeners.
-   * Resets the singleton so a new instance can be created.
-   */
-  dispose(): void {
-    this.listeners.clear();
-    EventBus._instance = undefined;
-  }
+	/**
+	 * Dispose of the EventBus instance and clear all listeners.
+	 * Resets the singleton so a new instance can be created.
+	 */
+	dispose(): void {
+		this.listeners.clear();
+		EventBus._instance = undefined;
+	}
 
-  emit(event: CrewEvent): void {
-    const listeners = this.listeners.get(event.type);
-    if (listeners) {
-      for (const listener of listeners) {
-        try {
-          listener(event);
-        } catch (e) {
-          // FIX (Round 15, L1): Use logInternalError for consistency with
-          // the rest of the codebase. Previously console.error may not be
-          // visible in all environments (e.g. JSON-RPC mode, redirected
-          // stderr).
-          logInternalError("event-bus.listener", e, `type=${event.type} runId=${event.runId}`);
-        }
-      }
-    }
-  }
+	emit(event: CrewEvent): void {
+		const listeners = this.listeners.get(event.type);
+		if (listeners) {
+			for (const listener of listeners) {
+				try {
+					listener(event);
+				} catch (e) {
+					// FIX (Round 15, L1): Use logInternalError for consistency with
+					// the rest of the codebase. Previously console.error may not be
+					// visible in all environments (e.g. JSON-RPC mode, redirected
+					// stderr).
+					logInternalError("event-bus.listener", e, `type=${event.type} runId=${event.runId}`);
+				}
+			}
+		}
+	}
 
-  on(type: CrewEventType, listener: CrewEventListener): () => void {
-    if (!this.listeners.has(type)) {
-      this.listeners.set(type, new Set());
-    }
-    this.listeners.get(type)!.add(listener);
+	on(type: CrewEventType, listener: CrewEventListener): () => void {
+		if (!this.listeners.has(type)) {
+			this.listeners.set(type, new Set());
+		}
+		this.listeners.get(type)!.add(listener);
 
-    return () => {
-      this.listeners.get(type)?.delete(listener);
-    };
-  }
+		return () => {
+			this.listeners.get(type)?.delete(listener);
+		};
+	}
 
-  off(type: CrewEventType, listener: CrewEventListener): void {
-    this.listeners.get(type)?.delete(listener);
-  }
+	off(type: CrewEventType, listener: CrewEventListener): void {
+		this.listeners.get(type)?.delete(listener);
+	}
 }
 
 /**

package/src/observability/event-to-metric.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { MetricRegistry } from "./metric-registry.ts";
 
 function recordValue(value: unknown): Record<string, unknown> {
-	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
 }
 
 function stringValue(value: unknown, fallback: string): string {
@@ -13,7 +13,15 @@ function numberValue(value: unknown, fallback = 0): number {
 	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 
-const CANCELLATION_REASON_LABELS = new Set(["caller_cancelled", "leader_interrupted", "provider_timeout", "worker_timeout", "tool_timeout", "shutdown", "unknown"]);
+const CANCELLATION_REASON_LABELS = new Set([
+	"caller_cancelled",
+	"leader_interrupted",
+	"provider_timeout",
+	"worker_timeout",
+	"tool_timeout",
+	"shutdown",
+	"unknown",
+]);
 
 function cancellationReasonLabel(value: unknown): string {
 	const raw = stringValue(value, "unknown");
@@ -34,34 +42,128 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 	const overflowCount = registry.counter("crew.task.overflow_phase_total", "Overflow recovery phase transitions");
 	const supervisorContactCount = registry.counter("crew.task.supervisor_contact_total", "Supervisor contact requests by reason");
 	registry.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds");
-	const runDuration = registry.histogram("crew.run.duration_ms", "Run end-to-end duration, milliseconds", [1000, 5000, 15000, 30000, 60000, 300000, 600000, 1800000]);
-	const taskDuration = registry.histogram("crew.task.duration_ms", "Task duration, milliseconds", [50, 200, 500, 1000, 5000, 30000, 120000]);
+	const runDuration = registry.histogram(
+		"crew.run.duration_ms",
+		"Run end-to-end duration, milliseconds",
+		[1000, 5000, 15000, 30000, 60000, 300000, 600000, 1800000],
+	);
+	const taskDuration = registry.histogram(
+		"crew.task.duration_ms",
+		"Task duration, milliseconds",
+		[50, 200, 500, 1000, 5000, 30000, 120000],
+	);
 	registry.histogram("crew.task.retry_count", "Retries per task", [0, 1, 2, 3, 5, 10]);
 	const tokenUsage = registry.histogram("crew.task.tokens_total", "Token usage per task", [100, 500, 2000, 10000, 50000, 200000]);
 
 	const handlers: Array<[string, (data: unknown) => void]> = [
-		["crew.run.completed", (data) => { const item = recordValue(data); runCount.inc({ status: "completed" }); runDuration.observe({ team: stringValue(item.team, "unknown") }, numberValue(item.durationMs)); }],
+		[
+			"crew.run.completed",
+			(data) => {
+				const item = recordValue(data);
+				runCount.inc({ status: "completed" });
+				runDuration.observe({ team: stringValue(item.team, "unknown") }, numberValue(item.durationMs));
+			},
+		],
 		["crew.run.failed", () => runCount.inc({ status: "failed" })],
-		["crew.run.cancelled", (data) => { const item = recordValue(data); runCount.inc({ status: "cancelled", reason: cancellationReasonLabel(item.reason) }); }],
-		["crew.task.completed", (data) => { const item = recordValue(data); taskCount.inc({ status: "completed" }); taskDuration.observe({ role: stringValue(item.role, "unknown") }, numberValue(item.durationMs)); tokenUsage.observe({ role: stringValue(item.role, "unknown") }, numberValue(item.tokens)); }],
+		[
+			"crew.run.cancelled",
+			(data) => {
+				const item = recordValue(data);
+				runCount.inc({
+					status: "cancelled",
+					reason: cancellationReasonLabel(item.reason),
+				});
+			},
+		],
+		[
+			"crew.task.completed",
+			(data) => {
+				const item = recordValue(data);
+				taskCount.inc({ status: "completed" });
+				taskDuration.observe({ role: stringValue(item.role, "unknown") }, numberValue(item.durationMs));
+				tokenUsage.observe({ role: stringValue(item.role, "unknown") }, numberValue(item.tokens));
+			},
+		],
 		["crew.task.failed", () => taskCount.inc({ status: "failed" })],
 		["crew.task.needs_attention", () => taskCount.inc({ status: "needs_attention" })],
-		["crew.task.retry_attempt", (data) => { const item = recordValue(data); taskCount.inc({ status: "retry" }); retryAttemptCount.inc({ runId: stringValue(item.runId, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
-		["crew.task.deadletter", (data) => { const item = recordValue(data); deadletterCount.inc({ reason: stringValue(item.reason, "unknown") }); }],
-		["crew.task.overflow", (data) => { const item = recordValue(data); overflowCount.inc({ phase: stringValue(item.phase, "unknown"), previous_phase: stringValue(item.previousPhase, "none") }); }],
-		["supervisor.contact", (data) => { const item = recordValue(data); supervisorContactCount.inc({ reason: stringValue(item.reason, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
-		["crew.subagent.completed", (data) => { const item = recordValue(data); subagentCount.inc({ status: stringValue(item.status, "completed") }); }],
+		[
+			"crew.task.retry_attempt",
+			(data) => {
+				const item = recordValue(data);
+				taskCount.inc({ status: "retry" });
+				retryAttemptCount.inc({
+					runId: stringValue(item.runId, "unknown"),
+					taskId: stringValue(item.taskId, "unknown"),
+				});
+			},
+		],
+		[
+			"crew.task.deadletter",
+			(data) => {
+				const item = recordValue(data);
+				deadletterCount.inc({
+					reason: stringValue(item.reason, "unknown"),
+				});
+			},
+		],
+		[
+			"crew.task.overflow",
+			(data) => {
+				const item = recordValue(data);
+				overflowCount.inc({
+					phase: stringValue(item.phase, "unknown"),
+					previous_phase: stringValue(item.previousPhase, "none"),
+				});
+			},
+		],
+		[
+			"supervisor.contact",
+			(data) => {
+				const item = recordValue(data);
+				supervisorContactCount.inc({
+					reason: stringValue(item.reason, "unknown"),
+					taskId: stringValue(item.taskId, "unknown"),
+				});
+			},
+		],
+		[
+			"crew.subagent.completed",
+			(data) => {
+				const item = recordValue(data);
+				subagentCount.inc({
+					status: stringValue(item.status, "completed"),
+				});
+			},
+		],
 		["crew.subagent.failed", () => subagentCount.inc({ status: "failed" })],
-		["crew.mailbox.message", (data) => { const item = recordValue(data); mailboxCount.inc({ direction: stringValue(item.direction, "unknown") }); }],
+		[
+			"crew.mailbox.message",
+			(data) => {
+				const item = recordValue(data);
+				mailboxCount.inc({
+					direction: stringValue(item.direction, "unknown"),
+				});
+			},
+		],
 	];
 
 	const unsubscribers: Array<() => void> = [];
 	for (const [event, handler] of handlers) {
 		const unsubscribe = events?.on?.(event, (data: unknown) => {
-			try { handler(data); } catch { /* metric handlers must never break event delivery */ }
+			try {
+				handler(data);
+			} catch {
+				/* metric handlers must never break event delivery */
+			}
 		});
 		if (typeof unsubscribe === "function") unsubscribers.push(unsubscribe);
 	}
 	let disposed = false;
-	return { dispose() { if (disposed) return; disposed = true; for (const unsubscribe of unsubscribers.splice(0)) unsubscribe(); } };
+	return {
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			for (const unsubscribe of unsubscribers.splice(0)) unsubscribe();
+		},
+	};
 }