pi-crew 0.9.16 → 0.9.18

package/src/runtime/group-join.ts

@@ -54,7 +54,9 @@ export function deliverGroupJoin(input: {
 }): CrewGroupJoinDelivery | undefined {
 	if (!shouldGroupJoin(input.mode, input.batch)) return undefined;
 	const taskIds = input.batch.map((task) => task.id);
-	const latest = taskIds.map((id) => input.allTasks.find((task) => task.id === id)).filter((task): task is TeamTaskState => Boolean(task));
+	const latest = taskIds
+		.map((id) => input.allTasks.find((task) => task.id === id))
+		.filter((task): task is TeamTaskState => Boolean(task));
 	const completed = statusList(latest, "completed");
 	const failed = statusList(latest, "failed");
 	const skipped = statusList(latest, "skipped");
@@ -64,8 +66,22 @@ export function deliverGroupJoin(input: {
 	const summary = aggregateTaskOutputs(latest, input.manifest);
 	const requestId = requestIdFor(input.manifest.runId, batchId, partial);
 	const existingMailbox = findMailboxMessageByRequestId(input.manifest, requestId);
-	const existingStatus = existingMailbox ? readDeliveryState(input.manifest).messages[existingMailbox.id] ?? existingMailbox.status : undefined;
-	const delivery: CrewGroupJoinDelivery = { batchId, mode: input.mode, partial, taskIds, completed, failed, skipped, remaining, requestId, ackRequired: true, ackStatus: existingStatus === "acknowledged" ? "acknowledged" : "pending" };
+	const existingStatus = existingMailbox
+		? (readDeliveryState(input.manifest).messages[existingMailbox.id] ?? existingMailbox.status)
+		: undefined;
+	const delivery: CrewGroupJoinDelivery = {
+		batchId,
+		mode: input.mode,
+		partial,
+		taskIds,
+		completed,
+		failed,
+		skipped,
+		remaining,
+		requestId,
+		ackRequired: true,
+		ackStatus: existingStatus === "acknowledged" ? "acknowledged" : "pending",
+	};
 	const content = `${JSON.stringify({ ...delivery, createdAt: new Date().toISOString() }, null, 2)}\n`;
 	const artifact = writeArtifact(input.manifest.artifactsRoot, {
 		kind: "metadata",
@@ -73,35 +89,55 @@ export function deliverGroupJoin(input: {
 		producer: "group-join",
 		content,
 	});
-	const mailbox = existingMailbox ?? appendMailboxMessage(input.manifest, {
-		direction: "outbox",
-		from: "group-join",
-		to: "leader",
-		body: [
-			`Group join ${partial ? "partial" : "completed"}: ${taskIds.join(", ")}`,
-			`Request: ${requestId}`,
-			`Completed: ${completed.join(", ") || "none"}`,
-			`Failed: ${failed.join(", ") || "none"}`,
-			`Skipped: ${skipped.join(", ") || "none"}`,
-			`Remaining: ${remaining.join(", ") || "none"}`,
-			"",
-			summary,
-		].join("\n"),
-		status: "delivered",
-		data: { kind: "group_join", requestId, batchId, partial, ackRequired: true, taskIds, completed, failed, skipped, remaining },
-	});
+	const mailbox =
+		existingMailbox ??
+		appendMailboxMessage(input.manifest, {
+			direction: "outbox",
+			from: "group-join",
+			to: "leader",
+			body: [
+				`Group join ${partial ? "partial" : "completed"}: ${taskIds.join(", ")}`,
+				`Request: ${requestId}`,
+				`Completed: ${completed.join(", ") || "none"}`,
+				`Failed: ${failed.join(", ") || "none"}`,
+				`Skipped: ${skipped.join(", ") || "none"}`,
+				`Remaining: ${remaining.join(", ") || "none"}`,
+				"",
+				summary,
+			].join("\n"),
+			status: "delivered",
+			data: {
+				kind: "group_join",
+				requestId,
+				batchId,
+				partial,
+				ackRequired: true,
+				taskIds,
+				completed,
+				failed,
+				skipped,
+				remaining,
+			},
+		});
 	appendEvent(input.manifest.eventsPath, {
 		type: partial ? "agent.group_join.partial" : "agent.group_join.completed",
 		runId: input.manifest.runId,
 		message: `Group join ${partial ? "partial" : "completed"} for ${taskIds.length} task(s).`,
-		data: { ...delivery, artifactPath: artifact.path, messageId: mailbox.id, fallback: "mailbox-delivered", reused: Boolean(existingMailbox) },
-	});
-	if (existingMailbox) appendEvent(input.manifest.eventsPath, {
-		type: "agent.group_join.delivery_reused",
-		runId: input.manifest.runId,
-		message: `Reused group join mailbox delivery for ${taskIds.length} task(s).`,
-		data: { requestId, messageId: mailbox.id, batchId, partial },
+		data: {
+			...delivery,
+			artifactPath: artifact.path,
+			messageId: mailbox.id,
+			fallback: "mailbox-delivered",
+			reused: Boolean(existingMailbox),
+		},
 	});
+	if (existingMailbox)
+		appendEvent(input.manifest.eventsPath, {
+			type: "agent.group_join.delivery_reused",
+			runId: input.manifest.runId,
+			message: `Reused group join mailbox delivery for ${taskIds.length} task(s).`,
+			data: { requestId, messageId: mailbox.id, batchId, partial },
+		});
 	return { ...delivery, artifact, messageId: mailbox.id };
 }
 
@@ -129,10 +165,7 @@ export class GroupJoinManager {
 	private deliverCb: DeliveryCallback;
 	private groupTimeout: number;
 
-	constructor(
-		deliverCb: DeliveryCallback,
-		groupTimeout = DEFAULT_TIMEOUT,
-	) {
+	constructor(deliverCb: DeliveryCallback, groupTimeout = DEFAULT_TIMEOUT) {
 		this.deliverCb = deliverCb;
 		this.groupTimeout = groupTimeout;
 	}

package/src/runtime/handoff-manager.ts

@@ -8,18 +8,18 @@ const MAX_PENDING_HANDOFFS = 1000; // Prevent unbounded growth
  * Type guard for HandoffSummary structure validation.
  */
 export function isValidHandoffSummary(value: unknown): value is HandoffSummary {
-	if (!value || typeof value !== 'object') {
+	if (!value || typeof value !== "object") {
 		return false;
 	}
 	const obj = value as Record<string, unknown>;
 
 	// Check required fields
-	if (typeof obj.taskId !== 'string' || !obj.taskId) return false;
-	if (typeof obj.runId !== 'string' || !obj.runId) return false;
-	if (typeof obj.timestamp !== 'number') return false;
-	if (typeof obj.task !== 'string' || !obj.task) return false;
-	if (typeof obj.outcome !== 'string') return false;
-	if (!['success', 'failure', 'partial'].includes(obj.outcome)) return false;
+	if (typeof obj.taskId !== "string" || !obj.taskId) return false;
+	if (typeof obj.runId !== "string" || !obj.runId) return false;
+	if (typeof obj.timestamp !== "number") return false;
+	if (typeof obj.task !== "string" || !obj.task) return false;
+	if (typeof obj.outcome !== "string") return false;
+	if (!["success", "failure", "partial"].includes(obj.outcome)) return false;
 
 	// Check arrays
 	if (!Array.isArray(obj.filesCreated)) return false;
@@ -30,27 +30,27 @@ export function isValidHandoffSummary(value: unknown): value is HandoffSummary {
 	if (!Array.isArray(obj.nextSteps)) return false;
 
 	// Check metrics object
-	if (!obj.metrics || typeof obj.metrics !== 'object') return false;
+	if (!obj.metrics || typeof obj.metrics !== "object") return false;
 	const metrics = obj.metrics as Record<string, unknown>;
-	if (typeof metrics.tokensUsed !== 'number') return false;
-	if (typeof metrics.duration !== 'number') return false;
-	if (typeof metrics.iterations !== 'number') return false;
+	if (typeof metrics.tokensUsed !== "number") return false;
+	if (typeof metrics.duration !== "number") return false;
+	if (typeof metrics.iterations !== "number") return false;
 	if (!Array.isArray(metrics.toolsUsed)) return false;
 
 	// Check contextSnapshot
-	if (typeof obj.contextSnapshot !== 'string') return false;
+	if (typeof obj.contextSnapshot !== "string") return false;
 
 	return true;
 }
 
 /**
  * HandoffManager - Generates structured summaries for agent handoffs.
- * 
+ *
  * Based on pi-boomerang's session_before_tree hook pattern:
  * - Detects task completion via agent_end hook
  * - Generates structured summaries with token metrics, artifacts, decisions
  * - Optionally collapses context to reduce token usage
- * 
+ *
  * @see docs/pi-boomerang-integration-plan.md
  */
 
@@ -172,7 +172,7 @@ export interface SummarizeDecision {
 /**
  * HandoffManager generates structured summaries when agents complete tasks,
  * enabling efficient context passing to subsequent agents.
- * 
+ *
  * H1: Includes memory management to prevent unbounded growth of pendingHandoffs Map.
  */
 export class HandoffManager {
@@ -247,8 +247,7 @@ export class HandoffManager {
 		// Also enforce max handoffs limit
 		if (this.pendingHandoffs.size > MAX_PENDING_HANDOFFS) {
 			// Remove oldest entries
-			const sortedEntries = [...this.handoffTimestamps.entries()]
-				.sort((a, b) => a[1] - b[1]);
+			const sortedEntries = [...this.handoffTimestamps.entries()].sort((a, b) => a[1] - b[1]);
 			const removeCount = sortedEntries.length - MAX_PENDING_HANDOFFS;
 			for (let i = 0; i < removeCount; i++) {
 				const sessionId = sortedEntries[i][0];
@@ -261,7 +260,7 @@ export class HandoffManager {
 	/**
 	 * Hook: agent_end
 	 * Called when agent completes a task.
-	 * 
+	 *
 	 * @param packet - The task packet
 	 * @param result - The task result
 	 */
@@ -294,7 +293,10 @@ export class HandoffManager {
 		}
 
 		// Emit handoff event
-		this.options.eventEmitter?.emit("handoff:generated", { packet, summary });
+		this.options.eventEmitter?.emit("handoff:generated", {
+			packet,
+			summary,
+		});
 
 		// Optionally collapse context
 		if (packet.collapseContext) {
@@ -308,7 +310,7 @@ export class HandoffManager {
 	 * Hook: session_before_tree
 	 * Called before navigating to tree view.
 	 * Injects pending handoff summaries into the tree.
-	 * 
+	 *
 	 * @param sessionId - The session ID
 	 * @param targetId - The target tree node ID
 	 */
@@ -335,19 +337,19 @@ export class HandoffManager {
 	 */
 	shouldSummarize(packet: TaskPacket, result: TaskResult): SummarizeDecision {
 		// H7: Validate packet structure
-		if (!packet || typeof packet.taskId !== 'string' || !packet.taskId) {
+		if (!packet || typeof packet.taskId !== "string" || !packet.taskId) {
 			return {
 				shouldSummarize: false,
-				reason: 'Invalid task packet structure',
+				reason: "Invalid task packet structure",
 				tokenCount: 0,
 			};
 		}
 
 		// H7: Validate result structure
-		if (!result || typeof result.outcome !== 'string') {
+		if (!result || typeof result.outcome !== "string") {
 			return {
 				shouldSummarize: false,
-				reason: 'Invalid task result structure',
+				reason: "Invalid task result structure",
 				tokenCount: 0,
 			};
 		}
@@ -384,8 +386,7 @@ export class HandoffManager {
 		}
 
 		// 4. Task has significant artifacts or decisions
-		const hasArtifacts = (result.filesCreated?.length ?? 0) > 0 ||
-			(result.filesModified?.length ?? 0) > 0;
+		const hasArtifacts = (result.filesCreated?.length ?? 0) > 0 || (result.filesModified?.length ?? 0) > 0;
 		const hasDecisions = (result.decisions?.length ?? 0) > 0;
 
 		if (hasArtifacts || hasDecisions) {
@@ -419,11 +420,7 @@ export class HandoffManager {
 		const artifacts = this.extractArtifacts(result);
 		// Use extractDecisionsFromResult to handle empty array and generate defaults
 		const decisions = this.extractDecisionsFromResult(result);
-		const contextSnapshot = await this.generateContextSnapshot(
-			packet.runId,
-			packet.taskId,
-			result
-		);
+		const contextSnapshot = await this.generateContextSnapshot(packet.runId, packet.taskId, result);
 
 		return {
 			taskId: packet.taskId,
@@ -531,11 +528,13 @@ export class HandoffManager {
 
 		// Generate a default decision for failure outcomes
 		if (result.outcome === "failure") {
-			return [{
-				rationale: "Task failed",
-				outcome: result.error ?? "Unknown error",
-				alternativesConsidered: [],
-			}];
+			return [
+				{
+					rationale: "Task failed",
+					outcome: result.error ?? "Unknown error",
+					alternativesConsidered: [],
+				},
+			];
 		}
 
 		return [];
@@ -544,11 +543,7 @@ export class HandoffManager {
 	/**
 	 * Generate context snapshot for handoff.
 	 */
-	private async generateContextSnapshot(
-		runId: string,
-		taskId: string,
-		result: TaskResult
-	): Promise<string> {
+	private async generateContextSnapshot(runId: string, taskId: string, result: TaskResult): Promise<string> {
 		const parts: string[] = [];
 
 		parts.push(`Task: ${taskId}`);
@@ -602,4 +597,4 @@ export class HandoffManager {
  */
 export function createHandoffManager(options?: HandoffManagerOptions): HandoffManager {
 	return new HandoffManager(options);
-}
+}

package/src/runtime/heartbeat-gradient.ts

@@ -8,7 +8,11 @@ export interface GradientThresholds {
 	deadMs: number;
 }
 
-export const DEFAULT_GRADIENT_THRESHOLDS: GradientThresholds = { warnMs: 30_000, staleMs: 60_000, deadMs: 300_000 };
+export const DEFAULT_GRADIENT_THRESHOLDS: GradientThresholds = {
+	warnMs: 30_000,
+	staleMs: 60_000,
+	deadMs: 300_000,
+};
 
 export function heartbeatAgeMs(heartbeat: WorkerHeartbeatState | undefined, now = Date.now()): number {
 	if (!heartbeat) return Number.POSITIVE_INFINITY;
@@ -16,7 +20,11 @@ export function heartbeatAgeMs(heartbeat: WorkerHeartbeatState | undefined, now
 	return Number.isFinite(lastSeen) ? Math.max(0, now - lastSeen) : Number.POSITIVE_INFINITY;
 }
 
-export function classifyHeartbeat(heartbeat: WorkerHeartbeatState | undefined, thresholds: GradientThresholds = DEFAULT_GRADIENT_THRESHOLDS, now = Date.now()): HeartbeatLevel {
+export function classifyHeartbeat(
+	heartbeat: WorkerHeartbeatState | undefined,
+	thresholds: GradientThresholds = DEFAULT_GRADIENT_THRESHOLDS,
+	now = Date.now(),
+): HeartbeatLevel {
 	if (!heartbeat) return "dead";
 	if (heartbeat.alive === false) return "dead";
 	const elapsed = heartbeatAgeMs(heartbeat, now);

package/src/runtime/heartbeat-watcher.ts

@@ -5,8 +5,8 @@ import { appendEvent } from "../state/event-log.ts";
 import { loadRunManifestById } from "../state/state-store.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { logInternalError } from "../utils/internal-error.ts";
+import { DEFAULT_GRADIENT_THRESHOLDS, type GradientThresholds, type HeartbeatLevel, heartbeatAgeMs } from "./heartbeat-gradient.ts";
 import type { ManifestCache } from "./manifest-cache.ts";
-import { DEFAULT_GRADIENT_THRESHOLDS, heartbeatAgeMs, type GradientThresholds, type HeartbeatLevel } from "./heartbeat-gradient.ts";
 
 export interface HeartbeatWatcherRouter {
 	enqueue(notification: NotificationDescriptor): boolean;
@@ -126,18 +126,44 @@ export class HeartbeatWatcher {
 						// Process is dead
 					}
 				}
-				let level: HeartbeatLevel = elapsed > thresholds.deadMs ? "dead" : elapsed > thresholds.staleMs ? "stale" : elapsed > thresholds.warnMs ? "warn" : "healthy";
+				let level: HeartbeatLevel =
+					elapsed > thresholds.deadMs
+						? "dead"
+						: elapsed > thresholds.staleMs
+							? "stale"
+							: elapsed > thresholds.warnMs
+								? "warn"
+								: "healthy";
 				if (level === "dead" && isProcessAlive) {
 					level = "stale";
 				}
-				this.opts.registry.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds").set({ runId: run.runId, taskId: task.id }, Number.isFinite(elapsed) ? elapsed : thresholds.deadMs);
-				this.opts.registry.counter("crew.heartbeat.level_total", "Heartbeat classifications by level").inc({ runId: run.runId, level });
+				this.opts.registry
+					.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds")
+					.set({ runId: run.runId, taskId: task.id }, Number.isFinite(elapsed) ? elapsed : thresholds.deadMs);
+				this.opts.registry
+					.counter("crew.heartbeat.level_total", "Heartbeat classifications by level")
+					.inc({ runId: run.runId, level });
 				const previous = this.lastLevel.get(key);
 				this.lastLevel.set(key, level);
 				if (level === "dead" && previous !== "dead") {
 					this.opts.registry.counter("crew.heartbeat.dead_total", "Dead heartbeat detections").inc({ runId: run.runId });
-					appendEvent(loaded.manifest.eventsPath, { type: "crew.task.heartbeat_dead", runId: run.runId, taskId: task.id, message: `Task ${task.id} heartbeat dead.`, data: { elapsedMs: Number.isFinite(elapsed) ? elapsed : undefined } });
-					this.opts.router.enqueue({ id: `dead_${run.runId}_${task.id}`, severity: "warning", source: "heartbeat-watcher", runId: run.runId, title: `Task ${task.id} heartbeat dead`, body: "Background watcher detected a stuck worker." });
+					appendEvent(loaded.manifest.eventsPath, {
+						type: "crew.task.heartbeat_dead",
+						runId: run.runId,
+						taskId: task.id,
+						message: `Task ${task.id} heartbeat dead.`,
+						data: {
+							elapsedMs: Number.isFinite(elapsed) ? elapsed : undefined,
+						},
+					});
+					this.opts.router.enqueue({
+						id: `dead_${run.runId}_${task.id}`,
+						severity: "warning",
+						source: "heartbeat-watcher",
+						runId: run.runId,
+						title: `Task ${task.id} heartbeat dead`,
+						body: "Background watcher detected a stuck worker.",
+					});
 					this.opts.onDead?.(run.runId, task.id, Number.isFinite(elapsed) ? elapsed : thresholds.deadMs);
 				}
 				if (level === "dead") {

package/src/runtime/hidden-handoff.ts

@@ -1,16 +1,16 @@
 /**
  * HiddenHandoffService - Sends hidden boomerang-handoff messages to parent agents.
- * 
+ *
  * Based on pi-boomerang's triggerHiddenOrchestratorHandoff() pattern:
  * - Sends customType: "boomerang-handoff" messages
  * - Full handoff details in hidden message to parent
  * - Orchestrator immediately reads summary
- * 
+ *
  * @see docs/pi-boomerang-integration-plan.md
  */
 
-import type { HandoffSummary } from "./handoff-manager.ts";
 import { logInternalError } from "../utils/internal-error.ts";
+import type { HandoffSummary } from "./handoff-manager.ts";
 
 /**
  * Type of hidden handoff message.
@@ -161,21 +161,18 @@ export class HiddenHandoffService {
 
 	/**
 	 * Send a hidden handoff to the parent agent or specified recipient.
-	 * 
+	 *
 	 * @param summary - The handoff summary to send
 	 * @param options - Send options
 	 */
-	sendHandoff(
-		summary: HandoffSummary,
-		options: SendHandoffOptions = {},
-	): void {
+	sendHandoff(summary: HandoffSummary, options: SendHandoffOptions = {}): void {
 		if (!this.enabled) {
 			return;
 		}
 
 		const priority = options.priority ?? this.inferPriority(summary);
 		const content = this.buildContent(summary);
-		let recipient = options.to ?? this.getParentAgentId();
+		const recipient = options.to ?? this.getParentAgentId();
 
 		if (!recipient) {
 			// No parent to send to, but we still emit the event
@@ -233,10 +230,7 @@ export class HiddenHandoffService {
 	/**
 	 * Send a hidden handoff immediately (fire and forget).
 	 */
-	sendHandoffAsync(
-		summary: HandoffSummary,
-		options?: SendHandoffOptions,
-	): void {
+	sendHandoffAsync(summary: HandoffSummary, options?: SendHandoffOptions): void {
 		// Fire and forget - no await
 		try {
 			this.sendHandoff(summary, options);
@@ -289,10 +283,7 @@ export class HiddenHandoffService {
 	 * Build summary text from summary.
 	 */
 	private buildSummaryText(summary: HandoffSummary): string {
-		const parts: string[] = [
-			`Completed: ${summary.task}`,
-			`Outcome: ${summary.outcome}`,
-		];
+		const parts: string[] = [`Completed: ${summary.task}`, `Outcome: ${summary.outcome}`];
 
 		if (summary.filesCreated.length > 0) {
 			parts.push(`Files created: ${summary.filesCreated.join(", ")}`);
@@ -310,10 +301,7 @@ export class HiddenHandoffService {
 			parts.push(`Next steps: ${summary.nextSteps.join("; ")}`);
 		}
 
-		parts.push(
-			`Tokens: ${summary.metrics.tokensUsed}`,
-			`Duration: ${Math.round(summary.metrics.duration / 1000)}s`,
-		);
+		parts.push(`Tokens: ${summary.metrics.tokensUsed}`, `Duration: ${Math.round(summary.metrics.duration / 1000)}s`);
 
 		return parts.join("\n");
 	}
@@ -361,9 +349,7 @@ export class HiddenHandoffService {
 		const timestamps = this.sendTimestamps.get(recipient) ?? [];
 
 		// Filter out old timestamps outside the window
-		const recentTimestamps = timestamps.filter(
-			(t) => now - t < this.RATE_LIMIT_WINDOW_MS,
-		);
+		const recentTimestamps = timestamps.filter((t) => now - t < this.RATE_LIMIT_WINDOW_MS);
 
 		// HIGH-11: If no recent timestamps, remove the empty key to prevent unbounded growth
 		if (recentTimestamps.length === 0) {
@@ -384,9 +370,7 @@ export class HiddenHandoffService {
 		timestamps.push(now);
 
 		// MEDIUM-14: Use RATE_LIMIT_WINDOW_MS consistently for both filter and record
-		const recentTimestamps = timestamps.filter(
-			(t) => now - t < this.RATE_LIMIT_WINDOW_MS,
-		);
+		const recentTimestamps = timestamps.filter((t) => now - t < this.RATE_LIMIT_WINDOW_MS);
 
 		this.sendTimestamps.set(recipient, recentTimestamps);
 	}
@@ -418,8 +402,6 @@ export interface SendHandoffOptions {
 /**
  * Create a HiddenHandoffService with default options.
  */
-export function createHiddenHandoffService(
-	options?: HiddenHandoffServiceOptions,
-): HiddenHandoffService {
+export function createHiddenHandoffService(options?: HiddenHandoffServiceOptions): HiddenHandoffService {
 	return new HiddenHandoffService(options);
-}
+}

package/src/runtime/important-line-classifier.ts

@@ -107,7 +107,12 @@ export function splitWithImportantLines(value: string, maxChars: number, opts: S
 	const tail = value.slice(value.length - tailLen);
 
 	if (opts.preserveImportant === false) {
-		return { head, tail, importantLines: [], baseDropped: value.length - maxChars };
+		return {
+			head,
+			tail,
+			importantLines: [],
+			baseDropped: value.length - maxChars,
+		};
 	}
 
 	const slackFactor = opts.slackFactor ?? 0.15;
@@ -126,5 +131,10 @@ export function splitWithImportantLines(value: string, maxChars: number, opts: S
 		used += addLen;
 	}
 
-	return { head, tail, importantLines: chosen, baseDropped: value.length - maxChars };
+	return {
+		head,
+		tail,
+		importantLines: chosen,
+		baseDropped: value.length - maxChars,
+	};
 }

package/src/runtime/iteration-hooks.ts

@@ -8,9 +8,9 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
-import { HeadSnapStage } from "./compact-stages/index.ts";
-import { resolveShellForScript } from "../utils/resolve-shell.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
+import { resolveShellForScript } from "../utils/resolve-shell.ts";
+import { HeadSnapStage } from "./compact-stages/index.ts";
 import { DENIED_METRIC_NAMES } from "./metric-parser.ts";
 
 /** Hook execution stage. */
@@ -139,7 +139,14 @@ export async function runIterationHook(
 	options?: { timeoutMs?: number },
 ): Promise<HookResult> {
 	if (!isAllowedHookPath(hookScriptPath)) {
-		return { fired: false, stdout: "", stderr: "hook path not allowed: " + hookScriptPath, exitCode: null, timedOut: false, durationMs: 0 };
+		return {
+			fired: false,
+			stdout: "",
+			stderr: "hook path not allowed: " + hookScriptPath,
+			exitCode: null,
+			timedOut: false,
+			durationMs: 0,
+		};
 	}
 	// Resolve relative paths relative to cwd
 	const resolvedScript = path.isAbsolute(hookScriptPath) ? hookScriptPath : path.join(payload.cwd, hookScriptPath);
@@ -156,7 +163,12 @@ export async function runIterationHook(
 		const { command, args } = resolveShellForScript(resolvedScript);
 		const child = spawn(command, args, {
 			cwd: payload.cwd,
-			env: { ...sanitizeEnvSecrets(process.env, { allowList: ["PATH", "HOME", "USER", ...WINDOWS_ESSENTIAL_ENV_VARS, "TMPDIR", "LANG", "LC_ALL", "PI_CREW_*"] }), PI_CREW_HOOK: "1" },
+			env: {
+				...sanitizeEnvSecrets(process.env, {
+					allowList: ["PATH", "HOME", "USER", ...WINDOWS_ESSENTIAL_ENV_VARS, "TMPDIR", "LANG", "LC_ALL", "PI_CREW_*"],
+				}),
+				PI_CREW_HOOK: "1",
+			},
 			stdio: ["pipe", "pipe", "pipe"],
 		});
 
@@ -184,7 +196,9 @@ export async function runIterationHook(
 			// then apply the byte-cap stage with newline-snap so partial lines
 			// never appear in the captured preview. HeadSnapStage is byte-cap-safe
 			// (walks back partial UTF-8 sequences at the cut boundary).
-			const stdoutText = new HeadSnapStage({ maxBytes: MAX_STDOUT_BYTES }).apply(rawStdout.toString("utf-8"));
+			const stdoutText = new HeadSnapStage({
+				maxBytes: MAX_STDOUT_BYTES,
+			}).apply(rawStdout.toString("utf-8"));
 
 			const rawStderr = Buffer.concat(stderrChunks);
 
@@ -214,7 +228,9 @@ export async function runIterationHook(
 		// Write payload to stdin and close it.
 		// Handle EPIPE errors gracefully (occurs if the hook script exits before
 		// reading all of stdin, which is normal for some hook scripts on certain OS).
-		child.stdin.on("error", () => { /* ignore EPIPE — hook exited early */ });
+		child.stdin.on("error", () => {
+			/* ignore EPIPE — hook exited early */
+		});
 		try {
 			child.stdin.write(stdinJson, "utf-8");
 			child.stdin.end();
@@ -232,10 +248,7 @@ export async function runIterationHook(
  * - Empty stdout → null (no steer)
  * - Otherwise → trimmed stdout content
  */
-export function steerMessageFromHook(
-	stage: HookStage,
-	result: HookResult,
-): string | null {
+export function steerMessageFromHook(stage: HookStage, result: HookResult): string | null {
 	if (!result.fired) return null;
 
 	if (result.timedOut) {
@@ -267,10 +280,7 @@ export function steerMessageFromHook(
 /**
  * Build a log entry for recording hook execution in events.jsonl.
  */
-export function hookLogEntry(
-	stage: HookStage,
-	result: HookResult,
-): Record<string, unknown> {
+export function hookLogEntry(stage: HookStage, result: HookResult): Record<string, unknown> {
 	const entry: Record<string, unknown> = {
 		type: "iteration-hook",
 		stage,
@@ -292,4 +302,4 @@ export function hookLogEntry(
 	}
 
 	return entry;
-}
+}