pi-crew 0.9.16 → 0.9.18

package/src/runtime/team-runner.ts

@@ -1,109 +1,50 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agent-config.ts";
-import type {
-	CrewLimitsConfig,
-	CrewReliabilityConfig,
-	CrewRuntimeConfig,
-} from "../config/config.ts";
+import type { CrewLimitsConfig, CrewReliabilityConfig, CrewRuntimeConfig } from "../config/config.ts";
 import { appendHookEvent, executeHook } from "../hooks/registry.ts";
-import {
-	childCorrelation,
-	withCorrelation,
-} from "../observability/correlation.ts";
+import { childCorrelation, withCorrelation } from "../observability/correlation.ts";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { PluginRegistry } from "../plugins/plugin-registry.ts";
-import {
-	NextJsPlugin,
-	VitePlugin,
-	VitestPlugin,
-} from "../plugins/plugins/index.ts";
+import { NextJsPlugin, VitePlugin, VitestPlugin } from "../plugins/plugins/index.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
-import {
-	appendEvent,
-	appendEventAsync,
-	appendEventFireAndForget,
-} from "../state/event-log.ts";
+import { appendEvent, appendEventAsync, appendEventBuffered, flushEventLogBuffer } from "../state/event-log.ts";
 import { HealthStore } from "../state/health-store.ts";
 import { withRunLock } from "../state/locks.ts";
-import {
-	loadRunManifestById,
-	saveRunManifest,
-	saveRunManifestAsync,
-	saveRunTasksAsync,
-	updateRunStatus,
-} from "../state/state-store.ts";
-import type {
-	ArtifactDescriptor,
-	PolicyDecision,
-	TaskAttemptState,
-	TeamRunManifest,
-	TeamTaskState,
-} from "../state/types.ts";
+import { loadRunManifestById, saveRunManifest, saveRunManifestAsync, saveRunTasksAsync, updateRunStatus } from "../state/state-store.ts";
+import type { ArtifactDescriptor, PolicyDecision, TaskAttemptState, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { aggregateUsage, formatUsage } from "../state/usage.ts";
 import type { TeamConfig } from "../teams/team-config.ts";
 import { logInternalError } from "../utils/internal-error.ts";
-import type {
-	WorkflowConfig,
-	WorkflowStep,
-} from "../workflows/workflow-config.ts";
+import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
 import { checkBranchFreshness } from "../worktree/branch-freshness.ts";
-import {
-	buildSyntheticTerminalEvidence,
-	CrewCancellationError,
-	cancellationReasonFromSignal,
-} from "./cancellation.ts";
+import { buildSyntheticTerminalEvidence, CrewCancellationError, cancellationReasonFromSignal } from "./cancellation.ts";
+import { buildDispatchUnits, planCoalescedGroups } from "./coalesce-tasks.ts";
 import { resolveBatchConcurrency } from "./concurrency.ts";
 import { readCrewAgents, saveCrewAgents } from "./crew-agent-records.ts";
 import type { CrewRuntimeKind } from "./crew-agent-runtime.ts";
 import { crewHooks } from "./crew-hooks.ts";
 import { appendDeadletter } from "./deadletter.ts";
-import {
-	effectivenessPolicyDecision,
-	evaluateRunEffectiveness,
-	formatRunEffectivenessLines,
-} from "./effectiveness.ts";
-import {
-	applyGoalAchievement,
-	assessGoalAchievement,
-} from "./goal-achievement.ts";
+import { effectivenessPolicyDecision, evaluateRunEffectiveness, formatRunEffectivenessLines } from "./effectiveness.ts";
+import { applyGoalAchievement, assessGoalAchievement } from "./goal-achievement.ts";
 import { deliverGroupJoin, resolveGroupJoinMode } from "./group-join.ts";
 import { terminateLiveAgentsForRun } from "./live-agent-manager.ts";
 import { mapConcurrent } from "./parallel-utils.ts";
-import {
-	evaluateCrewPolicy,
-	summarizePolicyDecisions,
-} from "./policy-engine.ts";
-import {
-	buildRecoveryLedger,
-	shouldRerunFailedTask,
-} from "./recovery-recipes.ts";
-import {
-	DEFAULT_RETRY_POLICY,
-	executeWithRetry,
-	type RetryPolicy,
-} from "./retry-executor.ts";
+import { filterReadyByWriteOverlap } from "./path-overlap.ts";
+import { evaluateCrewPolicy, summarizePolicyDecisions } from "./policy-engine.ts";
+import { buildRecoveryLedger, shouldRerunFailedTask } from "./recovery-recipes.ts";
+import { DEFAULT_RETRY_POLICY, executeWithRetry, type RetryPolicy } from "./retry-executor.ts";
 import { permissionForRole } from "./role-permission.ts";
-import {
-	registerRunPromise,
-	rejectRunPromise,
-	resolveRunPromise,
-} from "./run-tracker.ts";
+import { runCoalescedTaskGroup } from "./run-coalesced-task-group.ts";
+import { registerRunPromise, rejectRunPromise, resolveRunPromise } from "./run-tracker.ts";
 import { resolveTaskRuntimeKind } from "./runtime-policy.ts";
 import type { CrewRuntimeCapabilities } from "./runtime-resolver.ts";
 import { recordsForMaterializedTasks } from "./task-display.ts";
-import {
-	buildExecutionPlan as buildDagExecutionPlan,
-	getReadyTasks as getDagReadyTasks,
-	type TaskNode,
-} from "./task-graph.ts";
-import {
-	buildTaskGraphIndex,
-	refreshTaskGraphQueues,
-	taskGraphSnapshot,
-} from "./task-graph-scheduler.ts";
+import { buildExecutionPlan as buildDagExecutionPlan, getReadyTasks as getDagReadyTasks, type TaskNode } from "./task-graph.ts";
+import { buildTaskGraphIndex, refreshTaskGraphQueues, taskGraphSnapshot } from "./task-graph-scheduler.ts";
 import { aggregateTaskOutputs } from "./task-output-context.ts";
 import { runTeamTask } from "./task-runner.ts";
+import { mergeArtifacts } from "./team-runner-artifacts.ts";
 import { clearTrackedTaskUsage } from "./usage-tracker.ts";
 import {
 	createWorkflowStateMachine,
@@ -192,22 +133,14 @@ export interface ExecuteTeamRunInput {
 }
 
 function findStep(workflow: WorkflowConfig, task: TeamTaskState): WorkflowStep {
-	const step = workflow.steps.find(
-		(candidate) => candidate.id === task.stepId,
-	);
-	if (!step)
-		throw new Error(
-			`Workflow step '${task.stepId}' not found for task '${task.id}'.`,
-		);
+	const step = workflow.steps.find((candidate) => candidate.id === task.stepId);
+	if (!step) throw new Error(`Workflow step '${task.stepId}' not found for task '${task.id}'.`);
 	return step;
 }
 
 function findAgent(agents: AgentConfig[], task: TeamTaskState): AgentConfig {
 	const agent = agents.find((candidate) => candidate.name === task.agent);
-	if (!agent)
-		throw new Error(
-			`Agent '${task.agent}' not found for task '${task.id}'.`,
-		);
+	if (!agent) throw new Error(`Agent '${task.agent}' not found for task '${task.id}'.`);
 	return agent;
 }
 
@@ -219,20 +152,12 @@ function markBlocked(tasks: TeamTaskState[], reason: string): TeamTaskState[] {
 					status: "skipped",
 					error: reason,
 					finishedAt: new Date().toISOString(),
-					graph: task.graph
-						? { ...task.graph, queue: "blocked" }
-						: undefined,
+					graph: task.graph ? { ...task.graph, queue: "blocked" } : undefined,
 				}
 			: task,
 	);
 }
 
-function mergeArtifacts(items: ArtifactDescriptor[]): ArtifactDescriptor[] {
-	const byPath = new Map<string, ArtifactDescriptor>();
-	for (const item of items) byPath.set(item.path, item);
-	return [...byPath.values()];
-}
-
 function isNonTerminalTaskStatus(status: TeamTaskState["status"]): boolean {
 	return status === "queued" || status === "running" || status === "waiting";
 }
