pi-crew 0.9.16 → 0.9.17

package/src/runtime/retry-executor.ts

@@ -21,7 +21,12 @@ export interface RetryHooks {
 	signal?: AbortSignal;
 }
 
-export const DEFAULT_RETRY_POLICY: RetryPolicy = { maxAttempts: 3, backoffMs: 1000, jitterRatio: 0.3, exponentialFactor: 2 };
+export const DEFAULT_RETRY_POLICY: RetryPolicy = {
+	maxAttempts: 3,
+	backoffMs: 1000,
+	jitterRatio: 0.3,
+	exponentialFactor: 2,
+};
 
 function asError(error: unknown): Error {
 	return error instanceof Error ? error : new Error(String(error));
@@ -45,11 +50,22 @@ export function calculateRetryDelay(attempt: number, policy: RetryPolicy = DEFAU
 }
 
 function retryAttemptInfo(attempt: number, hooks: RetryHooks): RetryAttemptInfo {
-	return { attempt, attemptId: hooks.attemptId?.(attempt) ?? `retry_attempt_${attempt}` };
+	return {
+		attempt,
+		attemptId: hooks.attemptId?.(attempt) ?? `retry_attempt_${attempt}`,
+	};
 }
 
-export async function executeWithRetry<T>(fn: (attempt: number, info: RetryAttemptInfo) => Promise<T>, policy: RetryPolicy = DEFAULT_RETRY_POLICY, hooks: RetryHooks = {}): Promise<T> {
-	const normalized: RetryPolicy = { ...DEFAULT_RETRY_POLICY, ...policy, maxAttempts: Math.max(1, policy.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts) };
+export async function executeWithRetry<T>(
+	fn: (attempt: number, info: RetryAttemptInfo) => Promise<T>,
+	policy: RetryPolicy = DEFAULT_RETRY_POLICY,
+	hooks: RetryHooks = {},
+): Promise<T> {
+	const normalized: RetryPolicy = {
+		...DEFAULT_RETRY_POLICY,
+		...policy,
+		maxAttempts: Math.max(1, policy.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts),
+	};
 	let lastError: Error | undefined;
 	for (let attempt = 1; attempt <= normalized.maxAttempts; attempt += 1) {
 		throwIfCancelled(hooks.signal);

package/src/runtime/retry-runner.ts

@@ -1,17 +1,17 @@
 /**
  * RetryRunner - Execute tasks with retry support and summary accumulation.
- * 
+ *
  * Based on pi-boomerang's --rethrow pattern:
  * - Retries failed tasks up to maxAttempts
  * - Generates handoffs between attempts
  * - Accumulates context from previous attempts
  * - Supports exponential backoff
  * - Limits handoff accumulation to prevent memory leaks
- * 
+ *
  * @see docs/pi-boomerang-integration-plan.md
  */
 
-import type { HandoffSummary, HandoffManager, TaskPacket, TaskResult } from "./handoff-manager.ts";
+import type { HandoffManager, HandoffSummary, TaskPacket, TaskResult } from "./handoff-manager.ts";
 
 /**
  * Retry configuration.
@@ -75,10 +75,7 @@ export class RetryRunner {
 	private taskRunner: TaskRunnerLike;
 	private handoffManager: HandoffManager;
 
-	constructor(
-		taskRunner: TaskRunnerLike,
-		handoffManager: HandoffManager,
-	) {
+	constructor(taskRunner: TaskRunnerLike, handoffManager: HandoffManager) {
 		this.taskRunner = taskRunner;
 		this.handoffManager = handoffManager;
 	}
@@ -127,15 +124,12 @@ export class RetryRunner {
 	/**
 	 * Execute task with retry support.
 	 * Summaries accumulate between attempts for better context.
-	 * 
+	 *
 	 * @param packet - Task packet to execute
 	 * @param config - Retry configuration (stopOnSuccess defaults to true)
 	 * @returns Final retry result with all attempts
 	 */
-	async runWithRetry(
-		packet: TaskPacket,
-		config: RetryConfig
-	): Promise<RetryResult> {
+	async runWithRetry(packet: TaskPacket, config: RetryConfig): Promise<RetryResult> {
 		if (this._disposed) {
 			throw new Error("RetryRunner has been disposed");
 		}
@@ -148,7 +142,6 @@ export class RetryRunner {
 		// Clear previous handoffs at start of each retry run
 		this._handoffs = [];
 
-
 		for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
 			if (this._disposed) {
 				throw new Error("RetryRunner was disposed during retry");
@@ -157,11 +150,7 @@ export class RetryRunner {
 
 			try {
 				// Inject accumulated handoffs into context
-				const enrichedPacket = this.enrichPacketWithHandoffs(
-					packet,
-					handoffs,
-					attempt
-				);
+				const enrichedPacket = this.enrichPacketWithHandoffs(packet, handoffs, attempt);
 
 				// Execute task
 				const result = await this.taskRunner.runTask(enrichedPacket);
@@ -175,10 +164,7 @@ export class RetryRunner {
 
 				// Generate summary between attempts
 				if (config.summaryBetweenAttempts !== false) {
-					const summary = await this.handoffManager.generateSummary(
-						packet,
-						result
-					);
+					const summary = await this.handoffManager.generateSummary(packet, result);
 					attemptResult.summary = summary;
 					handoffs.push(summary);
 
@@ -213,13 +199,12 @@ export class RetryRunner {
 						config.backoffMs ?? 1000,
 						attempt,
 						config.backoffMultiplier ?? 1,
-						config.maxBackoffMs
+						config.maxBackoffMs,
 					);
 					if (backoffDelay > 0) {
 						await this.sleep(backoffDelay);
 					}
 				}
-
 			} catch (error) {
 				attempts.push({
 					attempt,
@@ -238,7 +223,7 @@ export class RetryRunner {
 						config.backoffMs,
 						attempt,
 						config.backoffMultiplier ?? 1,
-						config.maxBackoffMs
+						config.maxBackoffMs,
 					);
 					if (backoffDelay > 0) {
 						await this.sleep(backoffDelay);
@@ -260,24 +245,23 @@ export class RetryRunner {
 	/**
 	 * Enrich packet with accumulated handoffs from previous attempts.
 	 */
-	private enrichPacketWithHandoffs(
-		packet: TaskPacket,
-		handoffs: HandoffSummary[],
-		attempt: number
-	): TaskPacket {
+	private enrichPacketWithHandoffs(packet: TaskPacket, handoffs: HandoffSummary[], attempt: number): TaskPacket {
 		if (handoffs.length === 0) {
 			return packet;
 		}
 
 		// Build accumulated context from previous attempts
-		const accumulatedContext = handoffs.map((h, index) =>
-			`## Attempt ${index + 1}: ${h.task}\n` +
-			`Outcome: ${h.outcome}\n` +
-			`Files: created=${h.filesCreated.join(", ")}, modified=${h.filesModified.join(", ")}\n` +
-			`Decisions: ${h.decisions.map(d => d.rationale).join("; ")}\n` +
-			`Blockers: ${h.blockers.join(", ")}\n` +
-			`Next Steps: ${h.nextSteps.join(", ")}\n`
-		).join("\n---\n");
+		const accumulatedContext = handoffs
+			.map(
+				(h, index) =>
+					`## Attempt ${index + 1}: ${h.task}\n` +
+					`Outcome: ${h.outcome}\n` +
+					`Files: created=${h.filesCreated.join(", ")}, modified=${h.filesModified.join(", ")}\n` +
+					`Decisions: ${h.decisions.map((d) => d.rationale).join("; ")}\n` +
+					`Blockers: ${h.blockers.join(", ")}\n` +
+					`Next Steps: ${h.nextSteps.join(", ")}\n`,
+			)
+			.join("\n---\n");
 
 		return {
 			...packet,
@@ -293,12 +277,7 @@ export class RetryRunner {
 	/**
 	 * Calculate backoff delay with optional capping.
 	 */
-	private calculateBackoff(
-		baseMs: number,
-		attempt: number,
-		multiplier: number,
-		maxBackoffMs?: number
-	): number {
+	private calculateBackoff(baseMs: number, attempt: number, multiplier: number, maxBackoffMs?: number): number {
 		let delay = baseMs * Math.pow(multiplier, attempt - 1);
 		if (maxBackoffMs !== undefined) {
 			delay = Math.min(delay, maxBackoffMs);
@@ -310,17 +289,14 @@ export class RetryRunner {
 	 * Sleep helper.
 	 */
 	private sleep(ms: number): Promise<void> {
-		return new Promise(resolve => setTimeout(resolve, ms));
+		return new Promise((resolve) => setTimeout(resolve, ms));
 	}
 }
 
 /**
  * Create a RetryRunner with default dependencies.
  */
-export function createRetryRunner(
-	taskRunner: TaskRunnerLike,
-	handoffManager: HandoffManager
-): RetryRunner {
+export function createRetryRunner(taskRunner: TaskRunnerLike, handoffManager: HandoffManager): RetryRunner {
 	return new RetryRunner(taskRunner, handoffManager);
 }
 
@@ -357,4 +333,4 @@ export const PERSISTENT_FAILURE_RETRY_CONFIG: RetryConfig = {
 	backoffMs: 2000,
 	backoffMultiplier: 2,
 	maxBackoffMs: 60000,
-};
+};

package/src/runtime/role-permission.ts

@@ -24,6 +24,11 @@ export function currentCrewRole(env: NodeJS.ProcessEnv = process.env): string |
 export function checkSubagentSpawnPermission(role: string | undefined): PermissionCheckResult {
 	if (!role) return { allowed: true, mode: "workspace_write" };
 	const mode = permissionForRole(role);
-	if (mode === "read_only") return { allowed: false, mode, reason: `Role '${role}' is read-only and cannot spawn additional subagents.` };
+	if (mode === "read_only")
+		return {
+			allowed: false,
+			mode,
+			reason: `Role '${role}' is read-only and cannot spawn additional subagents.`,
+		};
 	return { allowed: true, mode };
 }

package/src/runtime/run-coalesced-task-group.ts

@@ -0,0 +1,256 @@
+/**
+ * run-coalesced-task-group.ts — M6 real-dispatch MVP worker spawn.
+ *
+ * Spawns ONE child Pi process for an entire coalesced group of N tasks
+ * (sharing role + cwd per `planCoalescedGroups`). The combined prompt
+ * instructs the worker to wrap each task's result in `<<<TASK_RESULT:id>>>`
+ * ... `<<<END_TASK_RESULT>>>` delimiters. Output is split back into N
+ * per-task results via `splitCoalescedOutput`, each written to its own
+ * result artifact + state update.
+ */
+
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { permissionForRole } from "./role-permission.ts";
+import { runChildPi } from "./child-pi.ts";
+import { splitCoalescedOutput } from "./task-runner/output-splitter.ts";
+import { buildWorkspaceTree } from "./workspace-tree.ts";
+import { saveRunTasks, updateRunStatus } from "../state/state-store.ts";
+import { writeArtifact } from "../state/artifact-store.ts";
+import { appendEventAsync } from "../state/event-log.ts";
+import { createWorkerHeartbeat, touchWorkerHeartbeat } from "./worker-heartbeat.ts";
+import type { AgentConfig } from "../agents/agent-config.ts";
+import type { CrewRuntimeMode } from "./runtime-resolver.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import type { WorkflowStep } from "../workflows/workflow-config.ts";
+import { mergeArtifacts } from "./team-runner-artifacts.ts";
+
+export interface CoalescedTaskGroupInput {
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	groupTasks: TeamTaskState[];
+	step: WorkflowStep;
+	agent: AgentConfig;
+	signal?: AbortSignal;
+	executeWorkers: boolean;
+	runtimeKind?: CrewRuntimeMode;
+	workspaceId: string;
+	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
+	teamRole?: unknown;
+	perTaskRuntime?: CrewRuntimeMode;
+}
+
+export interface CoalescedTaskGroupResult {
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	taskIds: string[];
+	rawOutput: string;
+	success: boolean;
+}
+
+export async function runCoalescedTaskGroup(input: CoalescedTaskGroupInput): Promise<CoalescedTaskGroupResult> {
+	const { manifest, groupTasks, step, agent, signal, executeWorkers } = input;
+	const groupId = groupTasks.map((t) => t.id).join("+");
+	const firstTask = groupTasks[0]!;
+	const taskIds = groupTasks.map((t) => t.id);
+
+	// Set ALL N tasks to "running" before spawn so the dashboard reflects
+	// the in-flight state.
+	let updatedTasks: TeamTaskState[] = input.tasks.map((t) => {
+		if (taskIds.includes(t.id) && t.status !== "running") {
+			return { ...t, status: "running" as const, startedAt: new Date().toISOString() };
+		}
+		return t;
+	});
+	saveRunTasks(manifest, updatedTasks);
+	await appendEventAsync(manifest.eventsPath, {
+		type: "task.coalesced_dispatch_start",
+		runId: manifest.runId,
+		message: `Dispatching ${groupTasks.length} coalesced tasks in 1 worker (role=${firstTask.role}, cwd=${firstTask.cwd})`,
+		data: { groupId, role: firstTask.role, cwd: firstTask.cwd, taskIds },
+	});
+
+	const combinedPrompt = await buildCoalescedPrompt(manifest, step, groupTasks, agent);
+
+	// FIX (M6): write heartbeats for ALL N tasks in the coalesced group so the
+	// background watcher doesn't fire heartbeat_dead against the (single)
+	// child pi worker. Previously runCoalescedTaskGroup never wrote heartbeats,
+	// so the watcher saw `heartbeat.lastSeenAt: undefined` within 2 seconds of
+	// spawn and emitted heartbeat_dead even though the worker continued to
+	// completion (false-positive stuck-worker alarms). The singleton path
+	// (runTeamTask) writes heartbeats via persistHeartbeat — M6 needs the
+	// equivalent to avoid the false-positive.
+	updatedTasks = updatedTasks.map((t) => {
+		if (!taskIds.includes(t.id)) return t;
+		return {
+			...t,
+			heartbeat: t.heartbeat ?? createWorkerHeartbeat(t.id),
+		};
+	});
+	saveRunTasks(manifest, updatedTasks);
+
+	let rawOutput = "";
+	let success = false;
+	if (!executeWorkers) {
+		rawOutput = buildScaffoldOutput(groupTasks);
+		success = true;
+	} else {
+		// Heartbeat refresher: touch every task's heartbeat every 15s while the
+		// worker is alive. Set `alive: true` explicitly so post-completion
+		// staleness checks immediately recognize liveness.
+		const heartbeatTimer = setInterval(() => {
+			const now = new Date().toISOString();
+			updatedTasks = updatedTasks.map((t) => {
+				if (!taskIds.includes(t.id)) return t;
+				return {
+					...t,
+					heartbeat: touchWorkerHeartbeat(t.heartbeat ?? createWorkerHeartbeat(t.id), { alive: true }),
+				};
+			});
+			try {
+				saveRunTasks(manifest, updatedTasks);
+			} catch {
+				// Run may have been pruned mid-dispatch — best-effort only.
+			}
+		}, 15_000);
+		try {
+			const result = await runChildPi({
+				cwd: firstTask.cwd,
+				task: combinedPrompt,
+				agent,
+				signal,
+				excludeContextBash: true,
+				maxTurns: 5,
+				onJsonEvent: (e) => input.onJsonEvent?.(firstTask.id, manifest.runId, e),
+			});
+			rawOutput = result.rawFinalText ?? result.stdout ?? "";
+			success = result.exitStatus?.exitCode === 0;
+		} catch (err) {
+			rawOutput = `Worker dispatch failed: ${err instanceof Error ? err.message : String(err)}`;
+			success = false;
+		} finally {
+			clearInterval(heartbeatTimer);
+		}
+	}
+
+	const split = splitCoalescedOutput(rawOutput, taskIds);
+
+	const finishedAt = new Date().toISOString();
+	const newArtifacts: TeamRunManifest["artifacts"] = [];
+	updatedTasks = updatedTasks.map((t) => {
+		if (!taskIds.includes(t.id)) return t;
+		const entry = split.find((s) => s.taskId === t.id);
+		const ok = success && Boolean(entry?.text);
+		const text = entry?.text ?? rawOutput;
+		// BUGFIX (M6 real dispatch): write to artifactsRoot via writeArtifact
+		// so task.resultArtifact is set and aggregateTaskOutputs can read
+		// the per-task text. Previously the coalesced path used a raw
+		// writeFile to stateRoot/results/<id>.txt which aggregated task
+		// outputs could not locate — they only consult task.resultArtifact.
+		// Result: tasks reported "EMPTY OUTPUT" in the batch summary even
+		// though on-disk results were correct.
+		const resultArtifact = writeArtifact(manifest.artifactsRoot, {
+			kind: "result",
+			relativePath: `results/${t.id}.txt`,
+			content: text,
+			producer: t.id,
+		});
+		newArtifacts.push(resultArtifact);
+		return {
+			...t,
+			status: ok ? ("completed" as const) : ("failed" as const),
+			finishedAt,
+			result: {
+				text,
+				producer: groupId,
+				strategy: entry?.strategy ?? "broadcast",
+			},
+			resultArtifact,
+		};
+	});
+	saveRunTasks(manifest, updatedTasks);
+	let updatedManifest: TeamRunManifest = {
+		...manifest,
+		artifacts: mergeArtifacts([...manifest.artifacts, ...newArtifacts]),
+	};
+
+	if (success) {
+		updatedManifest = updateRunStatus(updatedManifest, "running");
+	}
+	await appendEventAsync(updatedManifest.eventsPath, {
+		type: "task.coalesced_dispatch_end",
+		runId: manifest.runId,
+		message: `Coalesced dispatch ${success ? "completed" : "failed"} (${taskIds.length} tasks, ${split[0]?.strategy ?? "broadcast"} split)`,
+		data: { groupId, taskIds, success, strategy: split[0]?.strategy },
+	});
+
+	return { manifest: updatedManifest, tasks: updatedTasks, taskIds, rawOutput, success };
+}
+
+async function buildCoalescedPrompt(
+	manifest: TeamRunManifest,
+	step: WorkflowStep,
+	groupTasks: TeamTaskState[],
+	agent: AgentConfig,
+): Promise<string> {
+	const tree = await buildWorkspaceTree(groupTasks[0]!.cwd);
+	const treeBlock = tree.rendered ? `# Workspace Structure\n${tree.rendered}` : "";
+	const roleInstructions =
+		permissionForRole(groupTasks[0]!.role) === "read_only"
+			? `You are running in READ-ONLY mode. Do not create, modify, delete, or move files. Emit your findings as TEXT in your final output.`
+			: "";
+
+	const taskBlocks = groupTasks
+		.map((task, idx) => {
+			return [
+				`### Task ${idx + 1} of ${groupTasks.length} (id: ${task.id})`,
+				`Step: ${step.id}`,
+				`Role: ${step.role}`,
+				`Task: ${step.task.replaceAll("{goal}", manifest.goal)}`,
+			].join("\n");
+		})
+		.join("\n\n---\n\n");
+
+	const outputInstructions = groupTasks.map((task) => `<<<TASK_RESULT:${task.id}>>>`).join(" ... ");
+
+	return [
+		"# pi-crew Coalesced Worker Prompt",
+		`Run ID: ${manifest.runId}`,
+		`Team: ${manifest.team}`,
+		`Workflow: ${manifest.workflow ?? "(none)"}`,
+		`Goal: ${manifest.goal}`,
+		`Tasks in this batch: ${groupTasks.length}`,
+		``,
+		roleInstructions,
+		``,
+		treeBlock,
+		``,
+		`# Your Tasks`,
+		`Complete ALL ${groupTasks.length} tasks below. For each, structure your final output using the delimiters shown.`,
+		``,
+		taskBlocks,
+		``,
+		`# Output Format (CRITICAL)`,
+		`After completing all tasks, structure your final output using these delimiters:`,
+		``,
+		outputInstructions,
+		``,
+		`Wrap each task's result between the start and end delimiters:`,
+		`<<<TASK_RESULT:{taskId}>>>`,
+		`...your result for this task...`,
+		`<<<END_TASK_RESULT>>>`,
+		``,
+		`If delimiters don't fit your workflow, use \`### Task N of M\` headings and we'll parse those instead.`,
+	]
+		.filter(Boolean)
+		.join("\n");
+}
+
+function buildScaffoldOutput(groupTasks: TeamTaskState[]): string {
+	return groupTasks
+		.map(
+			(task, idx) =>
+				`<<<TASK_RESULT:${task.id}>>>\nScaffold result for task ${idx + 1} of ${groupTasks.length}: ${task.id}\n<<<END_TASK_RESULT>>>`,
+		)
+		.join("\n\n");
+}

package/src/runtime/run-drift.ts

@@ -6,19 +6,19 @@
  * Repair handlers are idempotent — safe to run multiple times.
  */
 
-import { existsSync, statSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import { logInternalError } from "../utils/internal-error.ts";
 
 // ── Types ────────────────────────────────────────────────────────────────
 
 export type DriftKind =
-	| "stale-process"         // Heartbeat timeout (existing)
-	| "orphaned-claim"        // Task claim without task
-	| "orphaned-worktree"     // Worktree dir without active run
-	| "missing-timestamps"    // State files without timestamps
-	| "status-divergence"     // Manifest status ≠ status file
-	| "unregistered-run";     // State dir but no manifest
+	| "stale-process" // Heartbeat timeout (existing)
+	| "orphaned-claim" // Task claim without task
+	| "orphaned-worktree" // Worktree dir without active run
+	| "missing-timestamps" // State files without timestamps
+	| "status-divergence" // Manifest status ≠ status file
+	| "unregistered-run"; // State dir but no manifest
 
 export interface DriftReport {
 	kind: DriftKind;
@@ -34,7 +34,12 @@ export interface DriftContext {
 	/** Active run IDs (from registry) */
 	activeRunIds: Set<string>;
 	/** Manifest content if available */
-	manifest?: { runId: string; status: string; cwd: string; [k: string]: unknown };
+	manifest?: {
+		runId: string;
+		status: string;
+		cwd: string;
+		[k: string]: unknown;
+	};
 }
 
 // ── Detectors ────────────────────────────────────────────────────────────
@@ -180,13 +185,7 @@ export function detectUnregisteredRun(ctx: DriftContext): DriftReport | null {
 
 // ── Reconciliation Loop ─────────────────────────────────────────────────
 
-const ALL_DETECTORS = [
-	detectOrphanedClaim,
-	detectOrphanedWorktree,
-	detectMissingTimestamps,
-	detectStatusDivergence,
-	detectUnregisteredRun,
-];
+const ALL_DETECTORS = [detectOrphanedClaim, detectOrphanedWorktree, detectMissingTimestamps, detectStatusDivergence, detectUnregisteredRun];
 
 /**
  * Run all drift detectors and collect reports.

package/src/runtime/run-tracker.ts

@@ -7,20 +7,14 @@ import { isFinishedRunStatus } from "./process-status.ts";
 
 export interface ActiveRunPromise {
 	promise: Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }>;
-	resolve: (value: {
-		manifest: TeamRunManifest;
-		tasks: TeamTaskState[];
-	}) => void;
+	resolve: (value: { manifest: TeamRunManifest; tasks: TeamTaskState[] }) => void;
 	reject: (reason: unknown) => void;
 }
 
 const activeRunPromises = new Map<string, ActiveRunPromise>();
 
 export function registerRunPromise(runId: string): ActiveRunPromise {
-	let resolve!: (value: {
-		manifest: TeamRunManifest;
-		tasks: TeamTaskState[];
-	}) => void;
+	let resolve!: (value: { manifest: TeamRunManifest; tasks: TeamTaskState[] }) => void;
 	let reject!: (reason: unknown) => void;
 	const promise = new Promise<{
 		manifest: TeamRunManifest;
@@ -34,10 +28,7 @@ export function registerRunPromise(runId: string): ActiveRunPromise {
 	return entry;
 }
 
-export function resolveRunPromise(
-	runId: string,
-	result: { manifest: TeamRunManifest; tasks: TeamTaskState[] },
-): void {
+export function resolveRunPromise(runId: string, result: { manifest: TeamRunManifest; tasks: TeamTaskState[] }): void {
 	const entry = activeRunPromises.get(runId);
 	if (entry) {
 		entry.resolve(result);
@@ -78,13 +69,7 @@ export async function waitForRun(
 	if (entry) {
 		let timer: ReturnType<typeof setTimeout> | undefined;
 		const timeoutPromise = new Promise<never>((_, reject) => {
-			timer = setTimeout(
-				() =>
-					reject(
-						new Error(`waitForRun timed out after ${timeoutMs}ms`),
-					),
-				timeoutMs,
-			);
+			timer = setTimeout(() => reject(new Error(`waitForRun timed out after ${timeoutMs}ms`)), timeoutMs);
 		});
 		try {
 			return await Promise.race([entry.promise, timeoutPromise]);
@@ -102,16 +87,9 @@ export async function waitForRun(
 			// projects (see issue #29). Without this, the hardcoded `.crew/state/runs/`
 			// path never resolves in projects that use the `.pi/` layout, the throw
 			// escapes via subagent-manager.ts:281, and pi crashes with uncaughtException.
-			const runDir = path.join(
-				projectCrewRoot(cwd),
-				"state",
-				"runs",
-				runId,
-			);
+			const runDir = path.join(projectCrewRoot(cwd), "state", "runs", runId);
 			if (!fs.existsSync(runDir)) {
-				throw new Error(
-					`Run ${runId} not found. No run directory at ${runDir}`,
-				);
+				throw new Error(`Run ${runId} not found. No run directory at ${runDir}`);
 			}
 		}
 		const fresh = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;

package/src/runtime/runtime-policy.ts

@@ -22,12 +22,7 @@ export function resolveTaskRuntimeKind(
 	// Exception: when PI_CREW_MOCK_LIVE_SESSION is set, we're in a test harness
 	// that mocks the live-session path — forcing child-process would spawn a real
 	// pi process and hang the test.
-	if (
-		globalKind === "live-session" &&
-		currentCrewDepth(env) > 0 &&
-		env.PI_CREW_MOCK_LIVE_SESSION !== "success"
-	)
-		return "child-process";
+	if (globalKind === "live-session" && currentCrewDepth(env) > 0 && env.PI_CREW_MOCK_LIVE_SESSION !== "success") return "child-process";
 	const isolatedRoles = isolationPolicy?.isolatedRoles ?? [];
 	if (isolatedRoles.includes(role)) return "child-process";
 	return isolationPolicy?.defaultRuntime ?? globalKind;