@@ -253,22 +178,15 @@ function safeFinishedAt(task: TeamTaskState): number {
  * and the updated task has a valid finite finishedAt. Malformed finishedAt
  * should be replaced rather than persisting corruption.
  */
-function isMalformedFinishedAtReplacement(
-	currentTime: number,
-	updatedTime: number,
-): boolean {
+function isMalformedFinishedAtReplacement(currentTime: number, updatedTime: number): boolean {
 	return !Number.isFinite(currentTime) && Number.isFinite(updatedTime);
 }
 
-function shouldMergeTaskUpdate(
-	current: TeamTaskState,
-	updated: TeamTaskState,
-): boolean {
+function shouldMergeTaskUpdate(current: TeamTaskState, updated: TeamTaskState): boolean {
 	// Parallel workers receive the same input snapshot. A later result may still
 	// contain stale queued/running copies of tasks that another worker already
 	// completed. Never let those stale snapshots regress durable task state.
-	if (current.status === "waiting" && updated.status === "running")
-		return false;
+	if (current.status === "waiting" && updated.status === "running") return false;
 	// Block terminal→non-terminal transitions (e.g. completed→running).
 	// A task that has reached a terminal state must not be resurrected.
 	const currentIsTerminal = !isNonTerminalTaskStatus(current.status);
@@ -277,34 +195,21 @@ function shouldMergeTaskUpdate(
 	// Explicitly block completed↔needs_attention terminal-to-terminal transitions.
 	// Both are success terminal states used interchangeably; stale worker updates must
 	// not cause a completed task to appear as needs_attention or vice versa.
-	if (current.status === "completed" && updated.status === "needs_attention")
-		return false;
-	if (current.status === "needs_attention" && updated.status === "completed")
-		return false;
+	if (current.status === "completed" && updated.status === "needs_attention") return false;
+	if (current.status === "needs_attention" && updated.status === "completed") return false;
 	// Explicitly block failed→completed resurrection. Both statuses are terminal,
 	// but completed is the success terminal state and should not be reachable from
 	// failed via a stale merge. The check above only guards non-terminal→terminal.
-	if (current.status === "failed" && updated.status === "completed")
-		return false;
+	if (current.status === "failed" && updated.status === "completed") return false;
 	// Guard: when current is "running" but has resultArtifact (another worker already
 	// completed it), a stale updated with status="running" and no resultArtifact
 	// must not overwrite the actual completed state.
-	if (
-		current.status === updated.status &&
-		updated.status === "running" &&
-		current.resultArtifact &&
-		!updated.resultArtifact
-	)
+	if (current.status === updated.status && updated.status === "running" && current.resultArtifact && !updated.resultArtifact)
 		return false;
 	// Guard: when current is "completed" and has resultArtifact but updated is also
 	// "completed" without resultArtifact, block the stale update from overwriting
 	// a task that successfully produced output.
-	if (
-		current.status === updated.status &&
-		current.status === "completed" &&
-		current.resultArtifact &&
-		!updated.resultArtifact
-	)
+	if (current.status === updated.status && current.status === "completed" && current.resultArtifact && !updated.resultArtifact)
 		return false;
 	// Prevent a stale completed task from overwriting a fresher one.
 	// Restructure to handle undefined current.finishedAt as a special case:
@@ -318,9 +223,7 @@ function shouldMergeTaskUpdate(
 		// Malformed finishedAt (NaN) is treated as Infinity — invalid state should be
 		// replaced rather than persisting corruption. Log warning for visibility.
 		if (!Number.isFinite(currentTime)) {
-			console.warn(
-				`[team-runner] Task ${current.id} has malformed finishedAt: ${current.finishedAt}`,
-			);
+			console.warn(`[team-runner] Task ${current.id} has malformed finishedAt: ${current.finishedAt}`);
 		}
 		if (isMalformedFinishedAtReplacement(currentTime, updatedTime)) {
 			return true;
@@ -330,8 +233,7 @@ function shouldMergeTaskUpdate(
 	// Block if updated is trying to establish a terminal status without a finishedAt
 	// timestamp. Heartbeat-only updates (status='running', no finishedAt) are
 	// allowed if heartbeat has changed (checked separately in hasMeaningfulUpdate).
-	if (!updated.finishedAt && !isNonTerminalTaskStatus(updated.status))
-		return false;
+	if (!updated.finishedAt && !isNonTerminalTaskStatus(updated.status)) return false;
 	// Explicitly enumerate all fields that constitute a meaningful update so that
 	// adding a new important field requires updating this list (rather than silently
 	// losing data if a field is forgotten in the boolean OR chain below).
@@ -340,25 +242,20 @@ function shouldMergeTaskUpdate(
 		updated.finishedAt !== current.finishedAt ||
 		updated.startedAt !== current.startedAt ||
 		Boolean(updated.resultArtifact) !== Boolean(current.resultArtifact) ||
-		(Boolean(updated.resultArtifact) &&
-			updated.resultArtifact !== current.resultArtifact) ||
+		(Boolean(updated.resultArtifact) && updated.resultArtifact !== current.resultArtifact) ||
 		Boolean(updated.error) ||
 		Boolean(updated.modelAttempts?.length) ||
 		Boolean(updated.usage) ||
 		Boolean(updated.attempts?.length) ||
 		updated.heartbeat?.lastSeenAt !== current.heartbeat?.lastSeenAt ||
 		updated.jsonEvents !== current.jsonEvents ||
-		updated.agentProgress?.lastActivityAt !==
-			current.agentProgress?.lastActivityAt;
+		updated.agentProgress?.lastActivityAt !== current.agentProgress?.lastActivityAt;
 	return hasMeaningfulUpdate;
 }
 
 // H4 fix: rename to descriptive name. Kept __test__ as alias for backward
 // compat test imports.
-export function mergeTaskUpdatesPreservingTerminal(
-	base: TeamTaskState[],
-	results: Array<{ tasks: TeamTaskState[] }>,
-): TeamTaskState[] {
+export function mergeTaskUpdatesPreservingTerminal(base: TeamTaskState[], results: Array<{ tasks: TeamTaskState[] }>): TeamTaskState[] {
 	let merged = base;
 	for (const result of results) {
 		for (const updated of result.tasks) {
@@ -368,21 +265,15 @@ export function mergeTaskUpdatesPreservingTerminal(
 				// Log skipped merges for visibility into rejected parallel updates.
 				// In distributed systems with parallel workers, rejected merges may
 				// indicate bugs (wrong status, timestamp corruption) if they accumulate.
-				console.debug(
-					"[team-runner] Skipping stale merge for task",
-					updated.id,
-					{
-						currentStatus: current.status,
-						updatedStatus: updated.status,
-						currentFinishedAt: current.finishedAt,
-						updatedFinishedAt: updated.finishedAt,
-					},
-				);
+				console.debug("[team-runner] Skipping stale merge for task", updated.id, {
+					currentStatus: current.status,
+					updatedStatus: updated.status,
+					currentFinishedAt: current.finishedAt,
+					updatedFinishedAt: updated.finishedAt,
+				});
 				continue;
 			}
-			merged = merged.map((task) =>
-				task.id === updated.id ? updated : task,
-			);
+			merged = merged.map((task) => (task.id === updated.id ? updated : task));
 		}
 	}
 	return refreshTaskGraphQueues(merged);
@@ -427,8 +318,7 @@ function writeProgress(
 	runtimeConfig?: CrewRuntimeConfig,
 ): TeamRunManifest {
 	const counts = new Map<string, number>();
-	for (const task of tasks)
-		counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
+	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
 	const queue = taskGraphSnapshot(tasks);
 	const progress = writeArtifact(manifest.artifactsRoot, {
 		kind: "progress",
@@ -448,12 +338,7 @@ function writeProgress(
 			...tasks.map(formatTaskProgress),
 			"",
 			"## Effectiveness",
-			...runEffectivenessLines(
-				manifest,
-				tasks,
-				executeWorkers,
-				runtimeConfig,
-			),
+			...runEffectivenessLines(manifest, tasks, executeWorkers, runtimeConfig),
 			"",
 		].join("\n"),
 	});
@@ -461,26 +346,13 @@ function writeProgress(
 		...manifest,
 		updatedAt: new Date().toISOString(),
 		artifacts: [
-			...manifest.artifacts.filter(
-				(artifact) =>
-					!(
-						artifact.kind === "progress" &&
-						artifact.path === progress.path
-					),
-			),
+			...manifest.artifacts.filter((artifact) => !(artifact.kind === "progress" && artifact.path === progress.path)),
 			progress,
-		].filter(
-			(artifact, index, self) =>
-				self.findIndex((a) => a.path === artifact.path) === index,
-		),
+		].filter((artifact, index, self) => self.findIndex((a) => a.path === artifact.path) === index),
 	};
 }
 
-function applyPolicy(
-	manifest: TeamRunManifest,
-	tasks: TeamTaskState[],
-	limits?: CrewLimitsConfig,
-): TeamRunManifest {
+function applyPolicy(manifest: TeamRunManifest, tasks: TeamTaskState[], limits?: CrewLimitsConfig): TeamRunManifest {
 	const branchFreshness = checkBranchFreshness(manifest.cwd);
 	const branchArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "metadata",
@@ -493,10 +365,7 @@ function applyPolicy(
 		tasks,
 		limits,
 	});
-	if (
-		branchFreshness.status === "stale" ||
-		branchFreshness.status === "diverged"
-	) {
+	if (branchFreshness.status === "stale" || branchFreshness.status === "diverged") {
 		const branchDecision: PolicyDecision = {
 			action: "notify",
 			reason: "branch_stale",
@@ -526,10 +395,7 @@ function applyPolicy(
 	});
 	for (const item of decisions)
 		appendEvent(manifest.eventsPath, {
-			type:
-				item.action === "escalate"
-					? "policy.escalated"
-					: "policy.action",
+			type: item.action === "escalate" ? "policy.escalated" : "policy.action",
 			runId: manifest.runId,
 			taskId: item.taskId,
 			message: item.message,
@@ -537,10 +403,7 @@ function applyPolicy(
 		});
 	for (const item of recoveryLedger.entries)
 		appendEvent(manifest.eventsPath, {
-			type:
-				item.state === "escalation_required"
-					? "recovery.escalated"
-					: "recovery.attempted",
+			type: item.state === "escalation_required" ? "recovery.escalated" : "recovery.attempted",
 			runId: manifest.runId,
 			taskId: item.taskId,
 			message: item.message,
@@ -572,9 +435,7 @@ function applyPolicy(
 	};
 }
 
-function retryPolicyFromConfig(
-	config: CrewReliabilityConfig | undefined,
-): RetryPolicy {
+function retryPolicyFromConfig(config: CrewReliabilityConfig | undefined): RetryPolicy {
 	return { ...DEFAULT_RETRY_POLICY, ...(config?.retryPolicy ?? {}) };
 }
 
@@ -584,25 +445,15 @@ function retryPolicyFromConfig(
  * automatically. Previously opt-in, which left the entire retry+recovery stack dormant.
  * Exported for unit testing.
  */
-export function shouldUseRetry(
-	reliability: CrewReliabilityConfig | undefined,
-): boolean {
+export function shouldUseRetry(reliability: CrewReliabilityConfig | undefined): boolean {
 	return reliability?.autoRetry !== false;
 }
 
-function failedTaskFrom(
-	result: { tasks: TeamTaskState[] },
-	taskId: string,
-): TeamTaskState | undefined {
-	return result.tasks.find(
-		(item) => item.id === taskId && item.status === "failed",
-	);
+function failedTaskFrom(result: { tasks: TeamTaskState[] }, taskId: string): TeamTaskState | undefined {
+	return result.tasks.find((item) => item.id === taskId && item.status === "failed");
 }
 
-function requiresPlanApproval(
-	_workflow: WorkflowConfig,
-	runtimeConfig: CrewRuntimeConfig | undefined,
-): boolean {
+function requiresPlanApproval(_workflow: WorkflowConfig, runtimeConfig: CrewRuntimeConfig | undefined): boolean {
 	// ROADMAP T1.2: plan-level HITL applies to ANY workflow when
 	// config.runtime.requirePlanApproval === true (not just 'implementation').
 	// The gate fires at the read-only → mutating (plan → execute) boundary.
@@ -610,31 +461,19 @@ function requiresPlanApproval(
 }
 
 function isPlanApprovalPending(manifest: TeamRunManifest): boolean {
-	return (
-		manifest.planApproval?.required === true &&
-		manifest.planApproval.status === "pending"
-	);
+	return manifest.planApproval?.required === true && manifest.planApproval.status === "pending";
 }
 
 function isMutatingTask(task: TeamTaskState): boolean {
 	return permissionForRole(task.role) !== "read_only";
 }
 
-function ensurePlanApprovalRequested(
-	manifest: TeamRunManifest,
-	tasks: TeamTaskState[],
-): TeamRunManifest {
+function ensurePlanApprovalRequested(manifest: TeamRunManifest, tasks: TeamTaskState[]): TeamRunManifest {
 	if (manifest.planApproval) return manifest;
-	const assessTask = tasks.find(
-		(task) => task.stepId === "assess" && task.status === "completed",
-	);
+	const assessTask = tasks.find((task) => task.stepId === "assess" && task.status === "completed");
 	// ROADMAP T1.2: for non-adaptive workflows, fall back to the most recent
 	// completed read-only (planning) task as the plan reference.
-	const planTask =
-		assessTask ??
-		[...tasks]
-			.reverse()
-			.find((t) => t.status === "completed" && !isMutatingTask(t));
+	const planTask = assessTask ?? [...tasks].reverse().find((t) => t.status === "completed" && !isMutatingTask(t));
 	const now = new Date().toISOString();
 	const updated: TeamRunManifest = {
 		...manifest,
@@ -653,39 +492,28 @@ function ensurePlanApprovalRequested(
 		type: "plan.approval_required",
 		runId: updated.runId,
 		taskId: planTask?.id,
-		message:
-			"Plan requires explicit approval before mutating tasks run. Use: team api op=approve-plan runId=...",
+		message: "Plan requires explicit approval before mutating tasks run. Use: team api op=approve-plan runId=...",
 		data: { planArtifactPath: planTask?.resultArtifact?.path },
 	});
 	return updated;
 }
 
-function cancelPlanTasks(
-	tasks: TeamTaskState[],
-	reason: string,
-): TeamTaskState[] {
+function cancelPlanTasks(tasks: TeamTaskState[], reason: string): TeamTaskState[] {
 	return tasks.map((task) =>
-		task.status === "queued" ||
-		task.status === "running" ||
-		task.status === "waiting"
+		task.status === "queued" || task.status === "running" || task.status === "waiting"
 			? {
 					...task,
 					status: "cancelled",
 					finishedAt: new Date().toISOString(),
 					error: reason,
-					graph: task.graph
-						? { ...task.graph, queue: "done" }
-						: undefined,
+					graph: task.graph ? { ...task.graph, queue: "done" } : undefined,
 				}
 			: task,
 	);
 }
 
 function hasPendingMutatingAdaptiveTask(tasks: TeamTaskState[]): boolean {
-	return tasks.some(
-		(task) =>
-			task.status === "queued" && task.adaptive && isMutatingTask(task),
-	);
+	return tasks.some((task) => task.status === "queued" && task.adaptive && isMutatingTask(task));
 }
 
 /**
@@ -693,15 +521,9 @@ function hasPendingMutatingAdaptiveTask(tasks: TeamTaskState[]): boolean {
  * Fires when there are pending mutating tasks whose prerequisites (read-only
  * tasks) have completed — i.e. the plan→execute boundary.
  */
-export function hasPendingMutatingTaskAtBoundary(
-	tasks: TeamTaskState[],
-): boolean {
-	const hasCompletedReadOnly = tasks.some(
-		(t) => t.status === "completed" && !isMutatingTask(t),
-	);
-	const hasPendingMutating = tasks.some(
-		(t) => t.status === "queued" && isMutatingTask(t),
-	);
+export function hasPendingMutatingTaskAtBoundary(tasks: TeamTaskState[]): boolean {
+	const hasCompletedReadOnly = tasks.some((t) => t.status === "completed" && !isMutatingTask(t));
+	const hasPendingMutating = tasks.some((t) => t.status === "queued" && isMutatingTask(t));
 	return hasCompletedReadOnly && hasPendingMutating;
 }
 
@@ -710,10 +532,7 @@ export function hasPendingMutatingTaskAtBoundary(
  * execution planning. If so, build an execution plan and use `getDagReadyTasks`
  * to augment the ready-set selection.
  */
-function dagReadyTaskIds(
-	tasks: TeamTaskState[],
-	completedIds: Set<string>,
-): string[] | null {
+function dagReadyTaskIds(tasks: TeamTaskState[], completedIds: Set<string>): string[] | null {
 	const hasExplicitDeps = tasks.some((t) => t.dependsOn.length > 0);
 	if (!hasExplicitDeps) return null;
 	// FIX (goal-wrap runtime test): task.dependsOn stores STEP IDs (e.g. "execute"), not
@@ -736,9 +555,7 @@ function dagReadyTaskIds(
 	return getDagReadyTasks(plan, completedIds);
 }
 
-export async function executeTeamRun(
-	input: ExecuteTeamRunInput,
-): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
+export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
 	const workflow = input.workflow;
 
 	// DEFENSE-IN-DEPTH (advisory-only since v0.9.15): re-validate topology here in
@@ -748,30 +565,17 @@ export async function executeTeamRun(
 	// Skip for synthetic direct-agent workflows (filePath="<generated>").
 	if (workflow.filePath !== "<generated>") {
 		// LAZY: defer preflight-validator import until the defense-in-depth guard actually runs.
-		const { validateWorkflowUsage } = await import(
-			"../workflows/preflight-validator.ts"
-		);
+		const { validateWorkflowUsage } = await import("../workflows/preflight-validator.ts");
 		const preflight = validateWorkflowUsage(workflow, {
 			force: input.reliability?.forcePreflight === true,
 		});
-		if (
-			preflight.level === "warn" ||
-			preflight.level === "note" ||
-			preflight.level === "info"
-		) {
-			const icon =
-				preflight.level === "warn"
-					? "⚠️ "
-					: preflight.level === "note"
-						? "✅ "
-						: "ℹ️  ";
+		if (preflight.level === "warn" || preflight.level === "note" || preflight.level === "info") {
+			const icon = preflight.level === "warn" ? "⚠️ " : preflight.level === "note" ? "✅ " : "ℹ️  ";
 			console.warn(
 				`${icon}[team-runner.preflight] ${preflight.level.toUpperCase()}: ${preflight.message} (workflow=${workflow.name})`,
 			);
 			if (preflight.suggestion) {
-				console.warn(
-					`[team-runner.preflight] → ${preflight.suggestion}`,
-				);
+				console.warn(`[team-runner.preflight] → ${preflight.suggestion}`);
 			}
 		}
 	}
@@ -779,9 +583,7 @@ export async function executeTeamRun(
 	let manifest = updateRunStatus(
 		input.manifest,
 		"running",
-		input.executeWorkers
-			? "Executing team workflow."
-			: "Creating workflow prompts and placeholder results.",
+		input.executeWorkers ? "Executing team workflow." : "Creating workflow prompts and placeholder results.",
 	);
 
 	void registerRunPromise(manifest.runId);
@@ -791,10 +593,7 @@ export async function executeTeamRun(
 	// (NO_PID_HEARTBEAT_STALE_MS). Previously only sub-task runners wrote
 	// heartbeats; the team-level run had no heartbeat, so any multi-phase
 	// workflow lasting >5min was marked stale and cancelled.
-	const stopTeamHeartbeat = startTeamRunHeartbeat(
-		manifest.stateRoot,
-		manifest.runId,
-	);
+	const stopTeamHeartbeat = startTeamRunHeartbeat(manifest.stateRoot, manifest.runId);
 
 	const cleanupUsage = (): void => {
 		for (const task of input.tasks) clearTrackedTaskUsage(task.id);
@@ -807,11 +606,7 @@ export async function executeTeamRun(
 		// (and/or had a failed task) is a false-green. We expose goalAchieved on the
 		// manifest + emit an event so the lie is never silent, and downgrade status
 		// to "failed" only when a failed task corroborates it (conservative).
-		const gaAssessment = assessGoalAchievement(
-			result.manifest,
-			result.tasks,
-			workflow,
-		);
+		const gaAssessment = assessGoalAchievement(result.manifest, result.tasks, workflow);
 		const gaApplied = applyGoalAchievement(result.manifest, gaAssessment);
 		if (gaApplied.manifest !== result.manifest) {
 			result.manifest = gaApplied.manifest;
@@ -820,9 +615,7 @@ export async function executeTeamRun(
 			} catch (persistError) {
 				logInternalError(
 					"team-runner.goalAchievement.persist",
-					persistError instanceof Error
-						? persistError
-						: new Error(String(persistError)),
+					persistError instanceof Error ? persistError : new Error(String(persistError)),
 					`runId=${manifest.runId}`,
 				);
 			}
@@ -841,27 +634,15 @@ export async function executeTeamRun(
 		if (gaApplied.downgraded)
 			logInternalError(
 				"team-runner.goalAchievement.falseGreen",
-				new Error(
-					gaApplied.manifest.goalAchievementNote ??
-						"false-green detected",
-				),
+				new Error(gaApplied.manifest.goalAchievementNote ?? "false-green detected"),
 				`runId=${manifest.runId}`,
 			);
 		stopTeamHeartbeat();
 		resolveRunPromise(manifest.runId, result);
 		cleanupUsage();
 		// Terminate live agents for this run — agents are done when the run ends.
-		void terminateLiveAgentsForRun(
-			manifest.runId,
-			"completed",
-			appendEvent,
-			manifest.eventsPath,
-		).catch((error) =>
-			logInternalError(
-				"team-runner.completed.terminate",
-				error,
-				`runId=${manifest.runId}`,
-			),
+		void terminateLiveAgentsForRun(manifest.runId, "completed", appendEvent, manifest.eventsPath).catch((error) =>
+			logInternalError("team-runner.completed.terminate", error, `runId=${manifest.runId}`),
 		);
 
 		// Emit run completion hook (100% reliable, fire-and-forget)
@@ -885,13 +666,16 @@ export async function executeTeamRun(
 		if (afterRunReport.outcome === "block") {
 			logInternalError(
 				"team-runner.after_run_complete.blocked",
-				new Error(
-					afterRunReport.reason ?? "after_run_complete hook blocked",
-				),
+				new Error(afterRunReport.reason ?? "after_run_complete hook blocked"),
 				`runId=${manifest.runId}`,
 			);
 		}
 
+		// M7: flush buffered task.progress events so the final state is durable
+		// before the run returns. Buffered producer wins on latency (p95≈0µs);
+		// this single flush at run-end coalesces any pending progress bursts
+		// before manifest updates are observed by readers.
+		await flushEventLogBuffer();
 		return result;
 	} catch (error) {
 		// Round 27 (BUG 1): the success path calls stopTeamHeartbeat() but this
@@ -905,23 +689,25 @@ export async function executeTeamRun(
 		stopTeamHeartbeat();
 		// P1: Catch unhandled errors — ensure manifest/tasks/agents are terminal so they don't stay "running" forever.
 		const message = error instanceof Error ? error.message : String(error);
-		// Reload manifest with lock to avoid stale data overwriting concurrent writes.
-		// If lock acquisition fails, use in-memory data rather than stale disk data.
-		let loaded;
-		try {
-			loaded = await withRunLock(input.manifest, async () =>
-				loadRunManifestById(input.manifest.cwd, input.manifest.runId),
-			);
-		} catch {
-			loaded = undefined; // best-effort: use in-memory data if lock fails
-		}
-		const freshManifest = loaded?.manifest ?? manifest;
-		const freshTasks = refreshTaskGraphQueues(loaded?.tasks ?? input.tasks);
+		// FIX (2026-07-02): drop withRunLock here entirely.
+		// Previously this catch path acquired withRunLock to reload manifest+tasks
+		// from disk (best-effort with in-memory fallback). But the closeout path at
+		// line ~1596 ALSO holds the same run lock for its final save — when a late
+		// failure fires during closeout (e.g. async hook error after run.completed),
+		// this catch path can hit `Run 'run.lock' is locked by another operation.`
+		// and the error propagates as "Unhandled error in team runner" after the
+		// run has actually completed. Lock acquisition here is unnecessary —
+		// the closeout writes through to disk before this catch fires (or after —
+		// either is fine), and the in-memory state already contains the latest
+		// post-completion manifest/tasks. We use in-memory state unconditionally.
+		// The stale-data concern is mitigated by the dispatcher having re-read disk
+		// state under lock at line ~1364 for each iteration; the manifest+task
+		// objects in the calling scope are already post-merge.
+		const freshManifest = manifest;
+		const freshTasks = refreshTaskGraphQueues(input.tasks);
 		const failedAt = new Date().toISOString();
 		const tasks = freshTasks.map((task) =>
-			task.status === "running" ||
-			task.status === "queued" ||
-			task.status === "waiting"
+			task.status === "running" || task.status === "queued" || task.status === "waiting"
 				? {
 						...task,
 						status: "failed" as const,
@@ -932,53 +718,28 @@ export async function executeTeamRun(
 		);
 		manifest = freshManifest;
 		try {
-			await terminateLiveAgentsForRun(
-				manifest.runId,
-				"failed",
-				appendEvent,
-				manifest.eventsPath,
-			);
+			await terminateLiveAgentsForRun(manifest.runId, "failed", appendEvent, manifest.eventsPath);
 			await saveRunTasksAsync(manifest, tasks);
-			const existingRuntimeByTask = new Map(
-				readCrewAgents(manifest).map((agent) => [
-					agent.taskId,
-					agent.runtime,
-				]),
-			);
+			const existingRuntimeByTask = new Map(readCrewAgents(manifest).map((agent) => [agent.taskId, agent.runtime]));
 			const globalRuntime = input.runtime?.kind ?? "child-process";
-			const runtimeForAgent = (
-				agent: ReturnType<typeof recordsForMaterializedTasks>[number],
-			): CrewRuntimeKind => {
+			const runtimeForAgent = (agent: ReturnType<typeof recordsForMaterializedTasks>[number]): CrewRuntimeKind => {
 				const task = tasks.find((item) => item.id === agent.taskId);
 				return (
 					existingRuntimeByTask.get(agent.taskId) ??
-					resolveTaskRuntimeKind(
-						globalRuntime,
-						task?.role ?? agent.role,
-						input.runtimeConfig?.isolationPolicy,
-					)
+					resolveTaskRuntimeKind(globalRuntime, task?.role ?? agent.role, input.runtimeConfig?.isolationPolicy)
 				);
 			};
 			saveCrewAgents(
 				manifest,
-				recordsForMaterializedTasks(manifest, tasks, globalRuntime).map(
-					(agent) => ({ ...agent, runtime: runtimeForAgent(agent) }),
-				),
-			);
-			manifest = updateRunStatus(
-				manifest,
-				"failed",
-				`Unhandled error in team runner: ${message}`,
+				recordsForMaterializedTasks(manifest, tasks, globalRuntime).map((agent) => ({ ...agent, runtime: runtimeForAgent(agent) })),
 			);
+			manifest = updateRunStatus(manifest, "failed", `Unhandled error in team runner: ${message}`);
 			await saveRunManifestAsync(manifest);
 		} catch {
 			// Best-effort — state write may also fail
 		}
 		const result = { manifest, tasks };
-		rejectRunPromise(
-			manifest.runId,
-			error instanceof Error ? error : new Error(message),
-		);
+		rejectRunPromise(manifest.runId, error instanceof Error ? error : new Error(message));
 		crewHooks.emit({
 			type: "run_failed",
 			timestamp: new Date().toISOString(),
@@ -986,6 +747,9 @@ export async function executeTeamRun(
 			data: { status: manifest.status, error: message },
 		});
 		cleanupUsage();
+		// M7: flush buffered events before returning on the error path so the
+		// final buffered progress events are durable alongside the failure state.
+		await flushEventLogBuffer();
 		return result;
 	}
 }
@@ -1002,11 +766,7 @@ async function executeTeamRunCore(
 	});
 	appendHookEvent(manifest, beforeRunReport);
 	if (beforeRunReport.outcome === "block") {
-		manifest = updateRunStatus(
-			manifest,
-			"blocked",
-			beforeRunReport.reason ?? "before_run_start hook blocked the run.",
-		);
+		manifest = updateRunStatus(manifest, "blocked", beforeRunReport.reason ?? "before_run_start hook blocked the run.");
 		return { manifest, tasks: input.tasks };
 	}
 	let tasks = refreshTaskGraphQueues(input.tasks);
@@ -1015,12 +775,7 @@ async function executeTeamRunCore(
 	let adaptivePlanInjected = false;
 	let adaptivePlanMissing = false;
 	const attemptAdaptivePlan = () => {
-		if (
-			!canInjectAdaptivePlan ||
-			adaptivePlanInjected ||
-			adaptivePlanMissing
-		)
-			return { injected: false, missing: false };
+		if (!canInjectAdaptivePlan || adaptivePlanInjected || adaptivePlanMissing) return { injected: false, missing: false };
 		const adaptivePlan = injectAdaptivePlanIfReady({
 			manifest,
 			tasks,
@@ -1038,69 +793,38 @@ async function executeTeamRunCore(
 	};
 	const initialAdaptive = attemptAdaptivePlan();
 	if (initialAdaptive.missing) {
-		tasks = markBlocked(
-			tasks,
-			"Adaptive planner did not produce a valid subagent plan.",
-		);
+		tasks = markBlocked(tasks, "Adaptive planner did not produce a valid subagent plan.");
 		await saveRunTasksAsync(manifest, tasks);
-		manifest = updateRunStatus(
-			manifest,
-			"blocked",
-			"Adaptive planner did not produce a valid subagent plan.",
-		);
+		manifest = updateRunStatus(manifest, "blocked", "Adaptive planner did not produce a valid subagent plan.");
 		return { manifest, tasks };
 	}
 	if (initialAdaptive.injected) {
-		manifest = requiresPlanApproval(workflow, input.runtimeConfig)
-			? ensurePlanApprovalRequested(manifest, tasks)
-			: manifest;
+		manifest = requiresPlanApproval(workflow, input.runtimeConfig) ? ensurePlanApprovalRequested(manifest, tasks) : manifest;
 		queueIndex = buildTaskGraphIndex(tasks);
 	} else if (
 		requiresPlanApproval(workflow, input.runtimeConfig) &&
-		(hasPendingMutatingAdaptiveTask(tasks) ||
-			hasPendingMutatingTaskAtBoundary(tasks))
+		(hasPendingMutatingAdaptiveTask(tasks) || hasPendingMutatingTaskAtBoundary(tasks))
 	) {
 		manifest = ensurePlanApprovalRequested(manifest, tasks);
 	}
 	if (manifest.planApproval?.status === "cancelled") {
 		tasks = cancelPlanTasks(tasks, "Plan approval was cancelled.");
 		await saveRunTasksAsync(manifest, tasks);
-		manifest = updateRunStatus(
-			manifest,
-			"cancelled",
-			"Plan approval was cancelled.",
-		);
+		manifest = updateRunStatus(manifest, "cancelled", "Plan approval was cancelled.");
 		return { manifest, tasks };
 	}
-	manifest = writeProgress(
-		manifest,
-		tasks,
-		"team-runner",
-		input.executeWorkers,
-		input.runtimeConfig,
-	);
+	manifest = writeProgress(manifest, tasks, "team-runner", input.executeWorkers, input.runtimeConfig);
 	await saveRunManifestAsync(manifest);
-	const runtimeKind =
-		input.runtime?.kind ??
-		(input.executeWorkers ? "child-process" : "scaffold");
-	saveCrewAgents(
-		manifest,
-		recordsForMaterializedTasks(manifest, tasks, runtimeKind),
-	);
+	const runtimeKind = input.runtime?.kind ?? (input.executeWorkers ? "child-process" : "scaffold");
+	saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
 
 	// Build a workflow phase state machine from workflow steps for precondition tracking.
 	const workflowPhases: PhaseState[] = workflow.steps.map(
 		(step): PhaseState => ({
 			name: step.id,
 			status: "pending",
-			inputs:
-				step.reads === false
-					? []
-					: Array.isArray(step.reads)
-						? step.reads
-						: [],
-			outputs:
-				step.output === false ? [] : step.output ? [step.output] : [],
+			inputs: step.reads === false ? [] : Array.isArray(step.reads) ? step.reads : [],
+			outputs: step.output === false ? [] : step.output ? [step.output] : [],
 		}),
 	);
 	let wfMachine = createWorkflowStateMachine(workflowPhases);
@@ -1111,12 +835,7 @@ async function executeTeamRunCore(
 			const message = `${cancelReason.message} (${cancelReason.code})`;
 			const cancelledTaskIds: string[] = [];
 			tasks = tasks.map((task) => {
-				if (
-					task.status !== "queued" &&
-					task.status !== "running" &&
-					task.status !== "waiting"
-				)
-					return task;
+				if (task.status !== "queued" && task.status !== "running" && task.status !== "waiting") return task;
 				cancelledTaskIds.push(task.id);
 				const base = {
 					...task,
@@ -1129,11 +848,7 @@ async function executeTeamRunCore(
 						...base,
 						terminalEvidence: [
 							...(task.terminalEvidence ?? []),
-							buildSyntheticTerminalEvidence(
-								"worker",
-								cancelReason,
-								task.startedAt,
-							),
+							buildSyntheticTerminalEvidence("worker", cancelReason, task.startedAt),
 						],
 					};
 				}
@@ -1191,20 +906,10 @@ async function executeTeamRunCore(
 				});
 				continue; // loop re-processes the re-queued task
 			}
-			tasks = markBlocked(
-				tasks,
-				`Blocked by failed task '${failed.id}'.`,
-			);
+			tasks = markBlocked(tasks, `Blocked by failed task '${failed.id}'.`);
 			await saveRunTasksAsync(manifest, tasks);
-			saveCrewAgents(
-				manifest,
-				recordsForMaterializedTasks(manifest, tasks, runtimeKind),
-			);
-			manifest = updateRunStatus(
-				manifest,
-				"failed",
-				`Failed at task '${failed.id}'.`,
-			);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
 			return { manifest, tasks };
 		}
 
@@ -1213,47 +918,27 @@ async function executeTeamRunCore(
 		// DAG-based execution plan: when tasks have explicit dependsOn, use the
 		// topological wave planner to determine ready tasks. Fall back to the
 		// existing task-graph-scheduler when no explicit deps exist (backward compat).
-		const completedIds = new Set(
-			tasks
-				.filter(
-					(t) =>
-						t.status === "completed" ||
-						t.status === "needs_attention",
-				)
-				.map((t) => t.id),
-		);
+		const completedIds = new Set(tasks.filter((t) => t.status === "completed" || t.status === "needs_attention").map((t) => t.id));
 		const dagReady = dagReadyTaskIds(tasks, completedIds);
-		const effectiveReady = dagReady ?? snapshot.ready;
+		const readyBeforeFilter = dagReady ?? snapshot.ready;
 
 		// Workflow phase precondition check (non-blocking: log warnings only).
 		if (wfMachine.currentPhaseIndex < wfMachine.phases.length) {
-			const completedArtifacts = manifest.artifacts
-				.filter((a) => a.kind === "result" || a.kind === "summary")
-				.map((a) => a.path);
+			const completedArtifacts = manifest.artifacts.filter((a) => a.kind === "result" || a.kind === "summary").map((a) => a.path);
 			const previousPhaseStatus =
-				wfMachine.currentPhaseIndex > 0
-					? (wfMachine.phases[wfMachine.currentPhaseIndex - 1]
-							?.status ?? "pending")
-					: "completed";
+				wfMachine.currentPhaseIndex > 0 ? (wfMachine.phases[wfMachine.currentPhaseIndex - 1]?.status ?? "pending") : "completed";
 			const wfContext: PhaseGuardContext = {
 				completedArtifacts,
 				previousPhaseStatus,
 				taskResults: tasks
-					.filter(
-						(t) =>
-							t.status === "completed" ||
-							t.status === "needs_attention",
-					)
+					.filter((t) => t.status === "completed" || t.status === "needs_attention")
 					.map((t) => ({
 						taskId: t.id,
 						status: t.status,
 						outputPath: t.resultArtifact?.path,
 					})),
 			};
-			const preconditions = validatePhasePreconditions(
-				wfMachine,
-				wfContext,
-			);
+			const preconditions = validatePhasePreconditions(wfMachine, wfContext);
 			if (!preconditions.ready) {
 				await appendEventAsync(manifest.eventsPath, {
 					type: "workflow.preconditions",
@@ -1261,8 +946,7 @@ async function executeTeamRunCore(
 					message: `Workflow phase '${wfMachine.phases[wfMachine.currentPhaseIndex]?.name}' is missing inputs: ${preconditions.blocking.join(", ")}`,
 					data: {
 						phaseIndex: wfMachine.currentPhaseIndex,
-						phaseName:
-							wfMachine.phases[wfMachine.currentPhaseIndex]?.name,
+						phaseName: wfMachine.phases[wfMachine.currentPhaseIndex]?.name,
 						blocking: preconditions.blocking,
 					},
 				});
@@ -1270,8 +954,7 @@ async function executeTeamRunCore(
 				// Advance the machine past completed phases.
 				while (
 					wfMachine.currentPhaseIndex < wfMachine.phases.length &&
-					wfMachine.phases[wfMachine.currentPhaseIndex]?.status ===
-						"completed"
+					wfMachine.phases[wfMachine.currentPhaseIndex]?.status === "completed"
 				) {
 					wfMachine = {
 						...wfMachine,
@@ -1281,7 +964,7 @@ async function executeTeamRunCore(
 			}
 		}
 
-		const readyRoles = effectiveReady
+		const readyRoles = readyBeforeFilter
 			.map((taskId) => tasks.find((task) => task.id === taskId)?.role)
 			.filter((role): role is string => Boolean(role));
 		const concurrency = resolveBatchConcurrency({
@@ -1290,16 +973,55 @@ async function executeTeamRunCore(
 			teamMaxConcurrency: input.team.maxConcurrency,
 			limitMaxConcurrentWorkers: input.limits?.maxConcurrentWorkers,
 			allowUnboundedConcurrency: input.limits?.allowUnboundedConcurrency,
-			readyCount: effectiveReady.length,
+			readyCount: readyBeforeFilter.length,
 			workspaceMode: manifest.workspaceMode,
 			readyRoles,
 		});
+
+		// Round 25 (M5): serialize on write-path overlap when opted in.
+		// Opt-in via limits.serializeOnPathOverlap; default off (= no behavior change).
+		// filterReadyByWriteOverlap returns the same array when enabled=false, so
+		// production runs pay nothing for the unused code path. When the flag is on,
+		// `serializedReady` MAY be a strict subset of `readyBeforeFilter` (conflicting tasks
+		// deferred to next cycle).
+		const serializedReady = filterReadyByWriteOverlap(
+			readyBeforeFilter,
+			tasks,
+			workflow,
+			concurrency.maxConcurrent,
+			input.limits?.serializeOnPathOverlap === true,
+		);
+
+		// Round 25 (M6): coalesce micro-tasks when opted in.
+		// Default off; when on, groups same-(role,cwd) tasks into coalesced groups
+		// (with write-path safety). In v0.9.17 first ship, we ONLY log the
+		// coalesced group count to the event stream (informational). Actual
+		// dispatching of one-multi-task worker instead of N workers is deferred
+		// to a follow-up — it's a non-trivial prompt-construction change that
+		// deserves its own PR. For now, every coalesced group => one info event.
+		const coalesceEnabled = workflow.coalesceMicroTasks === true;
+		if (coalesceEnabled) {
+			const coalescedGroups = planCoalescedGroups(serializedReady, tasks, workflow, true);
+			for (const group of coalescedGroups) {
+				if (group.tasks.length < 2) continue; // singletons are not interesting
+				await appendEventAsync(manifest.eventsPath, {
+					type: "task.coalesced",
+					runId: manifest.runId,
+					message: `Coalesced ${group.tasks.length} micro-tasks (role=${group.role}, cwd=${group.cwd})`,
+					data: {
+						groupId: group.id,
+						role: group.role,
+						cwd: group.cwd,
+						taskIds: group.tasks.map((task) => task.id),
+					},
+				});
+			}
+		}
 		if (concurrency.reason.includes(";unbounded:")) {
 			await appendEventAsync(manifest.eventsPath, {
 				type: "limits.unbounded",
 				runId: manifest.runId,
-				message:
-					"Unbounded worker concurrency was explicitly enabled for this run.",
+				message: "Unbounded worker concurrency was explicitly enabled for this run.",
 				data: {
 					concurrencyReason: concurrency.reason,
 					maxConcurrent: concurrency.maxConcurrent,
@@ -1307,50 +1029,29 @@ async function executeTeamRunCore(
 			});
 		}
 		const approvalPending = isPlanApprovalPending(manifest);
-		const readyIds = approvalPending
-			? effectiveReady
-			: effectiveReady.slice(0, concurrency.selectedCount);
+		const readyIds = approvalPending ? serializedReady : serializedReady.slice(0, concurrency.selectedCount);
 		const candidateBatch = readyIds
 			.map((id) => tasks.find((task) => task.id === id))
 			.filter((task): task is TeamTaskState => Boolean(task));
 		const readyBatch = approvalPending
-			? candidateBatch
-					.filter((task) => !isMutatingTask(task))
-					.slice(0, concurrency.selectedCount)
+			? candidateBatch.filter((task) => !isMutatingTask(task)).slice(0, concurrency.selectedCount)
 			: candidateBatch;
 		if (readyBatch.length === 0) {
 			if (approvalPending && candidateBatch.some(isMutatingTask)) {
 				await saveRunTasksAsync(manifest, tasks);
-				saveCrewAgents(
-					manifest,
-					recordsForMaterializedTasks(manifest, tasks, runtimeKind),
-				);
-				manifest = updateRunStatus(
-					manifest,
-					"blocked",
-					"Plan approval required before mutating implementation tasks run.",
-				);
+				saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+				manifest = updateRunStatus(manifest, "blocked", "Plan approval required before mutating implementation tasks run.");
 				return { manifest, tasks };
 			}
-			tasks = markBlocked(
-				tasks,
-				"No ready queued task; dependency graph may be invalid.",
-			);
+			tasks = markBlocked(tasks, "No ready queued task; dependency graph may be invalid.");
 			await saveRunTasksAsync(manifest, tasks);
-			saveCrewAgents(
-				manifest,
-				recordsForMaterializedTasks(manifest, tasks, runtimeKind),
-			);
-			manifest = updateRunStatus(
-				manifest,
-				"blocked",
-				"No ready queued task.",
-			);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			manifest = updateRunStatus(manifest, "blocked", "No ready queued task.");
 			return { manifest, tasks };
 		}
 
-		// 2.2 caller migration: batch progress is high-frequency informational.
-		appendEventFireAndForget(manifest.eventsPath, {
+		// 2.2 caller migration: batch progress is high-frequency informational (M7 wire).
+		void appendEventBuffered(manifest.eventsPath, {
 			type: "task.progress",
 			runId: manifest.runId,
 			message: `Starting ready batch with ${readyBatch.length} task(s).`,
@@ -1363,9 +1064,7 @@ async function executeTeamRunCore(
 				selectedCount: readyBatch.length,
 				maxConcurrent: concurrency.maxConcurrent,
 				defaultConcurrency: concurrency.defaultConcurrency,
-				concurrencyReason: approvalPending
-					? `${concurrency.reason};plan-approval-read-only`
-					: concurrency.reason,
+				concurrencyReason: approvalPending ? `${concurrency.reason};plan-approval-read-only` : concurrency.reason,
 			},
 		});
 		// Execute before_task_start hooks for the batch
@@ -1382,22 +1081,14 @@ async function executeTeamRunCore(
 						? {
 								...t,
 								status: "skipped" as const,
-								error:
-									taskReport.reason ??
-									"before_task_start hook blocked execution.",
+								error: taskReport.reason ?? "before_task_start hook blocked execution.",
 							}
 						: t,
 				);
-				manifest = updateRunStatus(
-					manifest,
-					manifest.status,
-					`Task '${task.id}' blocked by hook.`,
-				);
+				manifest = updateRunStatus(manifest, manifest.status, `Task '${task.id}' blocked by hook.`);
 			}
 		}
-		const batchTasks = readyBatch.filter((task) =>
-			tasks.find((t) => t.id === task.id && t.status !== "skipped"),
-		);
+		const batchTasks = readyBatch.filter((task) => tasks.find((t) => t.id === task.id && t.status !== "skipped"));
 		if (batchTasks.length > 1) {
 			await appendEventAsync(manifest.eventsPath, {
 				type: "task.parallel_start",
@@ -1410,327 +1101,253 @@ async function executeTeamRunCore(
 				},
 			});
 		}
-		const results = await mapConcurrent(
-			batchTasks,
-			concurrency.selectedCount,
-			async (task) => {
-				const step = findStep(workflow, task);
-				const agent = findAgent(input.agents, task);
-				const teamRole = input.team.roles.find(
-					(role) => role.name === task.role,
-				);
-				const perTaskRuntime = resolveTaskRuntimeKind(
-					runtimeKind,
-					task.role,
-					input.runtimeConfig?.isolationPolicy,
-				);
-				const baseInput = {
+
+		// M6 real dispatch: when coalesceMicroTasks is enabled, batch the
+		// ready tasks into dispatch units. Multi-task groups are dispatched
+		// as one worker (single cold-start) instead of N. Singletons fall
+		// through to per-task dispatch.
+		const coalescedGroups = planCoalescedGroups(
+			batchTasks.map((t) => t.id),
+			tasks,
+			workflow,
+			coalesceEnabled,
+		);
+		const dispatchUnits = buildDispatchUnits(
+			batchTasks.map((t) => t.id),
+			coalescedGroups,
+		);
+
+		const results = await mapConcurrent(dispatchUnits, concurrency.selectedCount, async (unit) => {
+			// M6 real dispatch path: single worker for N tasks.
+			if (unit.kind === "group") {
+				const groupTasks = unit.group.tasks;
+				const firstTask = groupTasks[0]!;
+				const step = findStep(workflow, firstTask);
+				const agent = findAgent(input.agents, firstTask);
+				const teamRole = input.team.roles.find((role) => role.name === firstTask.role);
+				const perTaskRuntime = resolveTaskRuntimeKind(runtimeKind, firstTask.role, input.runtimeConfig?.isolationPolicy);
+				return runCoalescedTaskGroup({
 					manifest,
 					tasks,
-					task,
+					groupTasks,
 					step,
 					agent,
 					signal: input.signal,
 					executeWorkers: input.executeWorkers,
-					runtimeKind: runtimeKind,
-					taskRuntimeOverride:
-						perTaskRuntime !== runtimeKind
-							? perTaskRuntime
-							: undefined,
-					runtimeConfig: input.runtimeConfig,
-					parentContext: input.parentContext,
-					parentModel: input.parentModel,
-					modelRegistry: input.modelRegistry,
-					modelOverride: input.modelOverride,
-					teamRoleModel: teamRole?.model,
-					teamRoleSkills: teamRole?.skills,
-					skillOverride: input.skillOverride,
-					limits: input.limits,
-					onJsonEvent: input.onJsonEvent,
+					runtimeKind,
 					workspaceId: input.workspaceId,
-				};
-				// #1 (assessment): autoRetry now defaults ON (opt-out via reliability.autoRetry=false).
-				// The dominant v0.9.13 failure was ChildTimeout ("worker became unresponsive") with
-				// ZERO retries because this gate was opt-in. isRetryable() defaults to true when
-				// retryableErrors is empty, so transient hangs now retry up to maxAttempts (3) with
-				// exponential backoff. Set reliability.autoRetry=false to restore old single-shot behavior.
-				if (!shouldUseRetry(input.reliability))
-					return withCorrelation(
-						childCorrelation(manifest.runId, task.id),
-						() => runTeamTask(baseInput),
-					);
-				let lastFailed:
-					| { manifest: TeamRunManifest; tasks: TeamTaskState[] }
-					| undefined;
-				let lastAttemptId: string | undefined;
-				const attemptsSoFar: TaskAttemptState[] = [
-					...(task.attempts ?? []),
-				];
-				const policy = retryPolicyFromConfig(input.reliability);
-				try {
-					return await executeWithRetry(
-						async (attempt, info) => {
-							const startedAt = new Date().toISOString();
-							const inFlightAttempts: TaskAttemptState[] = [
-								...attemptsSoFar,
-								{ attemptId: info.attemptId, startedAt },
-							];
-							input.metricRegistry
-								?.counter(
-									"crew.task.retry_attempt_total",
-									"Retry attempts by run and task",
-								)
-								.inc({
+					onJsonEvent: input.onJsonEvent,
+					teamRole,
+					perTaskRuntime,
+				});
+			}
+			// Singleton path: original per-task dispatch.
+			const task = batchTasks.find((t) => t.id === unit.taskId)!;
+			const step = findStep(workflow, task);
+			const agent = findAgent(input.agents, task);
+			const teamRole = input.team.roles.find((role) => role.name === task.role);
+			const perTaskRuntime = resolveTaskRuntimeKind(runtimeKind, task.role, input.runtimeConfig?.isolationPolicy);
+			const baseInput = {
+				manifest,
+				tasks,
+				task,
+				step,
+				agent,
+				signal: input.signal,
+				executeWorkers: input.executeWorkers,
+				runtimeKind: runtimeKind,
+				taskRuntimeOverride: perTaskRuntime !== runtimeKind ? perTaskRuntime : undefined,
+				runtimeConfig: input.runtimeConfig,
+				parentContext: input.parentContext,
+				parentModel: input.parentModel,
+				modelRegistry: input.modelRegistry,
+				modelOverride: input.modelOverride,
+				teamRoleModel: teamRole?.model,
+				teamRoleSkills: teamRole?.skills,
+				skillOverride: input.skillOverride,
+				limits: input.limits,
+				onJsonEvent: input.onJsonEvent,
+				workspaceId: input.workspaceId,
+			};
+			// #1 (assessment): autoRetry now defaults ON (opt-out via reliability.autoRetry=false).
+			// The dominant v0.9.13 failure was ChildTimeout ("worker became unresponsive") with
+			// ZERO retries because this gate was opt-in. isRetryable() defaults to true when
+			// retryableErrors is empty, so transient hangs now retry up to maxAttempts (3) with
+			// exponential backoff. Set reliability.autoRetry=false to restore old single-shot behavior.
+			if (!shouldUseRetry(input.reliability))
+				return withCorrelation(childCorrelation(manifest.runId, task.id), () => runTeamTask(baseInput));
+			let lastFailed: { manifest: TeamRunManifest; tasks: TeamTaskState[] } | undefined;
+			let lastAttemptId: string | undefined;
+			const attemptsSoFar: TaskAttemptState[] = [...(task.attempts ?? [])];
+			const policy = retryPolicyFromConfig(input.reliability);
+			try {
+				return await executeWithRetry(
+					async (attempt, info) => {
+						const startedAt = new Date().toISOString();
+						const inFlightAttempts: TaskAttemptState[] = [...attemptsSoFar, { attemptId: info.attemptId, startedAt }];
+						input.metricRegistry?.counter("crew.task.retry_attempt_total", "Retry attempts by run and task").inc({
+							runId: manifest.runId,
+							taskId: task.id,
+						});
+						// NOTE: no withRunLock — best-effort only; concurrent writes may cause inconsistency
+						const fresh = loadRunManifestById(manifest.cwd, manifest.runId);
+						const freshManifest = fresh?.manifest ?? manifest;
+						const freshTasks = fresh?.tasks ?? tasks;
+						const freshTask = freshTasks.find((item) => item.id === task.id) ?? task;
+						if (freshTask.status !== "queued" && freshTask.status !== "running")
+							return {
+								manifest: freshManifest,
+								tasks: freshTasks,
+							};
+						const taskWithAttempt: TeamTaskState = {
+							...freshTask,
+							attempts: inFlightAttempts,
+						};
+						const result = await withCorrelation(childCorrelation(freshManifest.runId, task.id), () =>
+							runTeamTask({
+								...baseInput,
+								manifest: freshManifest,
+								tasks: freshTasks,
+								task: taskWithAttempt,
+							}),
+						);
+						const failed = failedTaskFrom(result, task.id);
+						const endedAt = new Date().toISOString();
+						const finishedAttempt: TaskAttemptState = {
+							attemptId: info.attemptId,
+							startedAt,
+							endedAt,
+							...(failed?.error ? { error: failed.error } : {}),
+						};
+						attemptsSoFar.push(finishedAttempt);
+						const withAttempt = result.tasks.map((item) =>
+							item.id === task.id ? { ...item, attempts: [...attemptsSoFar] } : item,
+						);
+						const enriched = {
+							manifest: result.manifest,
+							tasks: withAttempt,
+						};
+						if (failed) {
+							lastFailed = enriched;
+							throw new Error(failed.error ?? `Task ${task.id} failed.`);
+						}
+						input.metricRegistry?.histogram("crew.task.retry_count", "Retries per task", [0, 1, 2, 3, 5, 10]).observe(
+							{
+								runId: manifest.runId,
+								team: input.team.name,
+							},
+							Math.max(0, attempt - 1),
+						);
+						return enriched;
+					},
+					policy,
+					{
+						signal: input.signal,
+						attemptId: (attempt) => `${manifest.runId}:${task.id}:attempt-${attempt}`,
+						onAttemptFailed: (attempt, error, delayMs, info) => {
+							lastAttemptId = info.attemptId;
+							appendEventAsync(manifest.eventsPath, {
+								type: "crew.task.retry_attempt",
+								runId: manifest.runId,
+								taskId: task.id,
+								message: error.message,
+								data: {
+									attempt,
+									attemptId: info.attemptId,
+									delayMs,
+								},
+								metadata: { attemptId: info.attemptId },
+							}).catch((error) => logInternalError("team-runner.retry-attempt", error, `taskId=${task.id}`));
+							input.metricRegistry?.histogram("crew.task.retry_delay_ms", "Retry backoff delay, milliseconds").observe(
+								{
 									runId: manifest.runId,
 									taskId: task.id,
-								});
-							// NOTE: no withRunLock — best-effort only; concurrent writes may cause inconsistency
-							const fresh = loadRunManifestById(
-								manifest.cwd,
-								manifest.runId,
-							);
-							const freshManifest = fresh?.manifest ?? manifest;
-							const freshTasks = fresh?.tasks ?? tasks;
-							const freshTask =
-								freshTasks.find(
-									(item) => item.id === task.id,
-								) ?? task;
-							if (
-								freshTask.status !== "queued" &&
-								freshTask.status !== "running"
-							)
-								return {
-									manifest: freshManifest,
-									tasks: freshTasks,
-								};
-							const taskWithAttempt: TeamTaskState = {
-								...freshTask,
-								attempts: inFlightAttempts,
-							};
-							const result = await withCorrelation(
-								childCorrelation(freshManifest.runId, task.id),
-								() =>
-									runTeamTask({
-										...baseInput,
-										manifest: freshManifest,
-										tasks: freshTasks,
-										task: taskWithAttempt,
-									}),
+								},
+								delayMs,
 							);
-							const failed = failedTaskFrom(result, task.id);
-							const endedAt = new Date().toISOString();
-							const finishedAttempt: TaskAttemptState = {
+						},
+						onRetryGivenUp: (attempts, error, info) => {
+							lastAttemptId = info.attemptId;
+							appendDeadletter(manifest, {
+								runId: manifest.runId,
+								taskId: task.id,
+								reason: "max-retries",
+								attempts,
 								attemptId: info.attemptId,
-								startedAt,
-								endedAt,
-								...(failed?.error
-									? { error: failed.error }
-									: {}),
-							};
-							attemptsSoFar.push(finishedAttempt);
-							const withAttempt = result.tasks.map((item) =>
-								item.id === task.id
-									? { ...item, attempts: [...attemptsSoFar] }
-									: item,
-							);
-							const enriched = {
-								manifest: result.manifest,
-								tasks: withAttempt,
-							};
-							if (failed) {
-								lastFailed = enriched;
-								throw new Error(
-									failed.error ?? `Task ${task.id} failed.`,
-								);
-							}
+								lastError: error.message,
+								timestamp: new Date().toISOString(),
+							});
 							input.metricRegistry
-								?.histogram(
-									"crew.task.retry_count",
-									"Retries per task",
-									[0, 1, 2, 3, 5, 10],
-								)
-								.observe(
-									{
-										runId: manifest.runId,
-										team: input.team.name,
-									},
-									Math.max(0, attempt - 1),
-								);
-							return enriched;
-						},
-						policy,
-						{
-							signal: input.signal,
-							attemptId: (attempt) =>
-								`${manifest.runId}:${task.id}:attempt-${attempt}`,
-							onAttemptFailed: (
-								attempt,
-								error,
-								delayMs,
-								info,
-							) => {
-								lastAttemptId = info.attemptId;
-								appendEventAsync(manifest.eventsPath, {
-									type: "crew.task.retry_attempt",
-									runId: manifest.runId,
-									taskId: task.id,
-									message: error.message,
-									data: {
-										attempt,
-										attemptId: info.attemptId,
-										delayMs,
-									},
-									metadata: { attemptId: info.attemptId },
-								}).catch((error) =>
-									logInternalError(
-										"team-runner.retry-attempt",
-										error,
-										`taskId=${task.id}`,
-									),
-								);
-								input.metricRegistry
-									?.histogram(
-										"crew.task.retry_delay_ms",
-										"Retry backoff delay, milliseconds",
-									)
-									.observe(
-										{
-											runId: manifest.runId,
-											taskId: task.id,
-										},
-										delayMs,
-									);
-							},
-							onRetryGivenUp: (attempts, error, info) => {
-								lastAttemptId = info.attemptId;
-								appendDeadletter(manifest, {
+								?.counter("crew.task.deadletter_total", "Deadletter triggers by reason")
+								.inc({ reason: "max-retries" });
+							input.metricRegistry?.histogram("crew.task.retry_count", "Retries per task", [0, 1, 2, 3, 5, 10]).observe(
+								{
 									runId: manifest.runId,
-									taskId: task.id,
-									reason: "max-retries",
-									attempts,
-									attemptId: info.attemptId,
-									lastError: error.message,
-									timestamp: new Date().toISOString(),
-								});
-								input.metricRegistry
-									?.counter(
-										"crew.task.deadletter_total",
-										"Deadletter triggers by reason",
-									)
-									.inc({ reason: "max-retries" });
-								input.metricRegistry
-									?.histogram(
-										"crew.task.retry_count",
-										"Retries per task",
-										[0, 1, 2, 3, 5, 10],
-									)
-									.observe(
-										{
-											runId: manifest.runId,
-											team: input.team.name,
-										},
-										Math.max(0, attempts - 1),
-									);
-							},
+									team: input.team.name,
+								},
+								Math.max(0, attempts - 1),
+							);
 						},
-					);
-				} catch (retryError) {
-					if (
-						retryError instanceof CrewCancellationError ||
-						input.signal?.aborted
-					) {
-						const reason =
-							retryError instanceof CrewCancellationError
-								? retryError.reason
-								: cancellationReasonFromSignal(input.signal);
-						// NOTE: no withRunLock — best-effort only; concurrent writes may cause inconsistency
-						const fresh = loadRunManifestById(
-							manifest.cwd,
-							manifest.runId,
-						);
-						const freshManifest = fresh?.manifest ?? manifest;
-						const freshTasks = fresh?.tasks ?? tasks;
-						const cancelledTasks = freshTasks.map((item) =>
-							item.id === task.id &&
-							(item.status === "queued" ||
-								item.status === "running")
-								? {
-										...item,
-										status: "cancelled" as const,
-										finishedAt: new Date().toISOString(),
-										error: `${reason.message} (${reason.code})`,
-									}
-								: item,
-						);
-						appendEventAsync(freshManifest.eventsPath, {
-							type: "task.cancelled",
-							runId: freshManifest.runId,
-							taskId: task.id,
-							message: reason.message,
-							data: { reason, phase: "retry" },
-							metadata: lastAttemptId
-								? { attemptId: lastAttemptId }
-								: undefined,
-						}).catch((error) =>
-							logInternalError(
-								"team-runner.cancelled",
-								error,
-								`taskId=${task.id}`,
-							),
-						);
-						return {
-							manifest: updateRunStatus(
-								freshManifest,
-								"cancelled",
-								reason.message,
-							),
-							tasks: cancelledTasks,
-						};
-					}
-					if (lastFailed) return lastFailed;
+					},
+				);
+			} catch (retryError) {
+				if (retryError instanceof CrewCancellationError || input.signal?.aborted) {
+					const reason =
+						retryError instanceof CrewCancellationError ? retryError.reason : cancellationReasonFromSignal(input.signal);
 					// NOTE: no withRunLock — best-effort only; concurrent writes may cause inconsistency
-					const fresh = loadRunManifestById(
-						manifest.cwd,
-						manifest.runId,
-					);
+					const fresh = loadRunManifestById(manifest.cwd, manifest.runId);
 					const freshManifest = fresh?.manifest ?? manifest;
 					const freshTasks = fresh?.tasks ?? tasks;
-					const freshTask =
-						freshTasks.find((item) => item.id === task.id) ?? task;
-					if (
-						freshTask.status !== "queued" &&
-						freshTask.status !== "running"
-					)
-						return { manifest: freshManifest, tasks: freshTasks };
-					return withCorrelation(
-						childCorrelation(freshManifest.runId, task.id),
-						() =>
-							runTeamTask({
-								...baseInput,
-								manifest: freshManifest,
-								tasks: freshTasks,
-								task: freshTask,
-							}),
+					const cancelledTasks = freshTasks.map((item) =>
+						item.id === task.id && (item.status === "queued" || item.status === "running")
+							? {
+									...item,
+									status: "cancelled" as const,
+									finishedAt: new Date().toISOString(),
+									error: `${reason.message} (${reason.code})`,
+								}
+							: item,
 					);
+					appendEventAsync(freshManifest.eventsPath, {
+						type: "task.cancelled",
+						runId: freshManifest.runId,
+						taskId: task.id,
+						message: reason.message,
+						data: { reason, phase: "retry" },
+						metadata: lastAttemptId ? { attemptId: lastAttemptId } : undefined,
+					}).catch((error) => logInternalError("team-runner.cancelled", error, `taskId=${task.id}`));
+					return {
+						manifest: updateRunStatus(freshManifest, "cancelled", reason.message),
+						tasks: cancelledTasks,
+					};
 				}
-			},
-		);
+				if (lastFailed) return lastFailed;
+				// NOTE: no withRunLock — best-effort only; concurrent writes may cause inconsistency
+				const fresh = loadRunManifestById(manifest.cwd, manifest.runId);
+				const freshManifest = fresh?.manifest ?? manifest;
+				const freshTasks = fresh?.tasks ?? tasks;
+				const freshTask = freshTasks.find((item) => item.id === task.id) ?? task;
+				if (freshTask.status !== "queued" && freshTask.status !== "running") return { manifest: freshManifest, tasks: freshTasks };
+				return withCorrelation(childCorrelation(freshManifest.runId, task.id), () =>
+					runTeamTask({
+						...baseInput,
+						manifest: freshManifest,
+						tasks: freshTasks,
+						task: freshTask,
+					}),
+				);
+			}
+		});
 		if (results.length === 0) break;
 		// FIX: Filter out undefined entries from partial results when error occurred
 		// during parallel execution. Other workers may have written partial results
 		// before one threw. Results may be partial - some tasks in-flight at error
 		// time will not have entries in the results array.
-		const validResults = results.filter(
-			(item): item is NonNullable<typeof item> => item !== undefined,
-		);
+		const validResults = results.filter((item): item is NonNullable<typeof item> => item !== undefined);
 		// Guard: if ALL parallel workers threw before returning, validResults is empty.
 		// at(-1)! would crash. Mark the run failed rather than crashing.
 		if (validResults.length === 0) {
-			manifest = updateRunStatus(
-				manifest,
-				"failed",
-				"All parallel tasks failed catastrophically.",
-			);
+			manifest = updateRunStatus(manifest, "failed", "All parallel tasks failed catastrophically.");
 			return { manifest, tasks };
 		}
 		// Reconstruct manifest from the last worker's snapshot. The .artifacts field
@@ -1750,21 +1367,13 @@ async function executeTeamRunCore(
 			const disk = loadRunManifestById(manifest.cwd, manifest.runId);
 			const diskManifest = disk?.manifest ?? manifest;
 			const diskArtifacts = diskManifest.artifacts;
-			const reconciledArtifacts = mergeArtifacts(
-				[
-					...diskArtifacts,
-					...validResults.map((item) => item.manifest.artifacts),
-				].flat(),
-			);
+			const reconciledArtifacts = mergeArtifacts([...diskArtifacts, ...validResults.map((item) => item.manifest.artifacts)].flat());
 			const resultManifest = updateRunStatus(
 				{ ...diskManifest, artifacts: reconciledArtifacts },
 				"running",
 				"Merged task updates from parallel batch.",
 			);
-			const resultTasks = mergeTaskUpdatesPreservingTerminal(
-				tasks,
-				validResults,
-			);
+			const resultTasks = mergeTaskUpdatesPreservingTerminal(tasks, validResults);
 			await saveRunManifestAsync(resultManifest);
 			await saveRunTasksAsync(resultManifest, resultTasks);
 			return { resultManifest, resultTasks };
@@ -1773,13 +1382,7 @@ async function executeTeamRunCore(
 		tasks = mergeResult.resultTasks;
 
 		// Advance workflow phases whose tasks are all in terminal state
-		const terminalStatuses = new Set([
-			"completed",
-			"failed",
-			"skipped",
-			"cancelled",
-			"needs_attention",
-		]);
+		const terminalStatuses = new Set(["completed", "failed", "skipped", "cancelled", "needs_attention"]);
 		const phaseTaskMap = new Map<string, string[]>();
 		for (const task of tasks) {
 			if (!task.stepId) continue;
@@ -1787,11 +1390,7 @@ async function executeTeamRunCore(
 			existing.push(task.id);
 			phaseTaskMap.set(task.stepId, existing);
 		}
-		for (
-			let pi = wfMachine.currentPhaseIndex;
-			pi < wfMachine.phases.length;
-			pi++
-		) {
+		for (let pi = wfMachine.currentPhaseIndex; pi < wfMachine.phases.length; pi++) {
 			const phase = wfMachine.phases[pi]!;
 			const phaseTaskIds = phaseTaskMap.get(phase.name) ?? [];
 			if (phaseTaskIds.length === 0) continue;
@@ -1800,27 +1399,14 @@ async function executeTeamRunCore(
 				return task ? terminalStatuses.has(task.status) : false;
 			});
 			if (!allTerminal) break;
-			if (
-				phase.status !== "completed" &&
-				phase.status !== "failed" &&
-				phase.status !== "skipped"
-			) {
-				const completedArtifacts = manifest.artifacts
-					.filter((a) => a.kind === "result" || a.kind === "summary")
-					.map((a) => a.path);
-				const previousPhaseStatus =
-					pi > 0
-						? (wfMachine.phases[pi - 1]?.status ?? "pending")
-						: "completed";
+			if (phase.status !== "completed" && phase.status !== "failed" && phase.status !== "skipped") {
+				const completedArtifacts = manifest.artifacts.filter((a) => a.kind === "result" || a.kind === "summary").map((a) => a.path);
+				const previousPhaseStatus = pi > 0 ? (wfMachine.phases[pi - 1]?.status ?? "pending") : "completed";
 				const wfContext: PhaseGuardContext = {
 					completedArtifacts,
 					previousPhaseStatus,
 					taskResults: tasks
-						.filter(
-							(t) =>
-								t.status === "completed" ||
-								t.status === "needs_attention",
-						)
+						.filter((t) => t.status === "completed" || t.status === "needs_attention")
 						.map((t) => ({
 							taskId: t.id,
 							status: t.status,
@@ -1831,18 +1417,9 @@ async function executeTeamRunCore(
 				const phaseTasks = phaseTaskIds
 					.map((taskId) => tasks.find((t) => t.id === taskId))
 					.filter((t): t is NonNullable<typeof t> => t !== undefined);
-				const hasFailedOrCancelled = phaseTasks.some(
-					(t) => t.status === "failed" || t.status === "cancelled",
-				);
-				const phaseStatus = hasFailedOrCancelled
-					? "failed"
-					: "completed";
-				const transition = transitionPhase(
-					wfMachine,
-					pi,
-					phaseStatus,
-					wfContext,
-				);
+				const hasFailedOrCancelled = phaseTasks.some((t) => t.status === "failed" || t.status === "cancelled");
+				const phaseStatus = hasFailedOrCancelled ? "failed" : "completed";
+				const transition = transitionPhase(wfMachine, pi, phaseStatus, wfContext);
 				wfMachine = transition.machine;
 				if (transition.guardResult && !transition.guardResult.allowed) {
 					await appendEventAsync(manifest.eventsPath, {
@@ -1858,10 +1435,7 @@ async function executeTeamRunCore(
 					break;
 				}
 				await appendEventAsync(manifest.eventsPath, {
-					type:
-						phaseStatus === "failed"
-							? "workflow.phase_failed"
-							: "workflow.phase_completed",
+					type: phaseStatus === "failed" ? "workflow.phase_failed" : "workflow.phase_completed",
 					runId: manifest.runId,
 					message: `Workflow phase '${phase.name}' ${phaseStatus}.`,
 					data: { phaseIndex: pi, phaseStatus },
@@ -1870,24 +1444,14 @@ async function executeTeamRunCore(
 			wfMachine = { ...wfMachine, currentPhaseIndex: pi + 1 };
 		}
 
-		const cancelledResult = results.find(
-			(item) => item.manifest.status === "cancelled",
-		);
+		const cancelledResult = results.find((item) => item.manifest.status === "cancelled");
 		if (cancelledResult || input.signal?.aborted) {
-			const reason = input.signal?.aborted
-				? cancellationReasonFromSignal(input.signal)
-				: undefined;
-			const message =
-				reason?.message ??
-				cancelledResult?.manifest.summary ??
-				"Run cancelled during task execution.";
+			const reason = input.signal?.aborted ? cancellationReasonFromSignal(input.signal) : undefined;
+			const message = reason?.message ?? cancelledResult?.manifest.summary ?? "Run cancelled during task execution.";
 			manifest = { ...manifest, status: "running" };
 			manifest = updateRunStatus(manifest, "cancelled", message);
 			await saveRunTasksAsync(manifest, tasks);
-			saveCrewAgents(
-				manifest,
-				recordsForMaterializedTasks(manifest, tasks, runtimeKind),
-			);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
 			await saveRunManifestAsync(manifest);
 			await appendEventAsync(manifest.eventsPath, {
 				type: "run.cancelled",
@@ -1904,56 +1468,31 @@ async function executeTeamRunCore(
 		queueIndex = buildTaskGraphIndex(tasks);
 		const injectedAfterBatch = attemptAdaptivePlan();
 		if (injectedAfterBatch.missing) {
-			tasks = markBlocked(
-				tasks,
-				"Adaptive planner did not produce a valid subagent plan.",
-			);
+			tasks = markBlocked(tasks, "Adaptive planner did not produce a valid subagent plan.");
 			await saveRunTasksAsync(manifest, tasks);
-			saveCrewAgents(
-				manifest,
-				recordsForMaterializedTasks(manifest, tasks, runtimeKind),
-			);
-			manifest = updateRunStatus(
-				manifest,
-				"blocked",
-				"Adaptive planner did not produce a valid subagent plan.",
-			);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			manifest = updateRunStatus(manifest, "blocked", "Adaptive planner did not produce a valid subagent plan.");
 			return { manifest, tasks };
 		}
 		if (injectedAfterBatch.injected) {
-			manifest = requiresPlanApproval(workflow, input.runtimeConfig)
-				? ensurePlanApprovalRequested(manifest, tasks)
-				: manifest;
+			manifest = requiresPlanApproval(workflow, input.runtimeConfig) ? ensurePlanApprovalRequested(manifest, tasks) : manifest;
 			queueIndex = buildTaskGraphIndex(tasks);
 		} else if (
 			requiresPlanApproval(workflow, input.runtimeConfig) &&
-			(hasPendingMutatingAdaptiveTask(tasks) ||
-				hasPendingMutatingTaskAtBoundary(tasks))
+			(hasPendingMutatingAdaptiveTask(tasks) || hasPendingMutatingTaskAtBoundary(tasks))
 		) {
 			manifest = ensurePlanApprovalRequested(manifest, tasks);
 		}
 		if (manifest.planApproval?.status === "cancelled") {
 			tasks = cancelPlanTasks(tasks, "Plan approval was cancelled.");
 			await saveRunTasksAsync(manifest, tasks);
-			saveCrewAgents(
-				manifest,
-				recordsForMaterializedTasks(manifest, tasks, runtimeKind),
-			);
-			manifest = updateRunStatus(
-				manifest,
-				"cancelled",
-				"Plan approval was cancelled.",
-			);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			manifest = updateRunStatus(manifest, "cancelled", "Plan approval was cancelled.");
 			return { manifest, tasks };
 		}
 		await saveRunTasksAsync(manifest, tasks);
-		saveCrewAgents(
-			manifest,
-			recordsForMaterializedTasks(manifest, tasks, runtimeKind),
-		);
-		const completedBatch = tasks.filter((t) =>
-			batchTasks.some((bt) => bt.id === t.id),
-		);
+		saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+		const completedBatch = tasks.filter((t) => batchTasks.some((bt) => bt.id === t.id));
 		const batchArtifact = writeArtifact(manifest.artifactsRoot, {
 			kind: "summary",
 			relativePath: `batches/${batchTasks.map((task) => task.id).join("+")}.md`,
@@ -1968,19 +1507,9 @@ async function executeTeamRunCore(
 		});
 		manifest = {
 			...manifest,
-			artifacts: mergeArtifacts([
-				...manifest.artifacts,
-				batchArtifact,
-				...(groupDelivery?.artifact ? [groupDelivery.artifact] : []),
-			]),
+			artifacts: mergeArtifacts([...manifest.artifacts, batchArtifact, ...(groupDelivery?.artifact ? [groupDelivery.artifact] : [])]),
 		};
-		manifest = writeProgress(
-			manifest,
-			tasks,
-			"team-runner",
-			input.executeWorkers,
-			input.runtimeConfig,
-		);
+		manifest = writeProgress(manifest, tasks, "team-runner", input.executeWorkers, input.runtimeConfig);
 		await saveRunManifestAsync(manifest);
 	}
 
@@ -1998,10 +1527,7 @@ async function executeTeamRunCore(
 	if (effectivenessDecision) {
 		manifest = {
 			...manifest,
-			policyDecisions: [
-				...(manifest.policyDecisions ?? []),
-				effectivenessDecision,
-			],
+			policyDecisions: [...(manifest.policyDecisions ?? []), effectivenessDecision],
 			updatedAt: new Date().toISOString(),
 		};
 		await appendEventAsync(manifest.eventsPath, {
@@ -2011,62 +1537,27 @@ async function executeTeamRunCore(
 			data: { effectiveness, policyDecision: effectivenessDecision },
 		});
 	}
-	const blockingDecision = manifest.policyDecisions?.find(
-		(item) => item.action === "block" || item.action === "escalate",
-	);
+	const blockingDecision = manifest.policyDecisions?.find((item) => item.action === "block" || item.action === "escalate");
 	if (failed) {
-		manifest = updateRunStatus(
-			manifest,
-			"failed",
-			`Failed at task '${failed.id}'.`,
-		);
+		manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
 	} else if (waiting) {
-		manifest = updateRunStatus(
-			manifest,
-			"blocked",
-			`Waiting for response to task '${waiting.id}'.`,
-		);
+		manifest = updateRunStatus(manifest, "blocked", `Waiting for response to task '${waiting.id}'.`);
 	} else if (running) {
-		manifest = updateRunStatus(
-			manifest,
-			"blocked",
-			`Task '${running.id}' is still running.`,
-		);
+		manifest = updateRunStatus(manifest, "blocked", `Task '${running.id}' is still running.`);
 	} else if (effectiveness.severity === "failed") {
-		manifest = updateRunStatus(
-			manifest,
-			"failed",
-			effectivenessDecision?.message ?? "Run effectiveness guard failed.",
-		);
+		manifest = updateRunStatus(manifest, "failed", effectivenessDecision?.message ?? "Run effectiveness guard failed.");
 	} else if (effectiveness.severity === "blocked") {
-		manifest = updateRunStatus(
-			manifest,
-			"blocked",
-			effectivenessDecision?.message ??
-				"Run effectiveness guard blocked completion.",
-		);
+		manifest = updateRunStatus(manifest, "blocked", effectivenessDecision?.message ?? "Run effectiveness guard blocked completion.");
 	} else if (blockingDecision) {
-		manifest = updateRunStatus(
-			manifest,
-			"blocked",
-			blockingDecision.message,
-		);
+		manifest = updateRunStatus(manifest, "blocked", blockingDecision.message);
 	} else {
 		manifest = updateRunStatus(
 			manifest,
 			"completed",
-			input.executeWorkers
-				? "Team workflow completed."
-				: "Team workflow scaffold completed without launching child workers.",
+			input.executeWorkers ? "Team workflow completed." : "Team workflow scaffold completed without launching child workers.",
 		);
 	}
-	manifest = writeProgress(
-		manifest,
-		tasks,
-		"team-runner",
-		input.executeWorkers,
-		input.runtimeConfig,
-	);
+	manifest = writeProgress(manifest, tasks, "team-runner", input.executeWorkers, input.runtimeConfig);
 	await saveRunManifestAsync(manifest);
 	const usage = aggregateUsage(tasks);
 	const summaryArtifact = writeArtifact(manifest.artifactsRoot, {
@@ -2086,17 +1577,10 @@ async function executeTeamRunCore(
 			...tasks.map(formatTaskProgress),
 			"",
 			"## Effectiveness",
-			...runEffectivenessLines(
-				manifest,
-				tasks,
-				input.executeWorkers,
-				input.runtimeConfig,
-			),
+			...runEffectivenessLines(manifest, tasks, input.executeWorkers, input.runtimeConfig),
 			"",
 			"## Policy decisions",
-			...(manifest.policyDecisions?.length
-				? summarizePolicyDecisions(manifest.policyDecisions)
-				: ["- (none)"]),
+			...(manifest.policyDecisions?.length ? summarizePolicyDecisions(manifest.policyDecisions) : ["- (none)"]),
 			"",
 		].join("\n"),
 	});
@@ -2125,9 +1609,7 @@ async function executeTeamRunCore(
 	// health feature) AND created junk dirs that the recursive state watcher then
 	// attached extra inotify watches to. Fix: compute the real crew root (3 up)
 	// and make HEALTH_DIR relative to it.
-	const crewRoot = path.dirname(
-		path.dirname(path.dirname(finalManifest.stateRoot)),
-	);
+	const crewRoot = path.dirname(path.dirname(path.dirname(finalManifest.stateRoot)));
 	const healthStore = new HealthStore(crewRoot);
 	healthStore.saveSnapshot({
 		runId: finalManifest.runId,